Merge /spare/repo/linux-2.6/

16 files changed, 1951 insertions, 1138 deletions

diff --git a/drivers/message/i2o/Kconfig b/drivers/message/i2o/Kconfig
index 8d132b0d6b12..06e8eb19a05c 100644
--- a/drivers/message/i2o/Kconfig
+++ b/drivers/message/i2o/Kconfig
@@ -24,10 +24,28 @@ config I2O
 
           If unsure, say N.
 
+config I2O_EXT_ADAPTEC
+        bool "Enable Adaptec extensions"
+        depends on I2O
+        default y
+        ---help---
+          Say Y for support of raidutils for Adaptec I2O controllers. You also
+          have to say Y to "I2O Configuration support", "I2O SCSI OSM" below
+          and to "SCSI generic support" under "SCSI device configuration".
+
+config I2O_EXT_ADAPTEC_DMA64
+        bool "Enable 64-bit DMA"
+        depends on I2O_EXT_ADAPTEC && ( 64BIT || HIGHMEM64G )
+        default y
+        ---help---
+          Say Y for support of 64-bit DMA transfer mode on Adaptec I2O
+          controllers.
+          Note: You need at least firmware version 3709.
+
 config I2O_CONFIG
         tristate "I2O Configuration support"
-        depends on PCI && I2O
-        help
+        depends on I2O
+        ---help---
           Say Y for support of the configuration interface for the I2O adapters.
           If you have a RAID controller from Adaptec and you want to use the
           raidutils to manage your RAID array, you have to say Y here.
@@ -35,10 +53,28 @@ config I2O_CONFIG
           To compile this support as a module, choose M here: the
           module will be called i2o_config.
 
+config I2O_CONFIG_OLD_IOCTL
+        bool "Enable ioctls (OBSOLETE)"
+        depends on I2O_CONFIG
+        default y
+        ---help---
+          Enables old ioctls.
+
+config I2O_BUS
+        tristate "I2O Bus Adapter OSM"
+        depends on I2O
+        ---help---
+          Include support for the I2O Bus Adapter OSM. The Bus Adapter OSM
+          provides access to the busses on the I2O controller. The main purpose
+          is to rescan the bus to find new devices.
+
+          To compile this support as a module, choose M here: the
+          module will be called i2o_bus.
+
 config I2O_BLOCK
         tristate "I2O Block OSM"
         depends on I2O
-        help
+        ---help---
           Include support for the I2O Block OSM. The Block OSM presents disk
           and other structured block devices to the operating system. If you
           are using an RAID controller, you could access the array only by
@@ -51,7 +87,7 @@ config I2O_BLOCK
 config I2O_SCSI
         tristate "I2O SCSI OSM"
         depends on I2O && SCSI
-        help
+        ---help---
           Allows direct SCSI access to SCSI devices on a SCSI or FibreChannel
           I2O controller. You can use both the SCSI and Block OSM together if
           you wish. To access a RAID array, you must use the Block OSM driver.
@@ -63,7 +99,7 @@ config I2O_SCSI
 config I2O_PROC
         tristate "I2O /proc support"
         depends on I2O
-        help
+        ---help---
           If you say Y here and to "/proc file system support", you will be
           able to read I2O related information from the virtual directory
           /proc/i2o.
diff --git a/drivers/message/i2o/Makefile b/drivers/message/i2o/Makefile
index aabc6cdc3fce..2c2e39aa1efa 100644
--- a/drivers/message/i2o/Makefile
+++ b/drivers/message/i2o/Makefile
@@ -6,8 +6,11 @@
 #
 
 i2o_core-y              += iop.o driver.o device.o debug.o pci.o exec-osm.o
+i2o_bus-y               += bus-osm.o
+i2o_config-y            += config-osm.o
 obj-$(CONFIG_I2O)       += i2o_core.o
 obj-$(CONFIG_I2O_CONFIG)+= i2o_config.o
+obj-$(CONFIG_I2O_BUS)   += i2o_bus.o
 obj-$(CONFIG_I2O_BLOCK) += i2o_block.o
 obj-$(CONFIG_I2O_SCSI)  += i2o_scsi.o
 obj-$(CONFIG_I2O_PROC)  += i2o_proc.o
diff --git a/drivers/message/i2o/bus-osm.c b/drivers/message/i2o/bus-osm.c
new file mode 100644
index 000000000000..151b228e1cb3
--- /dev/null
+++ b/drivers/message/i2o/bus-osm.c
@@ -0,0 +1,164 @@
+/*
+ *      Bus Adapter OSM
+ *
+ *      Copyright (C) 2005      Markus Lidel <Markus.Lidel@shadowconnect.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 the
+ *      Free Software Foundation; either version 2 of the License, or (at your
+ *      option) any later version.
+ *
+ *      Fixes/additions:
+ *              Markus Lidel <Markus.Lidel@shadowconnect.com>
+ *                      initial version.
+ */
+
+#include <linux/module.h>
+#include <linux/i2o.h>
+
+#define OSM_NAME        "bus-osm"
+#define OSM_VERSION     "$Rev$"
+#define OSM_DESCRIPTION "I2O Bus Adapter OSM"
+
+static struct i2o_driver i2o_bus_driver;
+
+/* Bus OSM class handling definition */
+static struct i2o_class_id i2o_bus_class_id[] = {
+        {I2O_CLASS_BUS_ADAPTER},
+        {I2O_CLASS_END}
+};
+
+/**
+ *      i2o_bus_scan - Scan the bus for new devices
+ *      @dev: I2O device of the bus, which should be scanned
+ *
+ *      Scans the bus dev for new / removed devices. After the scan a new LCT
+ *      will be fetched automatically.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static int i2o_bus_scan(struct i2o_device *dev)
+{
+        struct i2o_message __iomem *msg;
+        u32 m;
+
+        m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);
+        if (m == I2O_QUEUE_EMPTY)
+                return -ETIMEDOUT;
+
+        writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
+        writel(I2O_CMD_BUS_SCAN << 24 | HOST_TID << 12 | dev->lct_data.tid,
+               &msg->u.head[1]);
+
+        return i2o_msg_post_wait(dev->iop, m, 60);
+};
+
+/**
+ *      i2o_bus_store_scan - Scan the I2O Bus Adapter
+ *      @d: device which should be scanned
+ *
+ *      Returns count.
+ */
+static ssize_t i2o_bus_store_scan(struct device *d, struct device_attribute *attr, const char *buf,
+                                  size_t count)
+{
+        struct i2o_device *i2o_dev = to_i2o_device(d);
+        int rc;
+
+        if ((rc = i2o_bus_scan(i2o_dev)))
+                osm_warn("bus scan failed %d\n", rc);
+
+        return count;
+}
+
+/* Bus Adapter OSM device attributes */
+static DEVICE_ATTR(scan, S_IWUSR, NULL, i2o_bus_store_scan);
+
+/**
+ *      i2o_bus_probe - verify if dev is a I2O Bus Adapter device and install it
+ *      @dev: device to verify if it is a I2O Bus Adapter device
+ *
+ *      Because we want all Bus Adapters always return 0.
+ *
+ *      Returns 0.
+ */
+static int i2o_bus_probe(struct device *dev)
+{
+        struct i2o_device *i2o_dev = to_i2o_device(get_device(dev));
+
+        device_create_file(dev, &dev_attr_scan);
+
+        osm_info("device added (TID: %03x)\n", i2o_dev->lct_data.tid);
+
+        return 0;
+};
+
+/**
+ *      i2o_bus_remove - remove the I2O Bus Adapter device from the system again
+ *      @dev: I2O Bus Adapter device which should be removed
+ *
+ *      Always returns 0.
+ */
+static int i2o_bus_remove(struct device *dev)
+{
+        struct i2o_device *i2o_dev = to_i2o_device(dev);
+
+        device_remove_file(dev, &dev_attr_scan);
+
+        put_device(dev);
+
+        osm_info("device removed (TID: %03x)\n", i2o_dev->lct_data.tid);
+
+        return 0;
+};
+
+/* Bus Adapter OSM driver struct */
+static struct i2o_driver i2o_bus_driver = {
+        .name = OSM_NAME,
+        .classes = i2o_bus_class_id,
+        .driver = {
+                   .probe = i2o_bus_probe,
+                   .remove = i2o_bus_remove,
+                   },
+};
+
+/**
+ *      i2o_bus_init - Bus Adapter OSM initialization function
+ *
+ *      Only register the Bus Adapter OSM in the I2O core.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static int __init i2o_bus_init(void)
+{
+        int rc;
+
+        printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
+
+        /* Register Bus Adapter OSM into I2O core */
+        rc = i2o_driver_register(&i2o_bus_driver);
+        if (rc) {
+                osm_err("Could not register Bus Adapter OSM\n");
+                return rc;
+        }
+
+        return 0;
+};
+
+/**
+ *      i2o_bus_exit - Bus Adapter OSM exit function
+ *
+ *      Unregisters Bus Adapter OSM from I2O core.
+ */
+static void __exit i2o_bus_exit(void)
+{
+        i2o_driver_unregister(&i2o_bus_driver);
+};
+
+MODULE_AUTHOR("Markus Lidel <Markus.Lidel@shadowconnect.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION(OSM_DESCRIPTION);
+MODULE_VERSION(OSM_VERSION);
+
+module_init(i2o_bus_init);
+module_exit(i2o_bus_exit);
diff --git a/drivers/message/i2o/config-osm.c b/drivers/message/i2o/config-osm.c
new file mode 100644
index 000000000000..d0267609a949
--- /dev/null
+++ b/drivers/message/i2o/config-osm.c
@@ -0,0 +1,579 @@
+/*
+ *      Configuration OSM
+ *
+ *      Copyright (C) 2005      Markus Lidel <Markus.Lidel@shadowconnect.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 the
+ *      Free Software Foundation; either version 2 of the License, or (at your
+ *      option) any later version.
+ *
+ *      Fixes/additions:
+ *              Markus Lidel <Markus.Lidel@shadowconnect.com>
+ *                      initial version.
+ */
+
+#include <linux/module.h>
+#include <linux/i2o.h>
+#include <linux/namei.h>
+
+#include <asm/uaccess.h>
+
+#define OSM_NAME        "config-osm"
+#define OSM_VERSION     "1.248"
+#define OSM_DESCRIPTION "I2O Configuration OSM"
+
+/* access mode user rw */
+#define S_IWRSR (S_IRUSR | S_IWUSR)
+
+static struct i2o_driver i2o_config_driver;
+
+/* Special file operations for sysfs */
+struct fops_attribute {
+        struct bin_attribute bin;
+        struct file_operations fops;
+};
+
+/**
+ *      sysfs_read_dummy
+ */
+static ssize_t sysfs_read_dummy(struct kobject *kobj, char *buf, loff_t offset,
+                                size_t count)
+{
+        return 0;
+};
+
+/**
+ *      sysfs_write_dummy
+ */
+static ssize_t sysfs_write_dummy(struct kobject *kobj, char *buf, loff_t offset,
+                                 size_t count)
+{
+        return 0;
+};
+
+/**
+ *      sysfs_create_fops_file - Creates attribute with special file operations
+ *      @kobj: kobject which should contains the attribute
+ *      @attr: attributes which should be used to create file
+ *
+ *      First creates attribute @attr in kobject @kobj. If it is the first time
+ *      this function is called, merge old fops from sysfs with new one and
+ *      write it back. Afterwords the new fops will be set for the created
+ *      attribute.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static int sysfs_create_fops_file(struct kobject *kobj,
+                                  struct fops_attribute *attr)
+{
+        struct file_operations tmp, *fops;
+        struct dentry *d;
+        struct qstr qstr;
+        int rc;
+
+        fops = &attr->fops;
+
+        if (fops->read)
+                attr->bin.read = sysfs_read_dummy;
+
+        if (fops->write)
+                attr->bin.write = sysfs_write_dummy;
+
+        if ((rc = sysfs_create_bin_file(kobj, &attr->bin)))
+                return rc;
+
+        qstr.name = attr->bin.attr.name;
+        qstr.len = strlen(qstr.name);
+        qstr.hash = full_name_hash(qstr.name, qstr.len);
+
+        if ((d = lookup_hash(&qstr, kobj->dentry))) {
+                if (!fops->owner) {
+                        memcpy(&tmp, d->d_inode->i_fop, sizeof(tmp));
+                        if (fops->read)
+                                tmp.read = fops->read;
+                        if (fops->write)
+                                tmp.write = fops->write;
+                        memcpy(fops, &tmp, sizeof(tmp));
+                }
+
+                d->d_inode->i_fop = fops;
+        } else
+                sysfs_remove_bin_file(kobj, &attr->bin);
+
+        return -ENOENT;
+};
+
+/**
+ *      sysfs_remove_fops_file - Remove attribute with special file operations
+ *      @kobj: kobject which contains the attribute
+ *      @attr: attributes which are used to create file
+ *
+ *      Only wrapper arround sysfs_remove_bin_file()
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static inline int sysfs_remove_fops_file(struct kobject *kobj,
+                                         struct fops_attribute *attr)
+{
+        return sysfs_remove_bin_file(kobj, &attr->bin);
+};
+
+/**
+ *      i2o_config_read_hrt - Returns the HRT of the controller
+ *      @kob: kernel object handle
+ *      @buf: buffer into which the HRT should be copied
+ *      @off: file offset
+ *      @count: number of bytes to read
+ *
+ *      Put @count bytes starting at @off into @buf from the HRT of the I2O
+ *      controller corresponding to @kobj.
+ *
+ *      Returns number of bytes copied into buffer.
+ */
+static ssize_t i2o_config_read_hrt(struct kobject *kobj, char *buf,
+                                   loff_t offset, size_t count)
+{
+        struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
+        i2o_hrt *hrt = c->hrt.virt;
+
+        u32 size = (hrt->num_entries * hrt->entry_len + 2) * 4;
+
+        if (offset > size)
+                return 0;
+
+        if (offset + count > size)
+                count = size - offset;
+
+        memcpy(buf, (u8 *) hrt + offset, count);
+
+        return count;
+};
+
+/**
+ *      i2o_config_read_lct - Returns the LCT of the controller
+ *      @kob: kernel object handle
+ *      @buf: buffer into which the LCT should be copied
+ *      @off: file offset
+ *      @count: number of bytes to read
+ *
+ *      Put @count bytes starting at @off into @buf from the LCT of the I2O
+ *      controller corresponding to @kobj.
+ *
+ *      Returns number of bytes copied into buffer.
+ */
+static ssize_t i2o_config_read_lct(struct kobject *kobj, char *buf,
+                                   loff_t offset, size_t count)
+{
+        struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
+        u32 size = c->lct->table_size * 4;
+
+        if (offset > size)
+                return 0;
+
+        if (offset + count > size)
+                count = size - offset;
+
+        memcpy(buf, (u8 *) c->lct + offset, count);
+
+        return count;
+};
+
+#define I2O_CONFIG_SW_ATTR(_name,_mode,_type,_swid) \
+static ssize_t i2o_config_##_name##_read(struct file *file, char __user *buf, size_t count, loff_t * offset) { \
+        return i2o_config_sw_read(file, buf, count, offset, _type, _swid); \
+};\
+\
+static ssize_t i2o_config_##_name##_write(struct file *file, const char __user *buf, size_t count, loff_t * offset) { \
+        return i2o_config_sw_write(file, buf, count, offset, _type, _swid); \
+}; \
+\
+static struct fops_attribute i2o_config_attr_##_name = { \
+        .bin = { .attr = { .name = __stringify(_name), .mode = _mode, \
+                           .owner = THIS_MODULE }, \
+                 .size = 0, }, \
+        .fops = { .write = i2o_config_##_name##_write, \
+                  .read = i2o_config_##_name##_read} \
+};
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+
+/**
+ *      i2o_config_dpt_reagion - Converts type and id to flash region
+ *      @swtype: type of software module reading
+ *      @swid: id of software which should be read
+ *
+ *      Converts type and id from I2O spec to the matching region for DPT /
+ *      Adaptec controllers.
+ *
+ *      Returns region which match type and id or -1 on error.
+ */
+static u32 i2o_config_dpt_region(u8 swtype, u8 swid)
+{
+        switch (swtype) {
+        case I2O_SOFTWARE_MODULE_IRTOS:
+                /*
+                 * content: operation firmware
+                 * region size:
+                 *      0xbc000 for 2554, 3754, 2564, 3757
+                 *      0x170000 for 2865
+                 *      0x17c000 for 3966
+                 */
+                if (!swid)
+                        return 0;
+
+                break;
+
+        case I2O_SOFTWARE_MODULE_IOP_PRIVATE:
+                /*
+                 * content: BIOS and SMOR
+                 * BIOS size: first 0x8000 bytes
+                 * region size:
+                 *      0x40000 for 2554, 3754, 2564, 3757
+                 *      0x80000 for 2865, 3966
+                 */
+                if (!swid)
+                        return 1;
+
+                break;
+
+        case I2O_SOFTWARE_MODULE_IOP_CONFIG:
+                switch (swid) {
+                case 0:
+                        /*
+                         * content: NVRAM defaults
+                         * region size: 0x2000 bytes
+                         */
+                        return 2;
+                case 1:
+                        /*
+                         * content: serial number
+                         * region size: 0x2000 bytes
+                         */
+                        return 3;
+                }
+                break;
+        }
+
+        return -1;
+};
+
+#endif
+
+/**
+ *      i2o_config_sw_read - Read a software module from controller
+ *      @file: file pointer
+ *      @buf: buffer into which the data should be copied
+ *      @count: number of bytes to read
+ *      @off: file offset
+ *      @swtype: type of software module reading
+ *      @swid: id of software which should be read
+ *
+ *      Transfers @count bytes at offset @offset from IOP into buffer using
+ *      type @swtype and id @swid as described in I2O spec.
+ *
+ *      Returns number of bytes copied into buffer or error code on failure.
+ */
+static ssize_t i2o_config_sw_read(struct file *file, char __user * buf,
+                                  size_t count, loff_t * offset, u8 swtype,
+                                  u32 swid)
+{
+        struct sysfs_dirent *sd = file->f_dentry->d_parent->d_fsdata;
+        struct kobject *kobj = sd->s_element;
+        struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
+        u32 m, function = I2O_CMD_SW_UPLOAD;
+        struct i2o_dma buffer;
+        struct i2o_message __iomem *msg;
+        u32 __iomem *mptr;
+        int rc, status;
+
+        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
+        if (m == I2O_QUEUE_EMPTY)
+                return -EBUSY;
+
+        mptr = &msg->body[3];
+
+        if ((rc = i2o_dma_alloc(&c->pdev->dev, &buffer, count, GFP_KERNEL))) {
+                i2o_msg_nop(c, m);
+                return rc;
+        }
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                mptr = &msg->body[4];
+                function = I2O_CMD_PRIVATE;
+
+                writel(TEN_WORD_MSG_SIZE | SGL_OFFSET_8, &msg->u.head[0]);
+
+                writel(I2O_VENDOR_DPT << 16 | I2O_DPT_FLASH_READ,
+                       &msg->body[0]);
+                writel(i2o_config_dpt_region(swtype, swid), &msg->body[1]);
+                writel(*offset, &msg->body[2]);
+                writel(count, &msg->body[3]);
+        } else
+#endif
+                writel(NINE_WORD_MSG_SIZE | SGL_OFFSET_7, &msg->u.head[0]);
+
+        writel(0xD0000000 | count, mptr++);
+        writel(buffer.phys, mptr);
+
+        writel(function << 24 | HOST_TID << 12 | ADAPTER_TID, &msg->u.head[1]);
+        writel(i2o_config_driver.context, &msg->u.head[2]);
+        writel(0, &msg->u.head[3]);
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (!c->adaptec)
+#endif
+        {
+                writel((u32) swtype << 16 | (u32) 1 << 8, &msg->body[0]);
+                writel(0, &msg->body[1]);
+                writel(swid, &msg->body[2]);
+        }
+
+        status = i2o_msg_post_wait_mem(c, m, 60, &buffer);
+
+        if (status == I2O_POST_WAIT_OK) {
+                if (!(rc = copy_to_user(buf, buffer.virt, count))) {
+                        rc = count;
+                        *offset += count;
+                }
+        } else
+                rc = -EIO;
+
+        if (status != -ETIMEDOUT)
+                i2o_dma_free(&c->pdev->dev, &buffer);
+
+        return rc;
+};
+
+/**
+ *      i2o_config_sw_write - Write a software module to controller
+ *      @file: file pointer
+ *      @buf: buffer into which the data should be copied
+ *      @count: number of bytes to read
+ *      @off: file offset
+ *      @swtype: type of software module writing
+ *      @swid: id of software which should be written
+ *
+ *      Transfers @count bytes at offset @offset from buffer to IOP using
+ *      type @swtype and id @swid as described in I2O spec.
+ *
+ *      Returns number of bytes copied from buffer or error code on failure.
+ */
+static ssize_t i2o_config_sw_write(struct file *file, const char __user * buf,
+                                   size_t count, loff_t * offset, u8 swtype,
+                                   u32 swid)
+{
+        struct sysfs_dirent *sd = file->f_dentry->d_parent->d_fsdata;
+        struct kobject *kobj = sd->s_element;
+        struct i2o_controller *c = kobj_to_i2o_device(kobj)->iop;
+        u32 m, function = I2O_CMD_SW_DOWNLOAD;
+        struct i2o_dma buffer;
+        struct i2o_message __iomem *msg;
+        u32 __iomem *mptr;
+        int rc, status;
+
+        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
+        if (m == I2O_QUEUE_EMPTY)
+                return -EBUSY;
+
+        mptr = &msg->body[3];
+
+        if ((rc = i2o_dma_alloc(&c->pdev->dev, &buffer, count, GFP_KERNEL)))
+                goto nop_msg;
+
+        if ((rc = copy_from_user(buffer.virt, buf, count)))
+                goto free_buffer;
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                mptr = &msg->body[4];
+                function = I2O_CMD_PRIVATE;
+
+                writel(TEN_WORD_MSG_SIZE | SGL_OFFSET_8, &msg->u.head[0]);
+
+                writel(I2O_VENDOR_DPT << 16 | I2O_DPT_FLASH_WRITE,
+                       &msg->body[0]);
+                writel(i2o_config_dpt_region(swtype, swid), &msg->body[1]);
+                writel(*offset, &msg->body[2]);
+                writel(count, &msg->body[3]);
+        } else
+#endif
+                writel(NINE_WORD_MSG_SIZE | SGL_OFFSET_7, &msg->u.head[0]);
+
+        writel(0xD4000000 | count, mptr++);
+        writel(buffer.phys, mptr);
+
+        writel(function << 24 | HOST_TID << 12 | ADAPTER_TID, &msg->u.head[1]);
+        writel(i2o_config_driver.context, &msg->u.head[2]);
+        writel(0, &msg->u.head[3]);
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (!c->adaptec)
+#endif
+        {
+                writel((u32) swtype << 16 | (u32) 1 << 8, &msg->body[0]);
+                writel(0, &msg->body[1]);
+                writel(swid, &msg->body[2]);
+        }
+
+        status = i2o_msg_post_wait_mem(c, m, 60, &buffer);
+
+        if (status != -ETIMEDOUT)
+                i2o_dma_free(&c->pdev->dev, &buffer);
+
+        if (status != I2O_POST_WAIT_OK)
+                return -EIO;
+
+        *offset += count;
+
+        return count;
+
+      free_buffer:
+        i2o_dma_free(&c->pdev->dev, &buffer);
+
+      nop_msg:
+        i2o_msg_nop(c, m);
+
+        return rc;
+};
+
+/* attribute for HRT in sysfs */
+static struct bin_attribute i2o_config_hrt_attr = {
+        .attr = {
+                 .name = "hrt",
+                 .mode = S_IRUGO,
+                 .owner = THIS_MODULE},
+        .size = 0,
+        .read = i2o_config_read_hrt
+};
+
+/* attribute for LCT in sysfs */
+static struct bin_attribute i2o_config_lct_attr = {
+        .attr = {
+                 .name = "lct",
+                 .mode = S_IRUGO,
+                 .owner = THIS_MODULE},
+        .size = 0,
+        .read = i2o_config_read_lct
+};
+
+/* IRTOS firmware access */
+I2O_CONFIG_SW_ATTR(irtos, S_IWRSR, I2O_SOFTWARE_MODULE_IRTOS, 0);
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+
+/*
+ * attribute for BIOS / SMOR, nvram and serial number access on DPT / Adaptec
+ * controllers
+ */
+I2O_CONFIG_SW_ATTR(bios, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_PRIVATE, 0);
+I2O_CONFIG_SW_ATTR(nvram, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_CONFIG, 0);
+I2O_CONFIG_SW_ATTR(serial, S_IWRSR, I2O_SOFTWARE_MODULE_IOP_CONFIG, 1);
+
+#endif
+
+/**
+ *      i2o_config_notify_controller_add - Notify of added controller
+ *      @c: the controller which was added
+ *
+ *      If a I2O controller is added, we catch the notification to add sysfs
+ *      entries.
+ */
+static void i2o_config_notify_controller_add(struct i2o_controller *c)
+{
+        struct kobject *kobj = &c->exec->device.kobj;
+
+        sysfs_create_bin_file(kobj, &i2o_config_hrt_attr);
+        sysfs_create_bin_file(kobj, &i2o_config_lct_attr);
+
+        sysfs_create_fops_file(kobj, &i2o_config_attr_irtos);
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                sysfs_create_fops_file(kobj, &i2o_config_attr_bios);
+                sysfs_create_fops_file(kobj, &i2o_config_attr_nvram);
+                sysfs_create_fops_file(kobj, &i2o_config_attr_serial);
+        }
+#endif
+};
+
+/**
+ *      i2o_config_notify_controller_remove - Notify of removed controller
+ *      @c: the controller which was removed
+ *
+ *      If a I2O controller is removed, we catch the notification to remove the
+ *      sysfs entries.
+ */
+static void i2o_config_notify_controller_remove(struct i2o_controller *c)
+{
+        struct kobject *kobj = &c->exec->device.kobj;
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                sysfs_remove_fops_file(kobj, &i2o_config_attr_serial);
+                sysfs_remove_fops_file(kobj, &i2o_config_attr_nvram);
+                sysfs_remove_fops_file(kobj, &i2o_config_attr_bios);
+        }
+#endif
+        sysfs_remove_fops_file(kobj, &i2o_config_attr_irtos);
+
+        sysfs_remove_bin_file(kobj, &i2o_config_lct_attr);
+        sysfs_remove_bin_file(kobj, &i2o_config_hrt_attr);
+};
+
+/* Config OSM driver struct */
+static struct i2o_driver i2o_config_driver = {
+        .name = OSM_NAME,
+        .notify_controller_add = i2o_config_notify_controller_add,
+        .notify_controller_remove = i2o_config_notify_controller_remove
+};
+
+#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
+#include "i2o_config.c"
+#endif
+
+/**
+ *      i2o_config_init - Configuration OSM initialization function
+ *
+ *      Registers Configuration OSM in the I2O core and if old ioctl's are
+ *      compiled in initialize them.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static int __init i2o_config_init(void)
+{
+        printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
+
+        if (i2o_driver_register(&i2o_config_driver)) {
+                osm_err("handler register failed.\n");
+                return -EBUSY;
+        }
+#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
+        if (i2o_config_old_init())
+                i2o_driver_unregister(&i2o_config_driver);
+#endif
+
+        return 0;
+}
+
+/**
+ *      i2o_config_exit - Configuration OSM exit function
+ *
+ *      If old ioctl's are compiled in exit remove them and unregisters
+ *      Configuration OSM from I2O core.
+ */
+static void i2o_config_exit(void)
+{
+#ifdef CONFIG_I2O_CONFIG_OLD_IOCTL
+        i2o_config_old_exit();
+#endif
+
+        i2o_driver_unregister(&i2o_config_driver);
+}
+
+MODULE_AUTHOR("Markus Lidel <Markus.Lidel@shadowconnect.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION(OSM_DESCRIPTION);
+MODULE_VERSION(OSM_VERSION);
+
+module_init(i2o_config_init);
+module_exit(i2o_config_exit);
diff --git a/drivers/message/i2o/core.h b/drivers/message/i2o/core.h
new file mode 100644
index 000000000000..c5bcfd70f711
--- /dev/null
+++ b/drivers/message/i2o/core.h
@@ -0,0 +1,58 @@
+/*
+ *      I2O core internal declarations
+ *
+ *      Copyright (C) 2005      Markus Lidel <Markus.Lidel@shadowconnect.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 the
+ *      Free Software Foundation; either version 2 of the License, or (at your
+ *      option) any later version.
+ *
+ *      Fixes/additions:
+ *              Markus Lidel <Markus.Lidel@shadowconnect.com>
+ *                      initial version.
+ */
+
+/* Exec-OSM */
+extern struct bus_type i2o_bus_type;
+
+extern struct i2o_driver i2o_exec_driver;
+extern int i2o_exec_lct_get(struct i2o_controller *);
+
+extern int __init i2o_exec_init(void);
+extern void __exit i2o_exec_exit(void);
+
+/* driver */
+extern int i2o_driver_dispatch(struct i2o_controller *, u32);
+
+extern int __init i2o_driver_init(void);
+extern void __exit i2o_driver_exit(void);
+
+/* PCI */
+extern int __init i2o_pci_init(void);
+extern void __exit i2o_pci_exit(void);
+
+/* device */
+extern void i2o_device_remove(struct i2o_device *);
+extern int i2o_device_parse_lct(struct i2o_controller *);
+
+extern int i2o_device_init(void);
+extern void i2o_device_exit(void);
+
+/* IOP */
+extern struct i2o_controller *i2o_iop_alloc(void);
+extern void i2o_iop_free(struct i2o_controller *);
+
+extern int i2o_iop_add(struct i2o_controller *);
+extern void i2o_iop_remove(struct i2o_controller *);
+
+/* config */
+extern int i2o_parm_issue(struct i2o_device *, int, void *, int, void *, int);
+
+/* control registers relative to c->base */
+#define I2O_IRQ_STATUS  0x30
+#define I2O_IRQ_MASK    0x34
+#define I2O_IN_PORT     0x40
+#define I2O_OUT_PORT    0x44
+
+#define I2O_IRQ_OUTBOUND_POST   0x00000008
diff --git a/drivers/message/i2o/debug.c b/drivers/message/i2o/debug.c
index 2a5d478fc60e..018ca887ca85 100644
--- a/drivers/message/i2o/debug.c
+++ b/drivers/message/i2o/debug.c
@@ -4,8 +4,6 @@
 #include <linux/pci.h>
 #include <linux/i2o.h>
 
-extern struct i2o_driver **i2o_drivers;
-extern unsigned int i2o_max_drivers;
 static void i2o_report_util_cmd(u8 cmd);
 static void i2o_report_exec_cmd(u8 cmd);
 static void i2o_report_fail_status(u8 req_status, u32 * msg);
@@ -23,7 +21,6 @@ void i2o_report_status(const char *severity, const char *str,
         u8 cmd = (msg[1] >> 24) & 0xFF;
         u8 req_status = (msg[4] >> 24) & 0xFF;
         u16 detailed_status = msg[4] & 0xFFFF;
-        //struct i2o_driver *h = i2o_drivers[msg[2] & (i2o_max_drivers-1)];
 
         if (cmd == I2O_CMD_UTIL_EVT_REGISTER)
                 return;         // No status in this reply
diff --git a/drivers/message/i2o/device.c b/drivers/message/i2o/device.c
index eb907e87bc7b..21f16ba3ac38 100644
--- a/drivers/message/i2o/device.c
+++ b/drivers/message/i2o/device.c
@@ -16,9 +16,7 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
-
-/* Exec OSM functions */
-extern struct bus_type i2o_bus_type;
+#include "core.h"
 
 /**
  *      i2o_device_issue_claim - claim or release a device
@@ -282,8 +280,7 @@ int i2o_device_parse_lct(struct i2o_controller *c)
 
         down(&c->lct_lock);
 
-        if (c->lct)
-                kfree(c->lct);
+        kfree(c->lct);
 
         lct = c->dlct.virt;
 
@@ -294,12 +291,12 @@ int i2o_device_parse_lct(struct i2o_controller *c)
         }
 
         if (lct->table_size * 4 > c->dlct.len) {
-                memcpy_fromio(c->lct, c->dlct.virt, c->dlct.len);
+                memcpy(c->lct, c->dlct.virt, c->dlct.len);
                 up(&c->lct_lock);
                 return -EAGAIN;
         }
 
-        memcpy_fromio(c->lct, c->dlct.virt, lct->table_size * 4);
+        memcpy(c->lct, c->dlct.virt, lct->table_size * 4);
 
         lct = c->lct;
 
@@ -354,7 +351,7 @@ static ssize_t i2o_device_class_show_class_id(struct class_device *cd,
 {
         struct i2o_device *dev = to_i2o_device(cd->dev);
 
-        sprintf(buf, "%03x\n", dev->lct_data.class_id);
+        sprintf(buf, "0x%03x\n", dev->lct_data.class_id);
         return strlen(buf) + 1;
 };
 
@@ -369,7 +366,7 @@ static ssize_t i2o_device_class_show_tid(struct class_device *cd, char *buf)
 {
         struct i2o_device *dev = to_i2o_device(cd->dev);
 
-        sprintf(buf, "%03x\n", dev->lct_data.tid);
+        sprintf(buf, "0x%03x\n", dev->lct_data.tid);
         return strlen(buf) + 1;
 };
 
@@ -401,25 +398,27 @@ static int i2o_device_class_add(struct class_device *cd)
 
         /* create user entries for this device */
         tmp = i2o_iop_find_device(i2o_dev->iop, i2o_dev->lct_data.user_tid);
-        if (tmp)
+        if (tmp && (tmp != i2o_dev))
                 sysfs_create_link(&i2o_dev->device.kobj, &tmp->device.kobj,
                                   "user");
 
         /* create user entries refering to this device */
         list_for_each_entry(tmp, &c->devices, list)
-            if (tmp->lct_data.user_tid == i2o_dev->lct_data.tid)
+            if ((tmp->lct_data.user_tid == i2o_dev->lct_data.tid)
+                && (tmp != i2o_dev))
                 sysfs_create_link(&tmp->device.kobj,
                                   &i2o_dev->device.kobj, "user");
 
         /* create parent entries for this device */
         tmp = i2o_iop_find_device(i2o_dev->iop, i2o_dev->lct_data.parent_tid);
-        if (tmp)
+        if (tmp && (tmp != i2o_dev))
                 sysfs_create_link(&i2o_dev->device.kobj, &tmp->device.kobj,
                                   "parent");
 
         /* create parent entries refering to this device */
         list_for_each_entry(tmp, &c->devices, list)
-            if (tmp->lct_data.parent_tid == i2o_dev->lct_data.tid)
+            if ((tmp->lct_data.parent_tid == i2o_dev->lct_data.tid)
+                && (tmp != i2o_dev))
                 sysfs_create_link(&tmp->device.kobj,
                                   &i2o_dev->device.kobj, "parent");
 
@@ -444,9 +443,8 @@ static struct class_interface i2o_device_class_interface = {
  *      Note that the minimum sized reslist is 8 bytes and contains
  *      ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
  */
-
 int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,
-                   int oplen, void *reslist, int reslen)
+                          int oplen, void *reslist, int reslen)
 {
         struct i2o_message __iomem *msg;
         u32 m;
@@ -489,7 +487,7 @@ int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,
         if (rc == -ETIMEDOUT)
                 return rc;
 
-        memcpy_fromio(reslist, res.virt, res.len);
+        memcpy(reslist, res.virt, res.len);
         i2o_dma_free(dev, &res);
 
         /* Query failed */
@@ -531,17 +529,23 @@ int i2o_parm_field_get(struct i2o_device *i2o_dev, int group, int field,
                        void *buf, int buflen)
 {
         u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
-        u8 resblk[8 + buflen];  /* 8 bytes for header */
+        u8 *resblk;             /* 8 bytes for header */
         int size;
 
         if (field == -1)        /* whole group */
                 opblk[4] = -1;
 
+        resblk = kmalloc(buflen + 8, GFP_KERNEL | GFP_ATOMIC);
+        if (!resblk)
+                return -ENOMEM;
+
         size = i2o_parm_issue(i2o_dev, I2O_CMD_UTIL_PARAMS_GET, opblk,
-                              sizeof(opblk), resblk, sizeof(resblk));
+                              sizeof(opblk), resblk, buflen + 8);
 
         memcpy(buf, resblk + 8, buflen);        /* cut off header */
 
+        kfree(resblk);
+
         if (size > buflen)
                 return buflen;
 
diff --git a/drivers/message/i2o/driver.c b/drivers/message/i2o/driver.c
index 91f4edbb2a27..739bfdef0c6d 100644
--- a/drivers/message/i2o/driver.c
+++ b/drivers/message/i2o/driver.c
@@ -17,9 +17,12 @@
 #include <linux/module.h>
 #include <linux/rwsem.h>
 #include <linux/i2o.h>
+#include "core.h"
+
+#define OSM_NAME        "i2o"
 
 /* max_drivers - Maximum I2O drivers (OSMs) which could be registered */
-unsigned int i2o_max_drivers = I2O_MAX_DRIVERS;
+static unsigned int i2o_max_drivers = I2O_MAX_DRIVERS;
 module_param_named(max_drivers, i2o_max_drivers, uint, 0);
 MODULE_PARM_DESC(max_drivers, "maximum number of OSM's to support");
 
@@ -76,17 +79,16 @@ int i2o_driver_register(struct i2o_driver *drv)
         int rc = 0;
         unsigned long flags;
 
-        pr_debug("i2o: Register driver %s\n", drv->name);
+        osm_debug("Register driver %s\n", drv->name);
 
         if (drv->event) {
                 drv->event_queue = create_workqueue(drv->name);
                 if (!drv->event_queue) {
-                        printk(KERN_ERR "i2o: Could not initialize event queue "
-                               "for driver %s\n", drv->name);
+                        osm_err("Could not initialize event queue for driver "
+                                "%s\n", drv->name);
                         return -EFAULT;
                 }
-                pr_debug("i2o: Event queue initialized for driver %s\n",
-                         drv->name);
+                osm_debug("Event queue initialized for driver %s\n", drv->name);
         } else
                 drv->event_queue = NULL;
 
@@ -97,8 +99,8 @@ int i2o_driver_register(struct i2o_driver *drv)
 
         for (i = 0; i2o_drivers[i]; i++)
                 if (i >= i2o_max_drivers) {
-                        printk(KERN_ERR "i2o: too many drivers registered, "
-                               "increase max_drivers\n");
+                        osm_err("too many drivers registered, increase "
+                                "max_drivers\n");
                         spin_unlock_irqrestore(&i2o_drivers_lock, flags);
                         return -EFAULT;
                 }
@@ -108,18 +110,16 @@ int i2o_driver_register(struct i2o_driver *drv)
 
         spin_unlock_irqrestore(&i2o_drivers_lock, flags);
 
-        pr_debug("i2o: driver %s gets context id %d\n", drv->name,
-                 drv->context);
+        osm_debug("driver %s gets context id %d\n", drv->name, drv->context);
 
         list_for_each_entry(c, &i2o_controllers, list) {
                 struct i2o_device *i2o_dev;
 
                 i2o_driver_notify_controller_add(drv, c);
                 list_for_each_entry(i2o_dev, &c->devices, list)
-                        i2o_driver_notify_device_add(drv, i2o_dev);
+                    i2o_driver_notify_device_add(drv, i2o_dev);
         }
 
-
         rc = driver_register(&drv->driver);
         if (rc)
                 destroy_workqueue(drv->event_queue);
@@ -139,7 +139,7 @@ void i2o_driver_unregister(struct i2o_driver *drv)
         struct i2o_controller *c;
         unsigned long flags;
 
-        pr_debug("i2o: unregister driver %s\n", drv->name);
+        osm_debug("unregister driver %s\n", drv->name);
 
         driver_unregister(&drv->driver);
 
@@ -159,7 +159,7 @@ void i2o_driver_unregister(struct i2o_driver *drv)
         if (drv->event_queue) {
                 destroy_workqueue(drv->event_queue);
                 drv->event_queue = NULL;
-                pr_debug("i2o: event queue removed for %s\n", drv->name);
+                osm_debug("event queue removed for %s\n", drv->name);
         }
 };
 
@@ -176,68 +176,70 @@ void i2o_driver_unregister(struct i2o_driver *drv)
  *      on success and if the message should be flushed afterwords. Returns
  *      negative error code on failure (the message will be flushed too).
  */
-int i2o_driver_dispatch(struct i2o_controller *c, u32 m,
-                        struct i2o_message __iomem *msg)
+int i2o_driver_dispatch(struct i2o_controller *c, u32 m)
 {
         struct i2o_driver *drv;
-        u32 context = readl(&msg->u.s.icntxt);
+        struct i2o_message *msg = i2o_msg_out_to_virt(c, m);
+        u32 context = le32_to_cpu(msg->u.s.icntxt);
+        unsigned long flags;
 
-        if (likely(context < i2o_max_drivers)) {
-                spin_lock(&i2o_drivers_lock);
-                drv = i2o_drivers[context];
-                spin_unlock(&i2o_drivers_lock);
+        if (unlikely(context >= i2o_max_drivers)) {
+                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
+                         context);
+                return -EIO;
+        }
 
-                if (unlikely(!drv)) {
-                        printk(KERN_WARNING "%s: Spurious reply to unknown "
-                               "driver %d\n", c->name, context);
-                        return -EIO;
-                }
+        spin_lock_irqsave(&i2o_drivers_lock, flags);
+        drv = i2o_drivers[context];
+        spin_unlock_irqrestore(&i2o_drivers_lock, flags);
 
-                if ((readl(&msg->u.head[1]) >> 24) == I2O_CMD_UTIL_EVT_REGISTER) {
-                        struct i2o_device *dev, *tmp;
-                        struct i2o_event *evt;
-                        u16 size;
-                        u16 tid;
+        if (unlikely(!drv)) {
+                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
+                         context);
+                return -EIO;
+        }
 
-                        tid = readl(&msg->u.head[1]) & 0x1fff;
+        if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_UTIL_EVT_REGISTER) {
+                struct i2o_device *dev, *tmp;
+                struct i2o_event *evt;
+                u16 size;
+                u16 tid = le32_to_cpu(msg->u.head[1]) & 0xfff;
 
-                        pr_debug("%s: event received from device %d\n", c->name,
-                                 tid);
+                osm_debug("event received from device %d\n", tid);
 
-                        /* cut of header from message size (in 32-bit words) */
-                        size = (readl(&msg->u.head[0]) >> 16) - 5;
+                if (!drv->event)
+                        return -EIO;
 
-                        evt = kmalloc(size * 4 + sizeof(*evt), GFP_ATOMIC);
-                        if (!evt)
-                                return -ENOMEM;
-                        memset(evt, 0, size * 4 + sizeof(*evt));
+                /* cut of header from message size (in 32-bit words) */
+                size = (le32_to_cpu(msg->u.head[0]) >> 16) - 5;
 
-                        evt->size = size;
-                        memcpy_fromio(&evt->tcntxt, &msg->u.s.tcntxt,
-                                      (size + 2) * 4);
+                evt = kmalloc(size * 4 + sizeof(*evt), GFP_ATOMIC | __GFP_ZERO);
+                if (!evt)
+                        return -ENOMEM;
 
-                        list_for_each_entry_safe(dev, tmp, &c->devices, list)
-                            if (dev->lct_data.tid == tid) {
-                                evt->i2o_dev = dev;
-                                break;
-                        }
+                evt->size = size;
+                evt->tcntxt = le32_to_cpu(msg->u.s.tcntxt);
+                evt->event_indicator = le32_to_cpu(msg->body[0]);
+                memcpy(&evt->tcntxt, &msg->u.s.tcntxt, size * 4);
 
-                        INIT_WORK(&evt->work, (void (*)(void *))drv->event,
-                                  evt);
-                        queue_work(drv->event_queue, &evt->work);
-                        return 1;
+                list_for_each_entry_safe(dev, tmp, &c->devices, list)
+                    if (dev->lct_data.tid == tid) {
+                        evt->i2o_dev = dev;
+                        break;
                 }
 
-                if (likely(drv->reply))
-                        return drv->reply(c, m, msg);
-                else
-                        pr_debug("%s: Reply to driver %s, but no reply function"
-                                 " defined!\n", c->name, drv->name);
+                INIT_WORK(&evt->work, (void (*)(void *))drv->event, evt);
+                queue_work(drv->event_queue, &evt->work);
+                return 1;
+        }
+
+        if (unlikely(!drv->reply)) {
+                osm_debug("%s: Reply to driver %s, but no reply function"
+                          " defined!\n", c->name, drv->name);
                 return -EIO;
-        } else
-                printk(KERN_WARNING "%s: Spurious reply to unknown driver "
-                       "%d\n", c->name, readl(&msg->u.s.icntxt));
-        return -EIO;
+        }
+
+        return drv->reply(c, m, msg);
 }
 
 /**
@@ -334,11 +336,11 @@ int __init i2o_driver_init(void)
         if ((i2o_max_drivers < 2) || (i2o_max_drivers > 64) ||
             ((i2o_max_drivers ^ (i2o_max_drivers - 1)) !=
              (2 * i2o_max_drivers - 1))) {
-                printk(KERN_WARNING "i2o: max_drivers set to %d, but must be "
-                       ">=2 and <= 64 and a power of 2\n", i2o_max_drivers);
+                osm_warn("max_drivers set to %d, but must be >=2 and <= 64 and "
+                         "a power of 2\n", i2o_max_drivers);
                 i2o_max_drivers = I2O_MAX_DRIVERS;
         }
-        printk(KERN_INFO "i2o: max drivers = %d\n", i2o_max_drivers);
+        osm_info("max drivers = %d\n", i2o_max_drivers);
 
         i2o_drivers =
             kmalloc(i2o_max_drivers * sizeof(*i2o_drivers), GFP_KERNEL);
diff --git a/drivers/message/i2o/exec-osm.c b/drivers/message/i2o/exec-osm.c
index 79c1cbfb8f44..bda2c62648ba 100644
--- a/drivers/message/i2o/exec-osm.c
+++ b/drivers/message/i2o/exec-osm.c
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
+#include "core.h"
 
 #define OSM_NAME "exec-osm"
 
@@ -37,9 +38,6 @@ struct i2o_driver i2o_exec_driver;
 
 static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind);
 
-/* Module internal functions from other sources */
-extern int i2o_device_parse_lct(struct i2o_controller *);
-
 /* global wait list for POST WAIT */
 static LIST_HEAD(i2o_exec_wait_list);
 
@@ -50,7 +48,7 @@ struct i2o_exec_wait {
         u32 tcntxt;             /* transaction context from reply */
         int complete;           /* 1 if reply received otherwise 0 */
         u32 m;                  /* message id */
-        struct i2o_message __iomem *msg;        /* pointer to the reply message */
+        struct i2o_message *msg;        /* pointer to the reply message */
         struct list_head list;  /* node in global wait list */
 };
 
@@ -108,7 +106,8 @@ static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
  *      buffer must not be freed. Instead the event completion will free them
  *      for you. In all other cases the buffer are your problem.
  *
- *      Returns 0 on success or negative error code on failure.
+ *      Returns 0 on success, negative error code on timeout or positive error
+ *      code from reply.
  */
 int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
                           timeout, struct i2o_dma *dma)
@@ -116,7 +115,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
         DECLARE_WAIT_QUEUE_HEAD(wq);
         struct i2o_exec_wait *wait;
         static u32 tcntxt = 0x80000000;
-        struct i2o_message __iomem *msg = c->in_queue.virt + m;
+        struct i2o_message __iomem *msg = i2o_msg_in_to_virt(c, m);
         int rc = 0;
 
         wait = i2o_exec_wait_alloc();
@@ -153,7 +152,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
                 list_add(&wait->list, &i2o_exec_wait_list);
 
                 wait_event_interruptible_timeout(wq, wait->complete,
-                        timeout * HZ);
+                                                 timeout * HZ);
 
                 wait->wq = NULL;
         }
@@ -161,8 +160,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
         barrier();
 
         if (wait->complete) {
-                if (readl(&wait->msg->body[0]) >> 24)
-                        rc = readl(&wait->msg->body[0]) & 0xff;
+                rc = le32_to_cpu(wait->msg->body[0]) >> 24;
                 i2o_flush_reply(c, wait->m);
                 i2o_exec_wait_free(wait);
         } else {
@@ -187,6 +185,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
  *      @c: I2O controller which answers
  *      @m: message id
  *      @msg: pointer to the I2O reply message
+ *      @context: transaction context of request
  *
  *      This function is called in interrupt context only. If the reply reached
  *      before the timeout, the i2o_exec_wait struct is filled with the message
@@ -201,16 +200,12 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
  *      message must also be given back to the controller.
  */
 static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
-                                      struct i2o_message __iomem *msg)
+                                      struct i2o_message *msg, u32 context)
 {
         struct i2o_exec_wait *wait, *tmp;
-        static spinlock_t lock;
+        unsigned long flags;
+        static spinlock_t lock = SPIN_LOCK_UNLOCKED;
         int rc = 1;
-        u32 context;
-
-        spin_lock_init(&lock);
-
-        context = readl(&msg->u.s.tcntxt);
 
         /*
          * We need to search through the i2o_exec_wait_list to see if the given
@@ -219,11 +214,13 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
          * already expired. Not much we can do about that except log it for
          * debug purposes, increase timeout, and recompile.
          */
-        spin_lock(&lock);
+        spin_lock_irqsave(&lock, flags);
         list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
                 if (wait->tcntxt == context) {
                         list_del(&wait->list);
 
+                        spin_unlock_irqrestore(&lock, flags);
+
                         wait->m = m;
                         wait->msg = msg;
                         wait->complete = 1;
@@ -245,21 +242,63 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
                                 rc = -1;
                         }
 
-                        spin_unlock(&lock);
-
                         return rc;
                 }
         }
 
-        spin_unlock(&lock);
+        spin_unlock_irqrestore(&lock, flags);
 
-        pr_debug("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
+        osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
                  context);
 
         return -1;
 };
 
 /**
+ *      i2o_exec_show_vendor_id - Displays Vendor ID of controller
+ *      @d: device of which the Vendor ID should be displayed
+ *      @buf: buffer into which the Vendor ID should be printed
+ *
+ *      Returns number of bytes printed into buffer.
+ */
+static ssize_t i2o_exec_show_vendor_id(struct device *d, struct device_attribute *attr, char *buf)
+{
+        struct i2o_device *dev = to_i2o_device(d);
+        u16 id;
+
+        if (i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
+                sprintf(buf, "0x%04x", id);
+                return strlen(buf) + 1;
+        }
+
+        return 0;
+};
+
+/**
+ *      i2o_exec_show_product_id - Displays Product ID of controller
+ *      @d: device of which the Product ID should be displayed
+ *      @buf: buffer into which the Product ID should be printed
+ *
+ *      Returns number of bytes printed into buffer.
+ */
+static ssize_t i2o_exec_show_product_id(struct device *d, struct device_attribute *attr, char *buf)
+{
+        struct i2o_device *dev = to_i2o_device(d);
+        u16 id;
+
+        if (i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
+                sprintf(buf, "0x%04x", id);
+                return strlen(buf) + 1;
+        }
+
+        return 0;
+};
+
+/* Exec-OSM device attributes */
+static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
+static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
+
+/**
  *      i2o_exec_probe - Called if a new I2O device (executive class) appears
  *      @dev: I2O device which should be probed
  *
@@ -271,10 +310,16 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
 static int i2o_exec_probe(struct device *dev)
 {
         struct i2o_device *i2o_dev = to_i2o_device(dev);
+        struct i2o_controller *c = i2o_dev->iop;
 
         i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
 
-        i2o_dev->iop->exec = i2o_dev;
+        c->exec = i2o_dev;
+
+        i2o_exec_lct_notify(c, c->lct->change_ind + 1);
+
+        device_create_file(dev, &dev_attr_vendor_id);
+        device_create_file(dev, &dev_attr_product_id);
 
         return 0;
 };
@@ -289,6 +334,9 @@ static int i2o_exec_probe(struct device *dev)
  */
 static int i2o_exec_remove(struct device *dev)
 {
+        device_remove_file(dev, &dev_attr_product_id);
+        device_remove_file(dev, &dev_attr_vendor_id);
+
         i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
 
         return 0;
@@ -300,12 +348,16 @@ static int i2o_exec_remove(struct device *dev)
  *
  *      This function handles asynchronus LCT NOTIFY replies. It parses the
  *      new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
- *      again.
+ *      again, otherwise send LCT NOTIFY to get informed on next LCT change.
  */
 static void i2o_exec_lct_modified(struct i2o_controller *c)
 {
-        if (i2o_device_parse_lct(c) == -EAGAIN)
-                i2o_exec_lct_notify(c, 0);
+        u32 change_ind = 0;
+
+        if (i2o_device_parse_lct(c) != -EAGAIN)
+                change_ind = c->lct->change_ind + 1;
+
+        i2o_exec_lct_notify(c, change_ind);
 };
 
 /**
@@ -325,8 +377,14 @@ static void i2o_exec_lct_modified(struct i2o_controller *c)
 static int i2o_exec_reply(struct i2o_controller *c, u32 m,
                           struct i2o_message *msg)
 {
-        if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {   // Fail bit is set
-                struct i2o_message __iomem *pmsg;       /* preserved message */
+        u32 context;
+
+        if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
+                /*
+                 * If Fail bit is set we must take the transaction context of
+                 * the preserved message to find the right request again.
+                 */
+                struct i2o_message __iomem *pmsg;
                 u32 pm;
 
                 pm = le32_to_cpu(msg->body[3]);
@@ -335,15 +393,15 @@ static int i2o_exec_reply(struct i2o_controller *c, u32 m,
 
                 i2o_report_status(KERN_INFO, "i2o_core", msg);
 
-                /* Release the preserved msg by resubmitting it as a NOP */
-                i2o_msg_nop(c, pm);
+                context = readl(&pmsg->u.s.tcntxt);
 
-                /* If reply to i2o_post_wait failed, return causes a timeout */
-                return -1;
-        }
+                /* Release the preserved msg */
+                i2o_msg_nop(c, pm);
+        } else
+                context = le32_to_cpu(msg->u.s.tcntxt);
 
-        if (le32_to_cpu(msg->u.s.tcntxt) & 0x80000000)
-                return i2o_msg_post_wait_complete(c, m, msg);
+        if (context & 0x80000000)
+                return i2o_msg_post_wait_complete(c, m, msg, context);
 
         if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
                 struct work_struct *work;
@@ -381,8 +439,9 @@ static int i2o_exec_reply(struct i2o_controller *c, u32 m,
  */
 static void i2o_exec_event(struct i2o_event *evt)
 {
-        osm_info("Event received from device: %d\n",
-                 evt->i2o_dev->lct_data.tid);
+        if (likely(evt->i2o_dev))
+                osm_debug("Event received from device: %d\n",
+                          evt->i2o_dev->lct_data.tid);
         kfree(evt);
 };
 
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 7b74c87b569e..f283b5bafdd3 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -62,7 +62,7 @@
 #include "i2o_block.h"
 
 #define OSM_NAME        "block-osm"
-#define OSM_VERSION     "$Rev$"
+#define OSM_VERSION     "1.287"
 #define OSM_DESCRIPTION "I2O Block Device OSM"
 
 static struct i2o_driver i2o_block_driver;
@@ -104,7 +104,8 @@ static int i2o_block_remove(struct device *dev)
         struct i2o_device *i2o_dev = to_i2o_device(dev);
         struct i2o_block_device *i2o_blk_dev = dev_get_drvdata(dev);
 
-        osm_info("Device removed %s\n", i2o_blk_dev->gd->disk_name);
+        osm_info("device removed (TID: %03x): %s\n", i2o_dev->lct_data.tid,
+                 i2o_blk_dev->gd->disk_name);
 
         i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0);
 
@@ -146,6 +147,29 @@ static int i2o_block_device_flush(struct i2o_device *dev)
 };
 
 /**
+ *      i2o_block_issue_flush - device-flush interface for block-layer
+ *      @queue: the request queue of the device which should be flushed
+ *      @disk: gendisk
+ *      @error_sector: error offset
+ *
+ *      Helper function to provide flush functionality to block-layer.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+
+static int i2o_block_issue_flush(request_queue_t * queue, struct gendisk *disk,
+                                 sector_t * error_sector)
+{
+        struct i2o_block_device *i2o_blk_dev = queue->queuedata;
+        int rc = -ENODEV;
+
+        if (likely(i2o_blk_dev))
+                rc = i2o_block_device_flush(i2o_blk_dev->i2o_dev);
+
+        return rc;
+}
+
+/**
  *      i2o_block_device_mount - Mount (load) the media of device dev
  *      @dev: I2O device which should receive the mount request
  *      @media_id: Media Identifier
@@ -298,28 +322,31 @@ static inline void i2o_block_request_free(struct i2o_block_request *ireq)
 
 /**
  *      i2o_block_sglist_alloc - Allocate the SG list and map it
+ *      @c: I2O controller to which the request belongs
  *      @ireq: I2O block request
  *
- *      Builds the SG list and map it into to be accessable by the controller.
+ *      Builds the SG list and map it to be accessable by the controller.
  *
- *      Returns the number of elements in the SG list or 0 on failure.
+ *      Returns 0 on failure or 1 on success.
  */
-static inline int i2o_block_sglist_alloc(struct i2o_block_request *ireq)
+static inline int i2o_block_sglist_alloc(struct i2o_controller *c,
+                                         struct i2o_block_request *ireq,
+                                         u32 __iomem ** mptr)
 {
-        struct device *dev = &ireq->i2o_blk_dev->i2o_dev->iop->pdev->dev;
         int nents;
+        enum dma_data_direction direction;
 
+        ireq->dev = &c->pdev->dev;
         nents = blk_rq_map_sg(ireq->req->q, ireq->req, ireq->sg_table);
 
         if (rq_data_dir(ireq->req) == READ)
-                ireq->sg_dma_direction = PCI_DMA_FROMDEVICE;
+                direction = PCI_DMA_FROMDEVICE;
         else
-                ireq->sg_dma_direction = PCI_DMA_TODEVICE;
+                direction = PCI_DMA_TODEVICE;
 
-        ireq->sg_nents = dma_map_sg(dev, ireq->sg_table, nents,
-                                    ireq->sg_dma_direction);
+        ireq->sg_nents = nents;
 
-        return ireq->sg_nents;
+        return i2o_dma_map_sg(c, ireq->sg_table, nents, direction, mptr);
 };
 
 /**
@@ -330,10 +357,14 @@ static inline int i2o_block_sglist_alloc(struct i2o_block_request *ireq)
  */
 static inline void i2o_block_sglist_free(struct i2o_block_request *ireq)
 {
-        struct device *dev = &ireq->i2o_blk_dev->i2o_dev->iop->pdev->dev;
+        enum dma_data_direction direction;
 
-        dma_unmap_sg(dev, ireq->sg_table, ireq->sg_nents,
-                     ireq->sg_dma_direction);
+        if (rq_data_dir(ireq->req) == READ)
+                direction = PCI_DMA_FROMDEVICE;
+        else
+                direction = PCI_DMA_TODEVICE;
+
+        dma_unmap_sg(ireq->dev, ireq->sg_table, ireq->sg_nents, direction);
 };
 
 /**
@@ -351,6 +382,11 @@ static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req)
         struct i2o_block_device *i2o_blk_dev = q->queuedata;
         struct i2o_block_request *ireq;
 
+        if (unlikely(!i2o_blk_dev)) {
+                osm_err("block device already removed\n");
+                return BLKPREP_KILL;
+        }
+
         /* request is already processed by us, so return */
         if (req->flags & REQ_SPECIAL) {
                 osm_debug("REQ_SPECIAL already set!\n");
@@ -400,71 +436,65 @@ static void i2o_block_delayed_request_fn(void *delayed_request)
 };
 
 /**
- *      i2o_block_reply - Block OSM reply handler.
- *      @c: I2O controller from which the message arrives
- *      @m: message id of reply
- *      qmsg: the actuall I2O message reply
+ *      i2o_block_end_request - Post-processing of completed commands
+ *      @req: request which should be completed
+ *      @uptodate: 1 for success, 0 for I/O error, < 0 for specific error
+ *      @nr_bytes: number of bytes to complete
  *
- *      This function gets all the message replies.
+ *      Mark the request as complete. The lock must not be held when entering.
  *
  */
-static int i2o_block_reply(struct i2o_controller *c, u32 m,
-                           struct i2o_message *msg)
+static void i2o_block_end_request(struct request *req, int uptodate,
+                                  int nr_bytes)
 {
-        struct i2o_block_request *ireq;
-        struct request *req;
-        struct i2o_block_device *dev;
-        struct request_queue *q;
-        u8 st;
+        struct i2o_block_request *ireq = req->special;
+        struct i2o_block_device *dev = ireq->i2o_blk_dev;
+        request_queue_t *q = req->q;
         unsigned long flags;
 
-        /* FAILed message */
-        if (unlikely(le32_to_cpu(msg->u.head[0]) & (1 << 13))) {
-                struct i2o_message *pmsg;
-                u32 pm;
+        if (end_that_request_chunk(req, uptodate, nr_bytes)) {
+                int leftover = (req->hard_nr_sectors << KERNEL_SECTOR_SHIFT);
 
-                /*
-                 * FAILed message from controller
-                 * We increment the error count and abort it
-                 *
-                 * In theory this will never happen.  The I2O block class
-                 * specification states that block devices never return
-                 * FAILs but instead use the REQ status field...but
-                 * better be on the safe side since no one really follows
-                 * the spec to the book :)
-                 */
-                pm = le32_to_cpu(msg->body[3]);
-                pmsg = i2o_msg_in_to_virt(c, pm);
+                if (blk_pc_request(req))
+                        leftover = req->data_len;
 
-                req = i2o_cntxt_list_get(c, le32_to_cpu(pmsg->u.s.tcntxt));
-                if (unlikely(!req)) {
-                        osm_err("NULL reply received!\n");
-                        return -1;
-                }
+                if (end_io_error(uptodate))
+                        end_that_request_chunk(req, 0, leftover);
+        }
 
-                ireq = req->special;
-                dev = ireq->i2o_blk_dev;
-                q = dev->gd->queue;
+        add_disk_randomness(req->rq_disk);
 
-                req->errors++;
-
-                spin_lock_irqsave(q->queue_lock, flags);
+        spin_lock_irqsave(q->queue_lock, flags);
 
-                while (end_that_request_chunk(req, !req->errors,
-                                              le32_to_cpu(pmsg->body[1]))) ;
-                end_that_request_last(req);
+        end_that_request_last(req);
 
+        if (likely(dev)) {
                 dev->open_queue_depth--;
                 list_del(&ireq->queue);
-                blk_start_queue(q);
+        }
 
-                spin_unlock_irqrestore(q->queue_lock, flags);
+        blk_start_queue(q);
 
-                /* Now flush the message by making it a NOP */
-                i2o_msg_nop(c, pm);
+        spin_unlock_irqrestore(q->queue_lock, flags);
 
-                return -1;
-        }
+        i2o_block_sglist_free(ireq);
+        i2o_block_request_free(ireq);
+};
+
+/**
+ *      i2o_block_reply - Block OSM reply handler.
+ *      @c: I2O controller from which the message arrives
+ *      @m: message id of reply
+ *      qmsg: the actuall I2O message reply
+ *
+ *      This function gets all the message replies.
+ *
+ */
+static int i2o_block_reply(struct i2o_controller *c, u32 m,
+                           struct i2o_message *msg)
+{
+        struct request *req;
+        int uptodate = 1;
 
         req = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt));
         if (unlikely(!req)) {
@@ -472,61 +502,13 @@ static int i2o_block_reply(struct i2o_controller *c, u32 m,
                 return -1;
         }
 
-        ireq = req->special;
-        dev = ireq->i2o_blk_dev;
-        q = dev->gd->queue;
-
-        if (unlikely(!dev->i2o_dev)) {
-                /*
-                 * This is HACK, but Intel Integrated RAID allows user
-                 * to delete a volume that is claimed, locked, and in use
-                 * by the OS. We have to check for a reply from a
-                 * non-existent device and flag it as an error or the system
-                 * goes kaput...
-                 */
-                req->errors++;
-                osm_warn("Data transfer to deleted device!\n");
-                spin_lock_irqsave(q->queue_lock, flags);
-                while (end_that_request_chunk
-                       (req, !req->errors, le32_to_cpu(msg->body[1]))) ;
-                end_that_request_last(req);
-
-                dev->open_queue_depth--;
-                list_del(&ireq->queue);
-                blk_start_queue(q);
-
-                spin_unlock_irqrestore(q->queue_lock, flags);
-                return -1;
-        }
-
         /*
          *      Lets see what is cooking. We stuffed the
          *      request in the context.
          */
 
-        st = le32_to_cpu(msg->body[0]) >> 24;
-
-        if (st != 0) {
-                int err;
-                char *bsa_errors[] = {
-                        "Success",
-                        "Media Error",
-                        "Failure communicating to device",
-                        "Device Failure",
-                        "Device is not ready",
-                        "Media not present",
-                        "Media is locked by another user",
-                        "Media has failed",
-                        "Failure communicating to device",
-                        "Device bus failure",
-                        "Device is locked by another user",
-                        "Device is write protected",
-                        "Device has reset",
-                        "Volume has changed, waiting for acknowledgement"
-                };
-
-                err = le32_to_cpu(msg->body[0]) & 0xffff;
-
+        if ((le32_to_cpu(msg->body[0]) >> 24) != 0) {
+                u32 status = le32_to_cpu(msg->body[0]);
                 /*
                  *      Device not ready means two things. One is that the
                  *      the thing went offline (but not a removal media)
@@ -539,40 +521,24 @@ static int i2o_block_reply(struct i2o_controller *c, u32 m,
                  *      Don't stick a supertrak100 into cache aggressive modes
                  */
 
-                osm_err("block-osm: /dev/%s error: %s", dev->gd->disk_name,
-                        bsa_errors[le32_to_cpu(msg->body[0]) & 0xffff]);
-                if (le32_to_cpu(msg->body[0]) & 0x00ff0000)
-                        printk(KERN_ERR " - DDM attempted %d retries",
-                               (le32_to_cpu(msg->body[0]) >> 16) & 0x00ff);
-                printk(KERN_ERR ".\n");
-                req->errors++;
-        } else
-                req->errors = 0;
+                osm_err("TID %03x error status: 0x%02x, detailed status: "
+                        "0x%04x\n", (le32_to_cpu(msg->u.head[1]) >> 12 & 0xfff),
+                        status >> 24, status & 0xffff);
 
-        if (!end_that_request_chunk
-            (req, !req->errors, le32_to_cpu(msg->body[1]))) {
-                add_disk_randomness(req->rq_disk);
-                spin_lock_irqsave(q->queue_lock, flags);
-
-                end_that_request_last(req);
+                req->errors++;
 
-                dev->open_queue_depth--;
-                list_del(&ireq->queue);
-                blk_start_queue(q);
+                uptodate = 0;
+        }
 
-                spin_unlock_irqrestore(q->queue_lock, flags);
-
-                i2o_block_sglist_free(ireq);
-                i2o_block_request_free(ireq);
-        } else
-                osm_err("still remaining chunks\n");
+        i2o_block_end_request(req, uptodate, le32_to_cpu(msg->body[1]));
 
         return 1;
 };
 
 static void i2o_block_event(struct i2o_event *evt)
 {
-        osm_info("block-osm: event received\n");
+        osm_debug("event received\n");
+        kfree(evt);
 };
 
 /*
@@ -777,18 +743,25 @@ static int i2o_block_media_changed(struct gendisk *disk)
 static int i2o_block_transfer(struct request *req)
 {
         struct i2o_block_device *dev = req->rq_disk->private_data;
-        struct i2o_controller *c = dev->i2o_dev->iop;
+        struct i2o_controller *c;
         int tid = dev->i2o_dev->lct_data.tid;
         struct i2o_message __iomem *msg;
-        void __iomem *mptr;
+        u32 __iomem *mptr;
         struct i2o_block_request *ireq = req->special;
-        struct scatterlist *sg;
-        int sgnum;
-        int i;
         u32 m;
         u32 tcntxt;
-        u32 sg_flags;
+        u32 sgl_offset = SGL_OFFSET_8;
+        u32 ctl_flags = 0x00000000;
         int rc;
+        u32 cmd;
+
+        if (unlikely(!dev->i2o_dev)) {
+                osm_err("transfer to removed drive\n");
+                rc = -ENODEV;
+                goto exit;
+        }
+
+        c = dev->i2o_dev->iop;
 
         m = i2o_msg_get(c, &msg);
         if (m == I2O_QUEUE_EMPTY) {
@@ -802,82 +775,109 @@ static int i2o_block_transfer(struct request *req)
                 goto nop_msg;
         }
 
-        if ((sgnum = i2o_block_sglist_alloc(ireq)) <= 0) {
-                rc = -ENOMEM;
-                goto context_remove;
-        }
-
-        /* Build the message based on the request. */
         writel(i2o_block_driver.context, &msg->u.s.icntxt);
         writel(tcntxt, &msg->u.s.tcntxt);
-        writel(req->nr_sectors << 9, &msg->body[1]);
-
-        writel((((u64) req->sector) << 9) & 0xffffffff, &msg->body[2]);
-        writel(req->sector >> 23, &msg->body[3]);
 
-        mptr = &msg->body[4];
-
-        sg = ireq->sg_table;
+        mptr = &msg->body[0];
 
         if (rq_data_dir(req) == READ) {
-                writel(I2O_CMD_BLOCK_READ << 24 | HOST_TID << 12 | tid,
-                       &msg->u.head[1]);
-                sg_flags = 0x10000000;
+                cmd = I2O_CMD_BLOCK_READ << 24;
+
                 switch (dev->rcache) {
-                case CACHE_NULL:
-                        writel(0, &msg->body[0]);
-                        break;
                 case CACHE_PREFETCH:
-                        writel(0x201F0008, &msg->body[0]);
+                        ctl_flags = 0x201F0008;
                         break;
+
                 case CACHE_SMARTFETCH:
                         if (req->nr_sectors > 16)
-                                writel(0x201F0008, &msg->body[0]);
+                                ctl_flags = 0x201F0008;
                         else
-                                writel(0x001F0000, &msg->body[0]);
+                                ctl_flags = 0x001F0000;
+                        break;
+
+                default:
                         break;
                 }
         } else {
-                writel(I2O_CMD_BLOCK_WRITE << 24 | HOST_TID << 12 | tid,
-                       &msg->u.head[1]);
-                sg_flags = 0x14000000;
+                cmd = I2O_CMD_BLOCK_WRITE << 24;
+
                 switch (dev->wcache) {
-                case CACHE_NULL:
-                        writel(0, &msg->body[0]);
-                        break;
                 case CACHE_WRITETHROUGH:
-                        writel(0x001F0008, &msg->body[0]);
+                        ctl_flags = 0x001F0008;
                         break;
                 case CACHE_WRITEBACK:
-                        writel(0x001F0010, &msg->body[0]);
+                        ctl_flags = 0x001F0010;
                         break;
                 case CACHE_SMARTBACK:
                         if (req->nr_sectors > 16)
-                                writel(0x001F0004, &msg->body[0]);
+                                ctl_flags = 0x001F0004;
                         else
-                                writel(0x001F0010, &msg->body[0]);
+                                ctl_flags = 0x001F0010;
                         break;
                 case CACHE_SMARTTHROUGH:
                         if (req->nr_sectors > 16)
-                                writel(0x001F0004, &msg->body[0]);
+                                ctl_flags = 0x001F0004;
                         else
-                                writel(0x001F0010, &msg->body[0]);
+                                ctl_flags = 0x001F0010;
+                default:
+                        break;
+                }
+        }
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                u8 cmd[10];
+                u32 scsi_flags;
+                u16 hwsec = queue_hardsect_size(req->q) >> KERNEL_SECTOR_SHIFT;
+
+                memset(cmd, 0, 10);
+
+                sgl_offset = SGL_OFFSET_12;
+
+                writel(I2O_CMD_PRIVATE << 24 | HOST_TID << 12 | tid,
+                       &msg->u.head[1]);
+
+                writel(I2O_VENDOR_DPT << 16 | I2O_CMD_SCSI_EXEC, mptr++);
+                writel(tid, mptr++);
+
+                /*
+                 * ENABLE_DISCONNECT
+                 * SIMPLE_TAG
+                 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME
+                 */
+                if (rq_data_dir(req) == READ) {
+                        cmd[0] = 0x28;
+                        scsi_flags = 0x60a0000a;
+                } else {
+                        cmd[0] = 0x2A;
+                        scsi_flags = 0xa0a0000a;
                 }
+
+                writel(scsi_flags, mptr++);
+
+                *((u32 *) & cmd[2]) = cpu_to_be32(req->sector * hwsec);
+                *((u16 *) & cmd[7]) = cpu_to_be16(req->nr_sectors * hwsec);
+
+                memcpy_toio(mptr, cmd, 10);
+                mptr += 4;
+                writel(req->nr_sectors << KERNEL_SECTOR_SHIFT, mptr++);
+        } else
+#endif
+        {
+                writel(cmd | HOST_TID << 12 | tid, &msg->u.head[1]);
+                writel(ctl_flags, mptr++);
+                writel(req->nr_sectors << KERNEL_SECTOR_SHIFT, mptr++);
+                writel((u32) (req->sector << KERNEL_SECTOR_SHIFT), mptr++);
+                writel(req->sector >> (32 - KERNEL_SECTOR_SHIFT), mptr++);
         }
 
-        for (i = sgnum; i > 0; i--) {
-                if (i == 1)
-                        sg_flags |= 0x80000000;
-                writel(sg_flags | sg_dma_len(sg), mptr);
-                writel(sg_dma_address(sg), mptr + 4);
-                mptr += 8;
-                sg++;
+        if (!i2o_block_sglist_alloc(c, ireq, &mptr)) {
+                rc = -ENOMEM;
+                goto context_remove;
         }
 
-        writel(I2O_MESSAGE_SIZE
-               (((unsigned long)mptr -
-                 (unsigned long)&msg->u.head[0]) >> 2) | SGL_OFFSET_8,
-               &msg->u.head[0]);
+        writel(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) |
+               sgl_offset, &msg->u.head[0]);
 
         list_add_tail(&ireq->queue, &dev->open_queue);
         dev->open_queue_depth++;
@@ -920,11 +920,13 @@ static void i2o_block_request_fn(struct request_queue *q)
 
                         queue_depth = ireq->i2o_blk_dev->open_queue_depth;
 
-                        if (queue_depth < I2O_BLOCK_MAX_OPEN_REQUESTS)
+                        if (queue_depth < I2O_BLOCK_MAX_OPEN_REQUESTS) {
                                 if (!i2o_block_transfer(req)) {
                                         blkdev_dequeue_request(req);
                                         continue;
-                                }
+                                } else
+                                        osm_info("transfer error\n");
+                        }
 
                         if (queue_depth)
                                 break;
@@ -938,7 +940,6 @@ static void i2o_block_request_fn(struct request_queue *q)
                         INIT_WORK(&dreq->work, i2o_block_delayed_request_fn,
                                   dreq);
 
-                        osm_info("transfer error\n");
                         if (!queue_delayed_work(i2o_block_driver.event_queue,
                                                 &dreq->work,
                                                 I2O_BLOCK_RETRY_TIME))
@@ -1007,6 +1008,7 @@ static struct i2o_block_device *i2o_block_device_alloc(void)
         }
 
         blk_queue_prep_rq(queue, i2o_block_prep_req_fn);
+        blk_queue_issue_flush_fn(queue, i2o_block_issue_flush);
 
         gd->major = I2O_MAJOR;
         gd->queue = queue;
@@ -1039,17 +1041,27 @@ static struct i2o_block_device *i2o_block_device_alloc(void)
 static int i2o_block_probe(struct device *dev)
 {
         struct i2o_device *i2o_dev = to_i2o_device(dev);
-        struct i2o_block_device *i2o_blk_dev;
         struct i2o_controller *c = i2o_dev->iop;
+        struct i2o_block_device *i2o_blk_dev;
         struct gendisk *gd;
         struct request_queue *queue;
         static int unit = 0;
         int rc;
         u64 size;
         u32 blocksize;
-        u16 power;
         u32 flags, status;
-        int segments;
+        u16 body_size = 4;
+        unsigned short max_sectors;
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec)
+                body_size = 8;
+#endif
+
+        if (c->limit_sectors)
+                max_sectors = I2O_MAX_SECTORS_LIMITED;
+        else
+                max_sectors = I2O_MAX_SECTORS;
 
         /* skip devices which are used by IOP */
         if (i2o_dev->lct_data.user_tid != 0xfff) {
@@ -1057,8 +1069,6 @@ static int i2o_block_probe(struct device *dev)
                 return -ENODEV;
         }
 
-        osm_info("New device detected (TID: %03x)\n", i2o_dev->lct_data.tid);
-
         if (i2o_device_claim(i2o_dev)) {
                 osm_warn("Unable to claim device. Installation aborted\n");
                 rc = -EFAULT;
@@ -1086,50 +1096,44 @@ static int i2o_block_probe(struct device *dev)
         queue = gd->queue;
         queue->queuedata = i2o_blk_dev;
 
-        blk_queue_max_phys_segments(queue, I2O_MAX_SEGMENTS);
-        blk_queue_max_sectors(queue, I2O_MAX_SECTORS);
-
-        if (c->short_req)
-                segments = 8;
-        else {
-                i2o_status_block *sb;
+        blk_queue_max_phys_segments(queue, I2O_MAX_PHYS_SEGMENTS);
+        blk_queue_max_sectors(queue, max_sectors);
+        blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size));
 
-                sb = c->status_block.virt;
-
-                segments = (sb->inbound_frame_size -
-                            sizeof(struct i2o_message) / 4 - 4) / 2;
-        }
-
-        blk_queue_max_hw_segments(queue, segments);
-
-        osm_debug("max sectors = %d\n", I2O_MAX_SECTORS);
-        osm_debug("phys segments = %d\n", I2O_MAX_SEGMENTS);
-        osm_debug("hw segments = %d\n", segments);
+        osm_debug("max sectors = %d\n", queue->max_phys_segments);
+        osm_debug("phys segments = %d\n", queue->max_sectors);
+        osm_debug("max hw segments = %d\n", queue->max_hw_segments);
 
         /*
          *      Ask for the current media data. If that isn't supported
          *      then we ask for the device capacity data
          */
-        if (i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) != 0
-            || i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8) != 0) {
-                i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4);
-                i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8);
-        }
-        osm_debug("blocksize = %d\n", blocksize);
+        if (i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) ||
+            i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4)) {
+                blk_queue_hardsect_size(queue, blocksize);
+        } else
+                osm_warn("unable to get blocksize of %s\n", gd->disk_name);
 
-        if (i2o_parm_field_get(i2o_dev, 0x0000, 2, &power, 2))
-                power = 0;
+        if (i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8) ||
+            i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8)) {
+                set_capacity(gd, size >> KERNEL_SECTOR_SHIFT);
+        } else
+                osm_warn("could not get size of %s\n", gd->disk_name);
+
+        if (!i2o_parm_field_get(i2o_dev, 0x0000, 2, &i2o_blk_dev->power, 2))
+                i2o_blk_dev->power = 0;
         i2o_parm_field_get(i2o_dev, 0x0000, 5, &flags, 4);
         i2o_parm_field_get(i2o_dev, 0x0000, 6, &status, 4);
 
-        set_capacity(gd, size >> 9);
-
         i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0xffffffff);
 
         add_disk(gd);
 
         unit++;
 
+        osm_info("device added (TID: %03x): %s\n", i2o_dev->lct_data.tid,
+                 i2o_blk_dev->gd->disk_name);
+
         return 0;
 
       claim_release:
@@ -1177,7 +1181,7 @@ static int __init i2o_block_init(void)
                 goto exit;
         }
 
-        i2o_blk_req_pool.pool = mempool_create(I2O_REQ_MEMPOOL_SIZE,
+        i2o_blk_req_pool.pool = mempool_create(I2O_BLOCK_REQ_MEMPOOL_SIZE,
                                                mempool_alloc_slab,
                                                mempool_free_slab,
                                                i2o_blk_req_pool.slab);
diff --git a/drivers/message/i2o/i2o_block.h b/drivers/message/i2o/i2o_block.h
index ddd9a15679c0..4fdaa5bda412 100644
--- a/drivers/message/i2o/i2o_block.h
+++ b/drivers/message/i2o/i2o_block.h
@@ -56,42 +56,46 @@
 #define I2O_BLOCK_RETRY_TIME HZ/4
 #define I2O_BLOCK_MAX_OPEN_REQUESTS 50
 
+/* request queue sizes */
+#define I2O_BLOCK_REQ_MEMPOOL_SIZE              32
+
+#define KERNEL_SECTOR_SHIFT 9
+#define KERNEL_SECTOR_SIZE (1 << KERNEL_SECTOR_SHIFT)
+
 /* I2O Block OSM mempool struct */
 struct i2o_block_mempool {
-        kmem_cache_t    *slab;
-        mempool_t       *pool;
+        kmem_cache_t *slab;
+        mempool_t *pool;
 };
 
 /* I2O Block device descriptor */
 struct i2o_block_device {
         struct i2o_device *i2o_dev;     /* pointer to I2O device */
         struct gendisk *gd;
-        spinlock_t lock;                /* queue lock */
+        spinlock_t lock;        /* queue lock */
         struct list_head open_queue;    /* list of transfered, but unfinished
                                            requests */
         unsigned int open_queue_depth;  /* number of requests in the queue */
 
-        int rcache;                     /* read cache flags */
-        int wcache;                     /* write cache flags */
+        int rcache;             /* read cache flags */
+        int wcache;             /* write cache flags */
         int flags;
-        int power;                      /* power state */
-        int media_change_flag;          /* media changed flag */
+        u16 power;              /* power state */
+        int media_change_flag;  /* media changed flag */
 };
 
 /* I2O Block device request */
-struct i2o_block_request
-{
+struct i2o_block_request {
         struct list_head queue;
-        struct request *req;            /* corresponding request */
+        struct request *req;    /* corresponding request */
         struct i2o_block_device *i2o_blk_dev;   /* I2O block device */
-        int sg_dma_direction;           /* direction of DMA buffer read/write */
-        int sg_nents;                   /* number of SG elements */
-        struct scatterlist sg_table[I2O_MAX_SEGMENTS]; /* SG table */
+        struct device *dev;     /* device used for DMA */
+        int sg_nents;           /* number of SG elements */
+        struct scatterlist sg_table[I2O_MAX_PHYS_SEGMENTS];     /* SG table */
 };
 
 /* I2O Block device delayed request */
-struct i2o_block_delayed_request
-{
+struct i2o_block_delayed_request {
         struct work_struct work;
         struct request_queue *queue;
 };
diff --git a/drivers/message/i2o/i2o_config.c b/drivers/message/i2o/i2o_config.c
index 1fb5cdf67f8f..3c3a7abebb1b 100644
--- a/drivers/message/i2o/i2o_config.c
+++ b/drivers/message/i2o/i2o_config.c
@@ -30,29 +30,15 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/pci.h>
-#include <linux/i2o.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/miscdevice.h>
-#include <linux/mm.h>
-#include <linux/spinlock.h>
 #include <linux/smp_lock.h>
-#include <linux/ioctl32.h>
 #include <linux/compat.h>
-#include <linux/syscalls.h>
 
 #include <asm/uaccess.h>
-#include <asm/io.h>
 
-#define OSM_NAME        "config-osm"
-#define OSM_VERSION     "$Rev$"
-#define OSM_DESCRIPTION "I2O Configuration OSM"
+#include "core.h"
 
-extern int i2o_parm_issue(struct i2o_device *, int, void *, int, void *, int);
+#define SG_TABLESIZE            30
 
 static int i2o_cfg_ioctl(struct inode *inode, struct file *fp, unsigned int cmd,
                          unsigned long arg);
@@ -80,15 +66,6 @@ struct i2o_cfg_info {
 static struct i2o_cfg_info *open_files = NULL;
 static ulong i2o_cfg_info_id = 0;
 
-/*
- *      Each of these describes an i2o message handler. They are
- *      multiplexed by the i2o_core code
- */
-
-static struct i2o_driver i2o_config_driver = {
-        .name = OSM_NAME
-};
-
 static int i2o_cfg_getiops(unsigned long arg)
 {
         struct i2o_controller *c;
@@ -391,9 +368,9 @@ static int i2o_cfg_swul(unsigned long arg)
 
         i2o_dma_free(&c->pdev->dev, &buffer);
 
-return_ret:
+      return_ret:
         return ret;
-return_fault:
+      return_fault:
         ret = -EFAULT;
         goto return_ret;
 };
@@ -540,8 +517,10 @@ static int i2o_cfg_evt_get(unsigned long arg, struct file *fp)
         return 0;
 }
 
+#ifdef CONFIG_I2O_EXT_ADAPTEC
 #ifdef CONFIG_COMPAT
-static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long arg)
+static int i2o_cfg_passthru32(struct file *file, unsigned cmnd,
+                              unsigned long arg)
 {
         struct i2o_cmd_passthru32 __user *cmd;
         struct i2o_controller *c;
@@ -555,6 +534,7 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
         u32 sg_offset = 0;
         u32 sg_count = 0;
         u32 i = 0;
+        u32 sg_index = 0;
         i2o_status_block *sb;
         struct i2o_message *msg;
         u32 m;
@@ -634,8 +614,8 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                 if (sg_count > SG_TABLESIZE) {
                         printk(KERN_DEBUG "%s:IOCTL SG List too large (%u)\n",
                                c->name, sg_count);
-                        kfree(reply);
-                        return -EINVAL;
+                        rcode = -EINVAL;
+                        goto cleanup;
                 }
 
                 for (i = 0; i < sg_count; i++) {
@@ -651,7 +631,7 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                                 goto cleanup;
                         }
                         sg_size = sg[i].flag_count & 0xffffff;
-                        p = &(sg_list[i]);
+                        p = &(sg_list[sg_index++]);
                         /* Allocate memory for the transfer */
                         if (i2o_dma_alloc
                             (&c->pdev->dev, p, sg_size,
@@ -660,20 +640,21 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                                        "%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
                                        c->name, sg_size, i, sg_count);
                                 rcode = -ENOMEM;
-                                goto cleanup;
+                                goto sg_list_cleanup;
                         }
                         /* Copy in the user's SG buffer if necessary */
                         if (sg[i].
                             flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR */ ) {
                                 // TODO 64bit fix
                                 if (copy_from_user
-                                    (p->virt, (void __user *)(unsigned long)sg[i].addr_bus,
-                                     sg_size)) {
+                                    (p->virt,
+                                     (void __user *)(unsigned long)sg[i].
+                                     addr_bus, sg_size)) {
                                         printk(KERN_DEBUG
                                                "%s: Could not copy SG buf %d FROM user\n",
                                                c->name, i);
                                         rcode = -EFAULT;
-                                        goto cleanup;
+                                        goto sg_list_cleanup;
                                 }
                         }
                         //TODO 64bit fix
@@ -683,10 +664,10 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
 
         rcode = i2o_msg_post_wait(c, m, 60);
         if (rcode)
-                goto cleanup;
+                goto sg_list_cleanup;
 
         if (sg_offset) {
-                u32 msg[128];
+                u32 msg[I2O_OUTBOUND_MSG_FRAME_SIZE];
                 /* Copy back the Scatter Gather buffers back to user space */
                 u32 j;
                 // TODO 64bit fix
@@ -694,18 +675,18 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                 int sg_size;
 
                 // re-acquire the original message to handle correctly the sg copy operation
-                memset(&msg, 0, MSG_FRAME_SIZE * 4);
+                memset(&msg, 0, I2O_OUTBOUND_MSG_FRAME_SIZE * 4);
                 // get user msg size in u32s
                 if (get_user(size, &user_msg[0])) {
                         rcode = -EFAULT;
-                        goto cleanup;
+                        goto sg_list_cleanup;
                 }
                 size = size >> 16;
                 size *= 4;
                 /* Copy in the user's I2O command */
                 if (copy_from_user(msg, user_msg, size)) {
                         rcode = -EFAULT;
-                        goto cleanup;
+                        goto sg_list_cleanup;
                 }
                 sg_count =
                     (size - sg_offset * 4) / sizeof(struct sg_simple_element);
@@ -727,7 +708,7 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                                                c->name, sg_list[j].virt,
                                                sg[j].addr_bus);
                                         rcode = -EFAULT;
-                                        goto cleanup;
+                                        goto sg_list_cleanup;
                                 }
                         }
                 }
@@ -741,6 +722,7 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                                "%s: Could not copy message context FROM user\n",
                                c->name);
                         rcode = -EFAULT;
+                        goto sg_list_cleanup;
                 }
                 if (copy_to_user(user_reply, reply, reply_size)) {
                         printk(KERN_WARNING
@@ -749,16 +731,21 @@ static int i2o_cfg_passthru32(struct file *file, unsigned cmnd, unsigned long ar
                 }
         }
 
+      sg_list_cleanup:
+        for (i = 0; i < sg_index; i++)
+                i2o_dma_free(&c->pdev->dev, &sg_list[i]);
+
       cleanup:
         kfree(reply);
         return rcode;
 }
 
-static long i2o_cfg_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
+static long i2o_cfg_compat_ioctl(struct file *file, unsigned cmd,
+                                 unsigned long arg)
 {
         int ret;
-        lock_kernel();          
-        switch (cmd) { 
+        lock_kernel();
+        switch (cmd) {
         case I2OGETIOPS:
                 ret = i2o_cfg_ioctl(NULL, file, cmd, arg);
                 break;
@@ -862,8 +849,8 @@ static int i2o_cfg_passthru(unsigned long arg)
                 if (sg_count > SG_TABLESIZE) {
                         printk(KERN_DEBUG "%s:IOCTL SG List too large (%u)\n",
                                c->name, sg_count);
-                        kfree(reply);
-                        return -EINVAL;
+                        rcode = -EINVAL;
+                        goto cleanup;
                 }
 
                 for (i = 0; i < sg_count; i++) {
@@ -875,7 +862,7 @@ static int i2o_cfg_passthru(unsigned long arg)
                                        "%s:Bad SG element %d - not simple (%x)\n",
                                        c->name, i, sg[i].flag_count);
                                 rcode = -EINVAL;
-                                goto cleanup;
+                                goto sg_list_cleanup;
                         }
                         sg_size = sg[i].flag_count & 0xffffff;
                         /* Allocate memory for the transfer */
@@ -885,7 +872,7 @@ static int i2o_cfg_passthru(unsigned long arg)
                                        "%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
                                        c->name, sg_size, i, sg_count);
                                 rcode = -ENOMEM;
-                                goto cleanup;
+                                goto sg_list_cleanup;
                         }
                         sg_list[sg_index++] = p;        // sglist indexed with input frame, not our internal frame.
                         /* Copy in the user's SG buffer if necessary */
@@ -899,7 +886,7 @@ static int i2o_cfg_passthru(unsigned long arg)
                                                "%s: Could not copy SG buf %d FROM user\n",
                                                c->name, i);
                                         rcode = -EFAULT;
-                                        goto cleanup;
+                                        goto sg_list_cleanup;
                                 }
                         }
                         //TODO 64bit fix
@@ -909,7 +896,7 @@ static int i2o_cfg_passthru(unsigned long arg)
 
         rcode = i2o_msg_post_wait(c, m, 60);
         if (rcode)
-                goto cleanup;
+                goto sg_list_cleanup;
 
         if (sg_offset) {
                 u32 msg[128];
@@ -920,18 +907,18 @@ static int i2o_cfg_passthru(unsigned long arg)
                 int sg_size;
 
                 // re-acquire the original message to handle correctly the sg copy operation
-                memset(&msg, 0, MSG_FRAME_SIZE * 4);
+                memset(&msg, 0, I2O_OUTBOUND_MSG_FRAME_SIZE * 4);
                 // get user msg size in u32s
                 if (get_user(size, &user_msg[0])) {
                         rcode = -EFAULT;
-                        goto cleanup;
+                        goto sg_list_cleanup;
                 }
                 size = size >> 16;
                 size *= 4;
                 /* Copy in the user's I2O command */
                 if (copy_from_user(msg, user_msg, size)) {
                         rcode = -EFAULT;
-                        goto cleanup;
+                        goto sg_list_cleanup;
                 }
                 sg_count =
                     (size - sg_offset * 4) / sizeof(struct sg_simple_element);
@@ -953,7 +940,7 @@ static int i2o_cfg_passthru(unsigned long arg)
                                                c->name, sg_list[j],
                                                sg[j].addr_bus);
                                         rcode = -EFAULT;
-                                        goto cleanup;
+                                        goto sg_list_cleanup;
                                 }
                         }
                 }
@@ -975,10 +962,15 @@ static int i2o_cfg_passthru(unsigned long arg)
                 }
         }
 
+      sg_list_cleanup:
+        for (i = 0; i < sg_index; i++)
+                kfree(sg_list[i]);
+
       cleanup:
         kfree(reply);
         return rcode;
 }
+#endif
 
 /*
  * IOCTL Handler
@@ -1033,9 +1025,11 @@ static int i2o_cfg_ioctl(struct inode *inode, struct file *fp, unsigned int cmd,
                 ret = i2o_cfg_evt_get(arg, fp);
                 break;
 
+#ifdef CONFIG_I2O_EXT_ADAPTEC
         case I2OPASSTHRU:
                 ret = i2o_cfg_passthru(arg);
                 break;
+#endif
 
         default:
                 osm_debug("unknown ioctl called!\n");
@@ -1137,37 +1131,21 @@ static struct miscdevice i2o_miscdev = {
         &config_fops
 };
 
-static int __init i2o_config_init(void)
+static int __init i2o_config_old_init(void)
 {
-        printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
-
         spin_lock_init(&i2o_config_lock);
 
         if (misc_register(&i2o_miscdev) < 0) {
                 osm_err("can't register device.\n");
                 return -EBUSY;
         }
-        /*
-         *      Install our handler
-         */
-        if (i2o_driver_register(&i2o_config_driver)) {
-                osm_err("handler register failed.\n");
-                misc_deregister(&i2o_miscdev);
-                return -EBUSY;
-        }
+
         return 0;
 }
 
-static void i2o_config_exit(void)
+static void i2o_config_old_exit(void)
 {
         misc_deregister(&i2o_miscdev);
-        i2o_driver_unregister(&i2o_config_driver);
 }
 
 MODULE_AUTHOR("Red Hat Software");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION(OSM_DESCRIPTION);
-MODULE_VERSION(OSM_VERSION);
-
-module_init(i2o_config_init);
-module_exit(i2o_config_exit);
diff --git a/drivers/message/i2o/i2o_proc.c b/drivers/message/i2o/i2o_proc.c
index b176d0eeff7f..d559a1758363 100644
--- a/drivers/message/i2o/i2o_proc.c
+++ b/drivers/message/i2o/i2o_proc.c
@@ -28,7 +28,7 @@
  */
 
 #define OSM_NAME        "proc-osm"
-#define OSM_VERSION     "$Rev$"
+#define OSM_VERSION     "1.145"
 #define OSM_DESCRIPTION "I2O ProcFS OSM"
 
 #define I2O_MAX_MODULES 4
@@ -228,7 +228,7 @@ static const char *i2o_get_class_name(int class)
         case I2O_CLASS_FLOPPY_DEVICE:
                 idx = 12;
                 break;
-        case I2O_CLASS_BUS_ADAPTER_PORT:
+        case I2O_CLASS_BUS_ADAPTER:
                 idx = 13;
                 break;
         case I2O_CLASS_PEER_TRANSPORT_AGENT:
@@ -490,7 +490,7 @@ static int i2o_seq_show_lct(struct seq_file *seq, void *v)
                                 seq_printf(seq, ", Unknown Device Type");
                         break;
 
-                case I2O_CLASS_BUS_ADAPTER_PORT:
+                case I2O_CLASS_BUS_ADAPTER:
                         if (lct->lct_entry[i].sub_class < BUS_TABLE_SIZE)
                                 seq_printf(seq, ", %s",
                                            bus_ports[lct->lct_entry[i].
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index 43f5875e0be5..9f1744c3933b 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -54,6 +54,7 @@
 #include <linux/pci.h>
 #include <linux/blkdev.h>
 #include <linux/i2o.h>
+#include <linux/scatterlist.h>
 
 #include <asm/dma.h>
 #include <asm/system.h>
@@ -64,19 +65,23 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_request.h>
+#include <scsi/sg.h>
+#include <scsi/sg_request.h>
 
 #define OSM_NAME        "scsi-osm"
-#define OSM_VERSION     "$Rev$"
+#define OSM_VERSION     "1.282"
 #define OSM_DESCRIPTION "I2O SCSI Peripheral OSM"
 
 static struct i2o_driver i2o_scsi_driver;
 
-static int i2o_scsi_max_id = 16;
-static int i2o_scsi_max_lun = 8;
+static unsigned int i2o_scsi_max_id = 16;
+static unsigned int i2o_scsi_max_lun = 255;
 
 struct i2o_scsi_host {
         struct Scsi_Host *scsi_host;    /* pointer to the SCSI host */
         struct i2o_controller *iop;     /* pointer to the I2O controller */
+        unsigned int lun;       /* lun's used for block devices */
         struct i2o_device *channel[0];  /* channel->i2o_dev mapping table */
 };
 
@@ -99,11 +104,17 @@ static struct i2o_scsi_host *i2o_scsi_host_alloc(struct i2o_controller *c)
         u8 type;
         int i;
         size_t size;
-        i2o_status_block *sb;
+        u16 body_size = 6;
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec)
+                body_size = 8;
+#endif
 
         list_for_each_entry(i2o_dev, &c->devices, list)
-            if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT) {
-                if (i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1) || (type == 1))    /* SCSI bus */
+            if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER) {
+                if (i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1)
+                    && (type == 0x01))  /* SCSI bus */
                         max_channel++;
         }
 
@@ -125,20 +136,18 @@ static struct i2o_scsi_host *i2o_scsi_host_alloc(struct i2o_controller *c)
         scsi_host->max_id = i2o_scsi_max_id;
         scsi_host->max_lun = i2o_scsi_max_lun;
         scsi_host->this_id = c->unit;
-
-        sb = c->status_block.virt;
-
-        scsi_host->sg_tablesize = (sb->inbound_frame_size -
-                                   sizeof(struct i2o_message) / 4 - 6) / 2;
+        scsi_host->sg_tablesize = i2o_sg_tablesize(c, body_size);
 
         i2o_shost = (struct i2o_scsi_host *)scsi_host->hostdata;
         i2o_shost->scsi_host = scsi_host;
         i2o_shost->iop = c;
+        i2o_shost->lun = 1;
 
         i = 0;
         list_for_each_entry(i2o_dev, &c->devices, list)
-            if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER_PORT) {
-                if (i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1) || (type == 1))    /* only SCSI bus */
+            if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER) {
+                if (i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1)
+                    && (type == 0x01))  /* only SCSI bus */
                         i2o_shost->channel[i++] = i2o_dev;
 
                 if (i >= max_channel)
@@ -178,10 +187,13 @@ static int i2o_scsi_remove(struct device *dev)
         struct i2o_scsi_host *i2o_shost;
         struct scsi_device *scsi_dev;
 
+        osm_info("device removed (TID: %03x)\n", i2o_dev->lct_data.tid);
+
         i2o_shost = i2o_scsi_get_host(c);
 
         shost_for_each_device(scsi_dev, i2o_shost->scsi_host)
             if (scsi_dev->hostdata == i2o_dev) {
+                sysfs_remove_link(&i2o_dev->device.kobj, "scsi");
                 scsi_remove_device(scsi_dev);
                 scsi_device_put(scsi_dev);
                 break;
@@ -207,8 +219,8 @@ static int i2o_scsi_probe(struct device *dev)
         struct Scsi_Host *scsi_host;
         struct i2o_device *parent;
         struct scsi_device *scsi_dev;
-        u32 id;
-        u64 lun;
+        u32 id = -1;
+        u64 lun = -1;
         int channel = -1;
         int i;
 
@@ -218,8 +230,56 @@ static int i2o_scsi_probe(struct device *dev)
 
         scsi_host = i2o_shost->scsi_host;
 
-        if (i2o_parm_field_get(i2o_dev, 0, 3, &id, 4) < 0)
+        switch (i2o_dev->lct_data.class_id) {
+        case I2O_CLASS_RANDOM_BLOCK_STORAGE:
+        case I2O_CLASS_EXECUTIVE:
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+                if (c->adaptec) {
+                        u8 type;
+                        struct i2o_device *d = i2o_shost->channel[0];
+
+                        if (i2o_parm_field_get(d, 0x0000, 0, &type, 1)
+                            && (type == 0x01))  /* SCSI bus */
+                                if (i2o_parm_field_get(d, 0x0200, 4, &id, 4)) {
+                                        channel = 0;
+                                        if (i2o_dev->lct_data.class_id ==
+                                            I2O_CLASS_RANDOM_BLOCK_STORAGE)
+                                                lun = i2o_shost->lun++;
+                                        else
+                                                lun = 0;
+                                }
+                }
+#endif
+                break;
+
+        case I2O_CLASS_SCSI_PERIPHERAL:
+                if (i2o_parm_field_get(i2o_dev, 0x0000, 3, &id, 4) < 0)
+                        return -EFAULT;
+
+                if (i2o_parm_field_get(i2o_dev, 0x0000, 4, &lun, 8) < 0)
+                        return -EFAULT;
+
+                parent = i2o_iop_find_device(c, i2o_dev->lct_data.parent_tid);
+                if (!parent) {
+                        osm_warn("can not find parent of device %03x\n",
+                                 i2o_dev->lct_data.tid);
+                        return -EFAULT;
+                }
+
+                for (i = 0; i <= i2o_shost->scsi_host->max_channel; i++)
+                        if (i2o_shost->channel[i] == parent)
+                                channel = i;
+                break;
+
+        default:
                 return -EFAULT;
+        }
+
+        if (channel == -1) {
+                osm_warn("can not find channel of device %03x\n",
+                         i2o_dev->lct_data.tid);
+                return -EFAULT;
+        }
 
         if (id >= scsi_host->max_id) {
                 osm_warn("SCSI device id (%d) >= max_id of I2O host (%d)", id,
@@ -227,42 +287,26 @@ static int i2o_scsi_probe(struct device *dev)
                 return -EFAULT;
         }
 
-        if (i2o_parm_field_get(i2o_dev, 0, 4, &lun, 8) < 0)
-                return -EFAULT;
         if (lun >= scsi_host->max_lun) {
                 osm_warn("SCSI device id (%d) >= max_lun of I2O host (%d)",
                          (unsigned int)lun, scsi_host->max_lun);
                 return -EFAULT;
         }
 
-        parent = i2o_iop_find_device(c, i2o_dev->lct_data.parent_tid);
-        if (!parent) {
-                osm_warn("can not find parent of device %03x\n",
-                         i2o_dev->lct_data.tid);
-                return -EFAULT;
-        }
-
-        for (i = 0; i <= i2o_shost->scsi_host->max_channel; i++)
-                if (i2o_shost->channel[i] == parent)
-                        channel = i;
-
-        if (channel == -1) {
-                osm_warn("can not find channel of device %03x\n",
-                         i2o_dev->lct_data.tid);
-                return -EFAULT;
-        }
-
         scsi_dev =
             __scsi_add_device(i2o_shost->scsi_host, channel, id, lun, i2o_dev);
 
-        if (!scsi_dev) {
+        if (IS_ERR(scsi_dev)) {
                 osm_warn("can not add SCSI device %03x\n",
                          i2o_dev->lct_data.tid);
-                return -EFAULT;
+                return PTR_ERR(scsi_dev);
         }
 
-        osm_debug("added new SCSI device %03x (cannel: %d, id: %d, lun: %d)\n",
-                  i2o_dev->lct_data.tid, channel, id, (unsigned int)lun);
+        sysfs_create_link(&i2o_dev->device.kobj, &scsi_dev->sdev_gendev.kobj,
+                          "scsi");
+
+        osm_info("device added (TID: %03x) channel: %d, id: %d, lun: %d\n",
+                 i2o_dev->lct_data.tid, channel, id, (unsigned int)lun);
 
         return 0;
 };
@@ -293,162 +337,89 @@ static int i2o_scsi_reply(struct i2o_controller *c, u32 m,
                           struct i2o_message *msg)
 {
         struct scsi_cmnd *cmd;
+        u32 error;
         struct device *dev;
-        u8 as, ds, st;
 
         cmd = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt));
-
-        if (msg->u.head[0] & (1 << 13)) {
-                struct i2o_message __iomem *pmsg;       /* preserved message */
-                u32 pm;
-                int err = DID_ERROR;
-
-                pm = le32_to_cpu(msg->body[3]);
-
-                pmsg = i2o_msg_in_to_virt(c, pm);
-
-                osm_err("IOP fail.\n");
-                osm_err("From %d To %d Cmd %d.\n",
-                        (msg->u.head[1] >> 12) & 0xFFF,
-                        msg->u.head[1] & 0xFFF, msg->u.head[1] >> 24);
-                osm_err("Failure Code %d.\n", msg->body[0] >> 24);
-                if (msg->body[0] & (1 << 16))
-                        osm_err("Format error.\n");
-                if (msg->body[0] & (1 << 17))
-                        osm_err("Path error.\n");
-                if (msg->body[0] & (1 << 18))
-                        osm_err("Path State.\n");
-                if (msg->body[0] & (1 << 18))
-                {
-                        osm_err("Congestion.\n");
-                        err = DID_BUS_BUSY;
-                }
-
-                osm_debug("Failing message is %p.\n", pmsg);
-
-                cmd = i2o_cntxt_list_get(c, readl(&pmsg->u.s.tcntxt));
-                if (!cmd)
-                        return 1;
-
-                cmd->result = err << 16;
-                cmd->scsi_done(cmd);
-
-                /* Now flush the message by making it a NOP */
-                i2o_msg_nop(c, pm);
-
-                return 1;
+        if (unlikely(!cmd)) {
+                osm_err("NULL reply received!\n");
+                return -1;
         }
 
         /*
          *      Low byte is device status, next is adapter status,
          *      (then one byte reserved), then request status.
          */
-        ds = (u8) le32_to_cpu(msg->body[0]);
-        as = (u8) (le32_to_cpu(msg->body[0]) >> 8);
-        st = (u8) (le32_to_cpu(msg->body[0]) >> 24);
+        error = le32_to_cpu(msg->body[0]);
+
+        osm_debug("Completed %ld\n", cmd->serial_number);
 
+        cmd->result = error & 0xff;
         /*
-         *      Is this a control request coming back - eg an abort ?
+         * if DeviceStatus is not SCSI_SUCCESS copy over the sense data and let
+         * the SCSI layer handle the error
          */
+        if (cmd->result)
+                memcpy(cmd->sense_buffer, &msg->body[3],
+                       min(sizeof(cmd->sense_buffer), (size_t) 40));
 
-        if (!cmd) {
-                if (st)
-                        osm_warn("SCSI abort: %08X", le32_to_cpu(msg->body[0]));
-                osm_info("SCSI abort completed.\n");
-                return -EFAULT;
-        }
+        /* only output error code if AdapterStatus is not HBA_SUCCESS */
+        if ((error >> 8) & 0xff)
+                osm_err("SCSI error %08x\n", error);
 
-        osm_debug("Completed %ld\n", cmd->serial_number);
+        dev = &c->pdev->dev;
+        if (cmd->use_sg)
+                dma_unmap_sg(dev, cmd->request_buffer, cmd->use_sg,
+                             cmd->sc_data_direction);
+        else if (cmd->SCp.dma_handle)
+                dma_unmap_single(dev, cmd->SCp.dma_handle, cmd->request_bufflen,
+                                 cmd->sc_data_direction);
 
-        if (st) {
-                u32 count, error;
-                /* An error has occurred */
-
-                switch (st) {
-                case 0x06:
-                        count = le32_to_cpu(msg->body[1]);
-                        if (count < cmd->underflow) {
-                                int i;
-
-                                osm_err("SCSI underflow 0x%08X 0x%08X\n", count,
-                                        cmd->underflow);
-                                osm_debug("Cmd: ");
-                                for (i = 0; i < 15; i++)
-                                        pr_debug("%02X ", cmd->cmnd[i]);
-                                pr_debug(".\n");
-                                cmd->result = (DID_ERROR << 16);
-                        }
-                        break;
+        cmd->scsi_done(cmd);
 
-                default:
-                        error = le32_to_cpu(msg->body[0]);
-
-                        osm_err("SCSI error %08x\n", error);
-
-                        if ((error & 0xff) == 0x02 /*CHECK_CONDITION */ ) {
-                                int i;
-                                u32 len = sizeof(cmd->sense_buffer);
-                                len = (len > 40) ? 40 : len;
-                                // Copy over the sense data
-                                memcpy(cmd->sense_buffer, (void *)&msg->body[3],
-                                       len);
-                                for (i = 0; i <= len; i++)
-                                        osm_info("%02x\n",
-                                                 cmd->sense_buffer[i]);
-                                if (cmd->sense_buffer[0] == 0x70
-                                    && cmd->sense_buffer[2] == DATA_PROTECT) {
-                                        /* This is to handle an array failed */
-                                        cmd->result = (DID_TIME_OUT << 16);
-                                        printk(KERN_WARNING "%s: SCSI Data "
-                                               "Protect-Device (%d,%d,%d) "
-                                               "hba_status=0x%x, dev_status="
-                                               "0x%x, cmd=0x%x\n", c->name,
-                                               (u32) cmd->device->channel,
-                                               (u32) cmd->device->id,
-                                               (u32) cmd->device->lun,
-                                               (error >> 8) & 0xff,
-                                               error & 0xff, cmd->cmnd[0]);
-                                } else
-                                        cmd->result = (DID_ERROR << 16);
-
-                                break;
-                        }
-
-                        switch (as) {
-                        case 0x0E:
-                                /* SCSI Reset */
-                                cmd->result = DID_RESET << 16;
-                                break;
-
-                        case 0x0F:
-                                cmd->result = DID_PARITY << 16;
-                                break;
-
-                        default:
-                                cmd->result = DID_ERROR << 16;
-                                break;
-                        }
+        return 1;
+};
 
-                        break;
-                }
+/**
+ *      i2o_scsi_notify_device_add - Retrieve notifications of added devices
+ *      @i2o_dev: the I2O device which was added
+ *
+ *      If a I2O device is added we catch the notification, because I2O classes
+ *      other then SCSI peripheral will not be received through
+ *      i2o_scsi_probe().
+ */
+static void i2o_scsi_notify_device_add(struct i2o_device *i2o_dev)
+{
+        switch (i2o_dev->lct_data.class_id) {
+        case I2O_CLASS_EXECUTIVE:
+        case I2O_CLASS_RANDOM_BLOCK_STORAGE:
+                i2o_scsi_probe(&i2o_dev->device);
+                break;
 
-                cmd->scsi_done(cmd);
-                return 1;
+        default:
+                break;
         }
+};
 
-        cmd->result = DID_OK << 16 | ds;
-
-        cmd->scsi_done(cmd);
-
-        dev = &c->pdev->dev;
-        if (cmd->use_sg)
-                dma_unmap_sg(dev, (struct scatterlist *)cmd->buffer,
-                             cmd->use_sg, cmd->sc_data_direction);
-        else if (cmd->request_bufflen)
-                dma_unmap_single(dev, (dma_addr_t) ((long)cmd->SCp.ptr),
-                                 cmd->request_bufflen, cmd->sc_data_direction);
+/**
+ *      i2o_scsi_notify_device_remove - Retrieve notifications of removed
+ *                                      devices
+ *      @i2o_dev: the I2O device which was removed
+ *
+ *      If a I2O device is removed, we catch the notification to remove the
+ *      corresponding SCSI device.
+ */
+static void i2o_scsi_notify_device_remove(struct i2o_device *i2o_dev)
+{
+        switch (i2o_dev->lct_data.class_id) {
+        case I2O_CLASS_EXECUTIVE:
+        case I2O_CLASS_RANDOM_BLOCK_STORAGE:
+                i2o_scsi_remove(&i2o_dev->device);
+                break;
 
-        return 1;
+        default:
+                break;
+        }
 };
 
 /**
@@ -501,7 +472,7 @@ static void i2o_scsi_notify_controller_remove(struct i2o_controller *c)
 
         scsi_remove_host(i2o_shost->scsi_host);
         scsi_host_put(i2o_shost->scsi_host);
-        pr_info("I2O SCSI host removed\n");
+        osm_debug("I2O SCSI host removed\n");
 };
 
 /* SCSI OSM driver struct */
@@ -509,6 +480,8 @@ static struct i2o_driver i2o_scsi_driver = {
         .name = OSM_NAME,
         .reply = i2o_scsi_reply,
         .classes = i2o_scsi_class_id,
+        .notify_device_add = i2o_scsi_notify_device_add,
+        .notify_device_remove = i2o_scsi_notify_device_remove,
         .notify_controller_add = i2o_scsi_notify_controller_add,
         .notify_controller_remove = i2o_scsi_notify_controller_remove,
         .driver = {
@@ -535,26 +508,26 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
                                  void (*done) (struct scsi_cmnd *))
 {
         struct i2o_controller *c;
-        struct Scsi_Host *host;
         struct i2o_device *i2o_dev;
-        struct device *dev;
         int tid;
         struct i2o_message __iomem *msg;
         u32 m;
-        u32 scsi_flags, sg_flags;
+        /*
+         * ENABLE_DISCONNECT
+         * SIMPLE_TAG
+         * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME
+         */
+        u32 scsi_flags = 0x20a00000;
+        u32 sgl_offset;
         u32 __iomem *mptr;
-        u32 __iomem *lenptr;
-        u32 len, reqlen;
-        int i;
+        u32 cmd = I2O_CMD_SCSI_EXEC << 24;
+        int rc = 0;
 
         /*
          *      Do the incoming paperwork
          */
-
         i2o_dev = SCpnt->device->hostdata;
-        host = SCpnt->device->host;
         c = i2o_dev->iop;
-        dev = &c->pdev->dev;
 
         SCpnt->scsi_done = done;
 
@@ -562,7 +535,7 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
                 osm_warn("no I2O device in request\n");
                 SCpnt->result = DID_NO_CONNECT << 16;
                 done(SCpnt);
-                return 0;
+                goto exit;
         }
 
         tid = i2o_dev->lct_data.tid;
@@ -571,44 +544,85 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
         osm_debug("Real scsi messages.\n");
 
         /*
-         *      Obtain an I2O message. If there are none free then
-         *      throw it back to the scsi layer
-         */
-
-        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
-        if (m == I2O_QUEUE_EMPTY)
-                return SCSI_MLQUEUE_HOST_BUSY;
-
-        /*
          *      Put together a scsi execscb message
          */
-
-        len = SCpnt->request_bufflen;
-
         switch (SCpnt->sc_data_direction) {
         case PCI_DMA_NONE:
-                scsi_flags = 0x00000000;        // DATA NO XFER
-                sg_flags = 0x00000000;
+                /* DATA NO XFER */
+                sgl_offset = SGL_OFFSET_0;
                 break;
 
         case PCI_DMA_TODEVICE:
-                scsi_flags = 0x80000000;        // DATA OUT (iop-->dev)
-                sg_flags = 0x14000000;
+                /* DATA OUT (iop-->dev) */
+                scsi_flags |= 0x80000000;
+                sgl_offset = SGL_OFFSET_10;
                 break;
 
         case PCI_DMA_FROMDEVICE:
-                scsi_flags = 0x40000000;        // DATA IN  (iop<--dev)
-                sg_flags = 0x10000000;
+                /* DATA IN  (iop<--dev) */
+                scsi_flags |= 0x40000000;
+                sgl_offset = SGL_OFFSET_10;
                 break;
 
         default:
                 /* Unknown - kill the command */
                 SCpnt->result = DID_NO_CONNECT << 16;
                 done(SCpnt);
-                return 0;
+                goto exit;
         }
 
-        writel(I2O_CMD_SCSI_EXEC << 24 | HOST_TID << 12 | tid, &msg->u.head[1]);
+        /*
+         *      Obtain an I2O message. If there are none free then
+         *      throw it back to the scsi layer
+         */
+
+        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
+        if (m == I2O_QUEUE_EMPTY) {
+                rc = SCSI_MLQUEUE_HOST_BUSY;
+                goto exit;
+        }
+
+        mptr = &msg->body[0];
+
+#ifdef CONFIG_I2O_EXT_ADAPTEC
+        if (c->adaptec) {
+                u32 adpt_flags = 0;
+
+                if (SCpnt->sc_request && SCpnt->sc_request->upper_private_data) {
+                        i2o_sg_io_hdr_t __user *usr_ptr =
+                            ((Sg_request *) (SCpnt->sc_request->
+                                             upper_private_data))->header.
+                            usr_ptr;
+
+                        if (usr_ptr)
+                                get_user(adpt_flags, &usr_ptr->flags);
+                }
+
+                switch (i2o_dev->lct_data.class_id) {
+                case I2O_CLASS_EXECUTIVE:
+                case I2O_CLASS_RANDOM_BLOCK_STORAGE:
+                        /* interpret flag has to be set for executive */
+                        adpt_flags ^= I2O_DPT_SG_FLAG_INTERPRET;
+                        break;
+
+                default:
+                        break;
+                }
+
+                /*
+                 * for Adaptec controllers we use the PRIVATE command, because
+                 * the normal SCSI EXEC doesn't support all SCSI commands on
+                 * all controllers (for example READ CAPACITY).
+                 */
+                if (sgl_offset == SGL_OFFSET_10)
+                        sgl_offset = SGL_OFFSET_12;
+                cmd = I2O_CMD_PRIVATE << 24;
+                writel(I2O_VENDOR_DPT << 16 | I2O_CMD_SCSI_EXEC, mptr++);
+                writel(adpt_flags | tid, mptr++);
+        }
+#endif
+
+        writel(cmd | HOST_TID << 12 | tid, &msg->u.head[1]);
         writel(i2o_scsi_driver.context, &msg->u.s.icntxt);
 
         /* We want the SCSI control block back */
@@ -626,7 +640,7 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
          */
 
         /* Attach tags to the devices */
-        /*
+        /* FIXME: implement
            if(SCpnt->device->tagged_supported) {
            if(SCpnt->tag == HEAD_OF_QUEUE_TAG)
            scsi_flags |= 0x01000000;
@@ -635,67 +649,35 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
            }
          */
 
-        /* Direction, disconnect ok, tag, CDBLen */
-        writel(scsi_flags | 0x20200000 | SCpnt->cmd_len, &msg->body[0]);
-
-        mptr = &msg->body[1];
+        writel(scsi_flags | SCpnt->cmd_len, mptr++);
 
         /* Write SCSI command into the message - always 16 byte block */
         memcpy_toio(mptr, SCpnt->cmnd, 16);
         mptr += 4;
-        lenptr = mptr++;        /* Remember me - fill in when we know */
-
-        reqlen = 12;            // SINGLE SGE
-
-        /* Now fill in the SGList and command */
-        if (SCpnt->use_sg) {
-                struct scatterlist *sg;
-                int sg_count;
-
-                sg = SCpnt->request_buffer;
-                len = 0;
-
-                sg_count = dma_map_sg(dev, sg, SCpnt->use_sg,
-                                      SCpnt->sc_data_direction);
 
-                if (unlikely(sg_count <= 0))
-                        return -ENOMEM;
-
-                for (i = SCpnt->use_sg; i > 0; i--) {
-                        if (i == 1)
-                                sg_flags |= 0xC0000000;
-                        writel(sg_flags | sg_dma_len(sg), mptr++);
-                        writel(sg_dma_address(sg), mptr++);
-                        len += sg_dma_len(sg);
-                        sg++;
+        if (sgl_offset != SGL_OFFSET_0) {
+                /* write size of data addressed by SGL */
+                writel(SCpnt->request_bufflen, mptr++);
+
+                /* Now fill in the SGList and command */
+                if (SCpnt->use_sg) {
+                        if (!i2o_dma_map_sg(c, SCpnt->request_buffer,
+                                            SCpnt->use_sg,
+                                            SCpnt->sc_data_direction, &mptr))
+                                goto nomem;
+                } else {
+                        SCpnt->SCp.dma_handle =
+                            i2o_dma_map_single(c, SCpnt->request_buffer,
+                                               SCpnt->request_bufflen,
+                                               SCpnt->sc_data_direction, &mptr);
+                        if (dma_mapping_error(SCpnt->SCp.dma_handle))
+                                goto nomem;
                 }
-
-                reqlen = mptr - &msg->u.head[0];
-                writel(len, lenptr);
-        } else {
-                len = SCpnt->request_bufflen;
-
-                writel(len, lenptr);
-
-                if (len > 0) {
-                        dma_addr_t dma_addr;
-
-                        dma_addr = dma_map_single(dev, SCpnt->request_buffer,
-                                                  SCpnt->request_bufflen,
-                                                  SCpnt->sc_data_direction);
-                        if (!dma_addr)
-                                return -ENOMEM;
-
-                        SCpnt->SCp.ptr = (void *)(unsigned long)dma_addr;
-                        sg_flags |= 0xC0000000;
-                        writel(sg_flags | SCpnt->request_bufflen, mptr++);
-                        writel(dma_addr, mptr++);
-                } else
-                        reqlen = 9;
         }
 
         /* Stick the headers on */
-        writel(reqlen << 16 | SGL_OFFSET_10, &msg->u.head[0]);
+        writel(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) | sgl_offset,
+               &msg->u.head[0]);
 
         /* Queue the message */
         i2o_msg_post(c, m);
@@ -703,6 +685,13 @@ static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt,
         osm_debug("Issued %ld\n", SCpnt->serial_number);
 
         return 0;
+
+      nomem:
+        rc = -ENOMEM;
+        i2o_msg_nop(c, m);
+
+      exit:
+        return rc;
 };
 
 /**
diff --git a/drivers/message/i2o/iop.c b/drivers/message/i2o/iop.c
index 50c8cedf7a2d..42f8b810d6e5 100644
--- a/drivers/message/i2o/iop.c
+++ b/drivers/message/i2o/iop.c
@@ -28,8 +28,10 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
+#include "core.h"
 
-#define OSM_VERSION     "$Rev$"
+#define OSM_NAME        "i2o"
+#define OSM_VERSION     "1.288"
 #define OSM_DESCRIPTION "I2O subsystem"
 
 /* global I2O controller list */
@@ -43,20 +45,6 @@ static struct i2o_dma i2o_systab;
 
 static int i2o_hrt_get(struct i2o_controller *c);
 
-/* Module internal functions from other sources */
-extern struct i2o_driver i2o_exec_driver;
-extern int i2o_exec_lct_get(struct i2o_controller *);
-extern void i2o_device_remove(struct i2o_device *);
-
-extern int __init i2o_driver_init(void);
-extern void __exit i2o_driver_exit(void);
-extern int __init i2o_exec_init(void);
-extern void __exit i2o_exec_exit(void);
-extern int __init i2o_pci_init(void);
-extern void __exit i2o_pci_exit(void);
-extern int i2o_device_init(void);
-extern void i2o_device_exit(void);
-
 /**
  *      i2o_msg_nop - Returns a message which is not used
  *      @c: I2O controller from which the message was created
@@ -68,7 +56,7 @@ extern void i2o_device_exit(void);
  */
 void i2o_msg_nop(struct i2o_controller *c, u32 m)
 {
-        struct i2o_message __iomem *msg = c->in_queue.virt + m;
+        struct i2o_message __iomem *msg = i2o_msg_in_to_virt(c, m);
 
         writel(THREE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
         writel(I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | ADAPTER_TID,
@@ -92,16 +80,16 @@ void i2o_msg_nop(struct i2o_controller *c, u32 m)
  *      address from the read port (see the i2o spec). If no message is
  *      available returns I2O_QUEUE_EMPTY and msg is leaved untouched.
  */
-u32 i2o_msg_get_wait(struct i2o_controller *c, struct i2o_message __iomem **msg,
-                     int wait)
+u32 i2o_msg_get_wait(struct i2o_controller *c,
+                     struct i2o_message __iomem ** msg, int wait)
 {
         unsigned long timeout = jiffies + wait * HZ;
         u32 m;
 
         while ((m = i2o_msg_get(c, msg)) == I2O_QUEUE_EMPTY) {
                 if (time_after(jiffies, timeout)) {
-                        pr_debug("%s: Timeout waiting for message frame.\n",
-                                 c->name);
+                        osm_debug("%s: Timeout waiting for message frame.\n",
+                                  c->name);
                         return I2O_QUEUE_EMPTY;
                 }
                 set_current_state(TASK_UNINTERRUPTIBLE);
@@ -129,13 +117,13 @@ u32 i2o_cntxt_list_add(struct i2o_controller * c, void *ptr)
         unsigned long flags;
 
         if (!ptr)
-                printk(KERN_ERR "%s: couldn't add NULL pointer to context list!"
-                       "\n", c->name);
+                osm_err("%s: couldn't add NULL pointer to context list!\n",
+                        c->name);
 
         entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
         if (!entry) {
-                printk(KERN_ERR "%s: Could not allocate memory for context "
-                       "list element\n", c->name);
+                osm_err("%s: Could not allocate memory for context list element"
+                        "\n", c->name);
                 return 0;
         }
 
@@ -154,7 +142,7 @@ u32 i2o_cntxt_list_add(struct i2o_controller * c, void *ptr)
 
         spin_unlock_irqrestore(&c->context_list_lock, flags);
 
-        pr_debug("%s: Add context to list %p -> %d\n", c->name, ptr, context);
+        osm_debug("%s: Add context to list %p -> %d\n", c->name, ptr, context);
 
         return entry->context;
 };
@@ -186,11 +174,11 @@ u32 i2o_cntxt_list_remove(struct i2o_controller * c, void *ptr)
         spin_unlock_irqrestore(&c->context_list_lock, flags);
 
         if (!context)
-                printk(KERN_WARNING "%s: Could not remove nonexistent ptr "
-                       "%p\n", c->name, ptr);
+                osm_warn("%s: Could not remove nonexistent ptr %p\n", c->name,
+                         ptr);
 
-        pr_debug("%s: remove ptr from context list %d -> %p\n", c->name,
-                 context, ptr);
+        osm_debug("%s: remove ptr from context list %d -> %p\n", c->name,
+                  context, ptr);
 
         return context;
 };
@@ -220,11 +208,10 @@ void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
         spin_unlock_irqrestore(&c->context_list_lock, flags);
 
         if (!ptr)
-                printk(KERN_WARNING "%s: context id %d not found\n", c->name,
-                       context);
+                osm_warn("%s: context id %d not found\n", c->name, context);
 
-        pr_debug("%s: get ptr from context list %d -> %p\n", c->name, context,
-                 ptr);
+        osm_debug("%s: get ptr from context list %d -> %p\n", c->name, context,
+                  ptr);
 
         return ptr;
 };
@@ -252,11 +239,11 @@ u32 i2o_cntxt_list_get_ptr(struct i2o_controller * c, void *ptr)
         spin_unlock_irqrestore(&c->context_list_lock, flags);
 
         if (!context)
-                printk(KERN_WARNING "%s: Could not find nonexistent ptr "
-                       "%p\n", c->name, ptr);
+                osm_warn("%s: Could not find nonexistent ptr %p\n", c->name,
+                         ptr);
 
-        pr_debug("%s: get context id from context list %p -> %d\n", c->name,
-                 ptr, context);
+        osm_debug("%s: get context id from context list %p -> %d\n", c->name,
+                  ptr, context);
 
         return context;
 };
@@ -336,10 +323,9 @@ static int i2o_iop_quiesce(struct i2o_controller *c)
 
         /* Long timeout needed for quiesce if lots of devices */
         if ((rc = i2o_msg_post_wait(c, m, 240)))
-                printk(KERN_INFO "%s: Unable to quiesce (status=%#x).\n",
-                       c->name, -rc);
+                osm_info("%s: Unable to quiesce (status=%#x).\n", c->name, -rc);
         else
-                pr_debug("%s: Quiesced.\n", c->name);
+                osm_debug("%s: Quiesced.\n", c->name);
 
         i2o_status_get(c);      // Entered READY state
 
@@ -377,10 +363,9 @@ static int i2o_iop_enable(struct i2o_controller *c)
 
         /* How long of a timeout do we need? */
         if ((rc = i2o_msg_post_wait(c, m, 240)))
-                printk(KERN_ERR "%s: Could not enable (status=%#x).\n",
-                       c->name, -rc);
+                osm_err("%s: Could not enable (status=%#x).\n", c->name, -rc);
         else
-                pr_debug("%s: Enabled.\n", c->name);
+                osm_debug("%s: Enabled.\n", c->name);
 
         i2o_status_get(c);      // entered OPERATIONAL state
 
@@ -444,20 +429,78 @@ static int i2o_iop_clear(struct i2o_controller *c)
                &msg->u.head[1]);
 
         if ((rc = i2o_msg_post_wait(c, m, 30)))
-                printk(KERN_INFO "%s: Unable to clear (status=%#x).\n",
-                       c->name, -rc);
+                osm_info("%s: Unable to clear (status=%#x).\n", c->name, -rc);
         else
-                pr_debug("%s: Cleared.\n", c->name);
+                osm_debug("%s: Cleared.\n", c->name);
 
         /* Enable all IOPs */
         i2o_iop_enable_all();
 
-        i2o_status_get(c);
-
         return rc;
 }
 
 /**
+ *      i2o_iop_init_outbound_queue - setup the outbound message queue
+ *      @c: I2O controller
+ *
+ *      Clear and (re)initialize IOP's outbound queue and post the message
+ *      frames to the IOP.
+ *
+ *      Returns 0 on success or a negative errno code on failure.
+ */
+static int i2o_iop_init_outbound_queue(struct i2o_controller *c)
+{
+        volatile u8 *status = c->status.virt;
+        u32 m;
+        struct i2o_message __iomem *msg;
+        ulong timeout;
+        int i;
+
+        osm_debug("%s: Initializing Outbound Queue...\n", c->name);
+
+        memset(c->status.virt, 0, 4);
+
+        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
+        if (m == I2O_QUEUE_EMPTY)
+                return -ETIMEDOUT;
+
+        writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);
+        writel(I2O_CMD_OUTBOUND_INIT << 24 | HOST_TID << 12 | ADAPTER_TID,
+               &msg->u.head[1]);
+        writel(i2o_exec_driver.context, &msg->u.s.icntxt);
+        writel(0x00000000, &msg->u.s.tcntxt);
+        writel(PAGE_SIZE, &msg->body[0]);
+        /* Outbound msg frame size in words and Initcode */
+        writel(I2O_OUTBOUND_MSG_FRAME_SIZE << 16 | 0x80, &msg->body[1]);
+        writel(0xd0000004, &msg->body[2]);
+        writel(i2o_dma_low(c->status.phys), &msg->body[3]);
+        writel(i2o_dma_high(c->status.phys), &msg->body[4]);
+
+        i2o_msg_post(c, m);
+
+        timeout = jiffies + I2O_TIMEOUT_INIT_OUTBOUND_QUEUE * HZ;
+        while (*status <= I2O_CMD_IN_PROGRESS) {
+                if (time_after(jiffies, timeout)) {
+                        osm_warn("%s: Timeout Initializing\n", c->name);
+                        return -ETIMEDOUT;
+                }
+                set_current_state(TASK_UNINTERRUPTIBLE);
+                schedule_timeout(1);
+        }
+
+        m = c->out_queue.phys;
+
+        /* Post frames */
+        for (i = 0; i < I2O_MAX_OUTBOUND_MSG_FRAMES; i++) {
+                i2o_flush_reply(c, m);
+                udelay(1);      /* Promise */
+                m += I2O_OUTBOUND_MSG_FRAME_SIZE * sizeof(u32);
+        }
+
+        return 0;
+}
+
+/**
  *      i2o_iop_reset - reset an I2O controller
  *      @c: controller to reset
  *
@@ -468,20 +511,20 @@ static int i2o_iop_clear(struct i2o_controller *c)
  */
 static int i2o_iop_reset(struct i2o_controller *c)
 {
-        u8 *status = c->status.virt;
+        volatile u8 *status = c->status.virt;
         struct i2o_message __iomem *msg;
         u32 m;
         unsigned long timeout;
         i2o_status_block *sb = c->status_block.virt;
         int rc = 0;
 
-        pr_debug("%s: Resetting controller\n", c->name);
+        osm_debug("%s: Resetting controller\n", c->name);
 
         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
         if (m == I2O_QUEUE_EMPTY)
                 return -ETIMEDOUT;
 
-        memset(status, 0, 8);
+        memset(c->status_block.virt, 0, 8);
 
         /* Quiesce all IOPs first */
         i2o_iop_quiesce_all();
@@ -493,49 +536,43 @@ static int i2o_iop_reset(struct i2o_controller *c)
         writel(0, &msg->u.s.tcntxt);    //FIXME: use reasonable transaction context
         writel(0, &msg->body[0]);
         writel(0, &msg->body[1]);
-        writel(i2o_ptr_low((void *)c->status.phys), &msg->body[2]);
-        writel(i2o_ptr_high((void *)c->status.phys), &msg->body[3]);
+        writel(i2o_dma_low(c->status.phys), &msg->body[2]);
+        writel(i2o_dma_high(c->status.phys), &msg->body[3]);
 
         i2o_msg_post(c, m);
 
         /* Wait for a reply */
         timeout = jiffies + I2O_TIMEOUT_RESET * HZ;
         while (!*status) {
-                if (time_after(jiffies, timeout)) {
-                        printk(KERN_ERR "%s: IOP reset timeout.\n", c->name);
-                        rc = -ETIMEDOUT;
-                        goto exit;
-                }
-
-                /* Promise bug */
-                if (status[1] || status[4]) {
-                        *status = 0;
+                if (time_after(jiffies, timeout))
                         break;
-                }
 
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout(1);
-
-                rmb();
         }
 
-        if (*status == I2O_CMD_IN_PROGRESS) {
+        switch (*status) {
+        case I2O_CMD_REJECTED:
+                osm_warn("%s: IOP reset rejected\n", c->name);
+                rc = -EPERM;
+                break;
+
+        case I2O_CMD_IN_PROGRESS:
                 /*
                  * Once the reset is sent, the IOP goes into the INIT state
-                 * which is indeterminate.  We need to wait until the IOP
-                 * has rebooted before we can let the system talk to
-                 * it. We read the inbound Free_List until a message is
-                 * available. If we can't read one in the given ammount of
-                 * time, we assume the IOP could not reboot properly.
+                 * which is indeterminate. We need to wait until the IOP has
+                 * rebooted before we can let the system talk to it. We read
+                 * the inbound Free_List until a message is available. If we
+                 * can't read one in the given ammount of time, we assume the
+                 * IOP could not reboot properly.
                  */
-                pr_debug("%s: Reset in progress, waiting for reboot...\n",
-                         c->name);
+                osm_debug("%s: Reset in progress, waiting for reboot...\n",
+                          c->name);
 
                 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_RESET);
                 while (m == I2O_QUEUE_EMPTY) {
                         if (time_after(jiffies, timeout)) {
-                                printk(KERN_ERR "%s: IOP reset timeout.\n",
-                                       c->name);
+                                osm_err("%s: IOP reset timeout.\n", c->name);
                                 rc = -ETIMEDOUT;
                                 goto exit;
                         }
@@ -545,19 +582,26 @@ static int i2o_iop_reset(struct i2o_controller *c)
                         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_RESET);
                 }
                 i2o_msg_nop(c, m);
-        }
 
-        /* from here all quiesce commands are safe */
-        c->no_quiesce = 0;
+                /* from here all quiesce commands are safe */
+                c->no_quiesce = 0;
 
-        /* If IopReset was rejected or didn't perform reset, try IopClear */
-        i2o_status_get(c);
-        if (*status == I2O_CMD_REJECTED || sb->iop_state != ADAPTER_STATE_RESET) {
-                printk(KERN_WARNING "%s: Reset rejected, trying to clear\n",
-                       c->name);
-                i2o_iop_clear(c);
-        } else
-                pr_debug("%s: Reset completed.\n", c->name);
+                /* verify if controller is in state RESET */
+                i2o_status_get(c);
+
+                if (!c->promise && (sb->iop_state != ADAPTER_STATE_RESET))
+                        osm_warn("%s: reset completed, but adapter not in RESET"
+                                 " state.\n", c->name);
+                else
+                        osm_debug("%s: reset completed.\n", c->name);
+
+                break;
+
+        default:
+                osm_err("%s: IOP reset timeout.\n", c->name);
+                rc = -ETIMEDOUT;
+                break;
+        }
 
       exit:
         /* Enable all IOPs */
@@ -567,88 +611,6 @@ static int i2o_iop_reset(struct i2o_controller *c)
 };
 
 /**
- *      i2o_iop_init_outbound_queue - setup the outbound message queue
- *      @c: I2O controller
- *
- *      Clear and (re)initialize IOP's outbound queue and post the message
- *      frames to the IOP.
- *
- *      Returns 0 on success or a negative errno code on failure.
- */
-static int i2o_iop_init_outbound_queue(struct i2o_controller *c)
-{
-        u8 *status = c->status.virt;
-        u32 m;
-        struct i2o_message __iomem *msg;
-        ulong timeout;
-        int i;
-
-        pr_debug("%s: Initializing Outbound Queue...\n", c->name);
-
-        memset(status, 0, 4);
-
-        m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
-        if (m == I2O_QUEUE_EMPTY)
-                return -ETIMEDOUT;
-
-        writel(EIGHT_WORD_MSG_SIZE | TRL_OFFSET_6, &msg->u.head[0]);
-        writel(I2O_CMD_OUTBOUND_INIT << 24 | HOST_TID << 12 | ADAPTER_TID,
-               &msg->u.head[1]);
-        writel(i2o_exec_driver.context, &msg->u.s.icntxt);
-        writel(0x0106, &msg->u.s.tcntxt);       /* FIXME: why 0x0106, maybe in
-                                                   Spec? */
-        writel(PAGE_SIZE, &msg->body[0]);
-        writel(MSG_FRAME_SIZE << 16 | 0x80, &msg->body[1]);     /* Outbound msg frame
-                                                                   size in words and Initcode */
-        writel(0xd0000004, &msg->body[2]);
-        writel(i2o_ptr_low((void *)c->status.phys), &msg->body[3]);
-        writel(i2o_ptr_high((void *)c->status.phys), &msg->body[4]);
-
-        i2o_msg_post(c, m);
-
-        timeout = jiffies + I2O_TIMEOUT_INIT_OUTBOUND_QUEUE * HZ;
-        while (*status <= I2O_CMD_IN_PROGRESS) {
-                if (time_after(jiffies, timeout)) {
-                        printk(KERN_WARNING "%s: Timeout Initializing\n",
-                               c->name);
-                        return -ETIMEDOUT;
-                }
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
-
-                rmb();
-        }
-
-        m = c->out_queue.phys;
-
-        /* Post frames */
-        for (i = 0; i < NMBR_MSG_FRAMES; i++) {
-                i2o_flush_reply(c, m);
-                udelay(1);      /* Promise */
-                m += MSG_FRAME_SIZE * 4;
-        }
-
-        return 0;
-}
-
-/**
- *      i2o_iop_send_nop - send a core NOP message
- *      @c: controller
- *
- *      Send a no-operation message with a reply set to cause no
- *      action either. Needed for bringing up promise controllers.
- */
-static int i2o_iop_send_nop(struct i2o_controller *c)
-{
-        struct i2o_message __iomem *msg;
-        u32 m = i2o_msg_get_wait(c, &msg, HZ);
-        if (m == I2O_QUEUE_EMPTY)
-                return -ETIMEDOUT;
-        i2o_msg_nop(c, m);
-        return 0;
-}
-
-/**
  *      i2o_iop_activate - Bring controller up to HOLD
  *      @c: controller
  *
@@ -659,78 +621,62 @@ static int i2o_iop_send_nop(struct i2o_controller *c)
  */
 static int i2o_iop_activate(struct i2o_controller *c)
 {
-        struct pci_dev *i960 = NULL;
         i2o_status_block *sb = c->status_block.virt;
         int rc;
-
-        if (c->promise) {
-                /* Beat up the hardware first of all */
-                i960 =
-                    pci_find_slot(c->pdev->bus->number,
-                                  PCI_DEVFN(PCI_SLOT(c->pdev->devfn), 0));
-                if (i960)
-                        pci_write_config_word(i960, 0x42, 0);
-
-                /* Follow this sequence precisely or the controller
-                   ceases to perform useful functions until reboot */
-                if ((rc = i2o_iop_send_nop(c)))
-                        return rc;
-
-                if ((rc = i2o_iop_reset(c)))
-                        return rc;
-        }
+        int state;
 
         /* In INIT state, Wait Inbound Q to initialize (in i2o_status_get) */
         /* In READY state, Get status */
 
         rc = i2o_status_get(c);
         if (rc) {
-                printk(KERN_INFO "%s: Unable to obtain status, "
-                       "attempting a reset.\n", c->name);
-                if (i2o_iop_reset(c))
+                osm_info("%s: Unable to obtain status, attempting a reset.\n",
+                         c->name);
+                rc = i2o_iop_reset(c);
+                if (rc)
                         return rc;
         }
 
         if (sb->i2o_version > I2OVER15) {
-                printk(KERN_ERR "%s: Not running version 1.5 of the I2O "
-                       "Specification.\n", c->name);
+                osm_err("%s: Not running version 1.5 of the I2O Specification."
+                        "\n", c->name);
                 return -ENODEV;
         }
 
         switch (sb->iop_state) {
         case ADAPTER_STATE_FAULTED:
-                printk(KERN_CRIT "%s: hardware fault\n", c->name);
-                return -ENODEV;
+                osm_err("%s: hardware fault\n", c->name);
+                return -EFAULT;
 
         case ADAPTER_STATE_READY:
         case ADAPTER_STATE_OPERATIONAL:
         case ADAPTER_STATE_HOLD:
         case ADAPTER_STATE_FAILED:
-                pr_debug("%s: already running, trying to reset...\n", c->name);
-                if (i2o_iop_reset(c))
-                        return -ENODEV;
+                osm_debug("%s: already running, trying to reset...\n", c->name);
+                rc = i2o_iop_reset(c);
+                if (rc)
+                        return rc;
         }
 
+        /* preserve state */
+        state = sb->iop_state;
+
         rc = i2o_iop_init_outbound_queue(c);
         if (rc)
                 return rc;
 
-        if (c->promise) {
-                if ((rc = i2o_iop_send_nop(c)))
-                        return rc;
+        /* if adapter was not in RESET state clear now */
+        if (state != ADAPTER_STATE_RESET)
+                i2o_iop_clear(c);
 
-                if ((rc = i2o_status_get(c)))
-                        return rc;
+        i2o_status_get(c);
 
-                if (i960)
-                        pci_write_config_word(i960, 0x42, 0x3FF);
+        if (sb->iop_state != ADAPTER_STATE_HOLD) {
+                osm_err("%s: failed to bring IOP into HOLD state\n", c->name);
+                return -EIO;
         }
 
-        /* In HOLD state */
-
-        rc = i2o_hrt_get(c);
-
-        return rc;
+        return i2o_hrt_get(c);
 };
 
 /**
@@ -756,20 +702,18 @@ static int i2o_iop_systab_set(struct i2o_controller *c)
                 res->flags = IORESOURCE_MEM;
                 res->start = 0;
                 res->end = 0;
-                printk(KERN_INFO "%s: requires private memory resources.\n",
-                       c->name);
+                osm_info("%s: requires private memory resources.\n", c->name);
                 root = pci_find_parent_resource(c->pdev, res);
                 if (root == NULL)
-                        printk(KERN_WARNING "%s: Can't find parent resource!\n",
-                               c->name);
+                        osm_warn("%s: Can't find parent resource!\n", c->name);
                 if (root && allocate_resource(root, res, sb->desired_mem_size, sb->desired_mem_size, sb->desired_mem_size, 1 << 20,     /* Unspecified, so use 1Mb and play safe */
                                               NULL, NULL) >= 0) {
                         c->mem_alloc = 1;
                         sb->current_mem_size = 1 + res->end - res->start;
                         sb->current_mem_base = res->start;
-                        printk(KERN_INFO "%s: allocated %ld bytes of PCI memory"
-                               " at 0x%08lX.\n", c->name,
-                               1 + res->end - res->start, res->start);
+                        osm_info("%s: allocated %ld bytes of PCI memory at "
+                                 "0x%08lX.\n", c->name,
+                                 1 + res->end - res->start, res->start);
                 }
         }
 
@@ -779,20 +723,18 @@ static int i2o_iop_systab_set(struct i2o_controller *c)
                 res->flags = IORESOURCE_IO;
                 res->start = 0;
                 res->end = 0;
-                printk(KERN_INFO "%s: requires private memory resources.\n",
-                       c->name);
+                osm_info("%s: requires private memory resources.\n", c->name);
                 root = pci_find_parent_resource(c->pdev, res);
                 if (root == NULL)
-                        printk(KERN_WARNING "%s: Can't find parent resource!\n",
-                               c->name);
+                        osm_warn("%s: Can't find parent resource!\n", c->name);
                 if (root && allocate_resource(root, res, sb->desired_io_size, sb->desired_io_size, sb->desired_io_size, 1 << 20,        /* Unspecified, so use 1Mb and play safe */
                                               NULL, NULL) >= 0) {
                         c->io_alloc = 1;
                         sb->current_io_size = 1 + res->end - res->start;
                         sb->current_mem_base = res->start;
-                        printk(KERN_INFO "%s: allocated %ld bytes of PCI I/O at"
-                               " 0x%08lX.\n", c->name,
-                               1 + res->end - res->start, res->start);
+                        osm_info("%s: allocated %ld bytes of PCI I/O at 0x%08lX"
+                                 ".\n", c->name, 1 + res->end - res->start,
+                                 res->start);
                 }
         }
 
@@ -836,10 +778,10 @@ static int i2o_iop_systab_set(struct i2o_controller *c)
                          PCI_DMA_TODEVICE);
 
         if (rc < 0)
-                printk(KERN_ERR "%s: Unable to set SysTab (status=%#x).\n",
-                       c->name, -rc);
+                osm_err("%s: Unable to set SysTab (status=%#x).\n", c->name,
+                        -rc);
         else
-                pr_debug("%s: SysTab set.\n", c->name);
+                osm_debug("%s: SysTab set.\n", c->name);
 
         i2o_status_get(c);      // Entered READY state
 
@@ -863,7 +805,7 @@ static int i2o_iop_online(struct i2o_controller *c)
                 return rc;
 
         /* In READY state */
-        pr_debug("%s: Attempting to enable...\n", c->name);
+        osm_debug("%s: Attempting to enable...\n", c->name);
         rc = i2o_iop_enable(c);
         if (rc)
                 return rc;
@@ -882,7 +824,7 @@ void i2o_iop_remove(struct i2o_controller *c)
 {
         struct i2o_device *dev, *tmp;
 
-        pr_debug("%s: deleting controller\n", c->name);
+        osm_debug("%s: deleting controller\n", c->name);
 
         i2o_driver_notify_controller_remove_all(c);
 
@@ -891,8 +833,12 @@ void i2o_iop_remove(struct i2o_controller *c)
         list_for_each_entry_safe(dev, tmp, &c->devices, list)
             i2o_device_remove(dev);
 
+        device_del(&c->device);
+
         /* Ask the IOP to switch to RESET state */
         i2o_iop_reset(c);
+
+        put_device(&c->device);
 }
 
 /**
@@ -927,8 +873,7 @@ static int i2o_systab_build(void)
 
         systab = i2o_systab.virt = kmalloc(i2o_systab.len, GFP_KERNEL);
         if (!systab) {
-                printk(KERN_ERR "i2o: unable to allocate memory for System "
-                       "Table\n");
+                osm_err("unable to allocate memory for System Table\n");
                 return -ENOMEM;
         }
         memset(systab, 0, i2o_systab.len);
@@ -940,8 +885,8 @@ static int i2o_systab_build(void)
                 i2o_status_block *sb;
 
                 if (count >= num_controllers) {
-                        printk(KERN_ERR "i2o: controller added while building "
-                               "system table\n");
+                        osm_err("controller added while building system table"
+                                "\n");
                         break;
                 }
 
@@ -955,9 +900,8 @@ static int i2o_systab_build(void)
                  * it is techninically not part of the I2O subsystem...
                  */
                 if (unlikely(i2o_status_get(c))) {
-                        printk(KERN_ERR "%s: Deleting b/c could not get status"
-                               " while attempting to build system table\n",
-                               c->name);
+                        osm_err("%s: Deleting b/c could not get status while "
+                                "attempting to build system table\n", c->name);
                         i2o_iop_remove(c);
                         continue;       // try the next one
                 }
@@ -971,8 +915,10 @@ static int i2o_systab_build(void)
                 systab->iops[count].frame_size = sb->inbound_frame_size;
                 systab->iops[count].last_changed = change_ind;
                 systab->iops[count].iop_capabilities = sb->iop_capabilities;
-                systab->iops[count].inbound_low = i2o_ptr_low(c->post_port);
-                systab->iops[count].inbound_high = i2o_ptr_high(c->post_port);
+                systab->iops[count].inbound_low =
+                    i2o_dma_low(c->base.phys + I2O_IN_PORT);
+                systab->iops[count].inbound_high =
+                    i2o_dma_high(c->base.phys + I2O_IN_PORT);
 
                 count++;
         }
@@ -1010,11 +956,11 @@ int i2o_status_get(struct i2o_controller *c)
 {
         struct i2o_message __iomem *msg;
         u32 m;
-        u8 *status_block;
+        volatile u8 *status_block;
         unsigned long timeout;
 
         status_block = (u8 *) c->status_block.virt;
-        memset(status_block, 0, sizeof(i2o_status_block));
+        memset(c->status_block.virt, 0, sizeof(i2o_status_block));
 
         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
         if (m == I2O_QUEUE_EMPTY)
@@ -1027,8 +973,8 @@ int i2o_status_get(struct i2o_controller *c)
         writel(0, &msg->u.s.tcntxt);    // FIXME: use resonable transaction context
         writel(0, &msg->body[0]);
         writel(0, &msg->body[1]);
-        writel(i2o_ptr_low((void *)c->status_block.phys), &msg->body[2]);
-        writel(i2o_ptr_high((void *)c->status_block.phys), &msg->body[3]);
+        writel(i2o_dma_low(c->status_block.phys), &msg->body[2]);
+        writel(i2o_dma_high(c->status_block.phys), &msg->body[3]);
         writel(sizeof(i2o_status_block), &msg->body[4]);        /* always 88 bytes */
 
         i2o_msg_post(c, m);
@@ -1037,14 +983,12 @@ int i2o_status_get(struct i2o_controller *c)
         timeout = jiffies + I2O_TIMEOUT_STATUS_GET * HZ;
         while (status_block[87] != 0xFF) {
                 if (time_after(jiffies, timeout)) {
-                        printk(KERN_ERR "%s: Get status timeout.\n", c->name);
+                        osm_err("%s: Get status timeout.\n", c->name);
                         return -ETIMEDOUT;
                 }
 
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout(1);
-
-                rmb();
         }
 
 #ifdef DEBUG
@@ -1088,8 +1032,8 @@ static int i2o_hrt_get(struct i2o_controller *c)
                 rc = i2o_msg_post_wait_mem(c, m, 20, &c->hrt);
 
                 if (rc < 0) {
-                        printk(KERN_ERR "%s: Unable to get HRT (status=%#x)\n",
-                               c->name, -rc);
+                        osm_err("%s: Unable to get HRT (status=%#x)\n", c->name,
+                                -rc);
                         return rc;
                 }
 
@@ -1103,13 +1047,41 @@ static int i2o_hrt_get(struct i2o_controller *c)
                         return i2o_parse_hrt(c);
         }
 
-        printk(KERN_ERR "%s: Unable to get HRT after %d tries, giving up\n",
-               c->name, I2O_HRT_GET_TRIES);
+        osm_err("%s: Unable to get HRT after %d tries, giving up\n", c->name,
+                I2O_HRT_GET_TRIES);
 
         return -EBUSY;
 }
 
 /**
+ *      i2o_iop_free - Free the i2o_controller struct
+ *      @c: I2O controller to free
+ */
+void i2o_iop_free(struct i2o_controller *c)
+{
+        kfree(c);
+};
+
+/**
+ *      i2o_iop_release - release the memory for a I2O controller
+ *      @dev: I2O controller which should be released
+ *
+ *      Release the allocated memory. This function is called if refcount of
+ *      device reaches 0 automatically.
+ */
+static void i2o_iop_release(struct device *dev)
+{
+        struct i2o_controller *c = to_i2o_controller(dev);
+
+        i2o_iop_free(c);
+};
+
+/* I2O controller class */
+static struct class i2o_controller_class = {
+        .name = "i2o_controller",
+};
+
+/**
  *      i2o_iop_alloc - Allocate and initialize a i2o_controller struct
  *
  *      Allocate the necessary memory for a i2o_controller struct and
@@ -1125,8 +1097,8 @@ struct i2o_controller *i2o_iop_alloc(void)
 
         c = kmalloc(sizeof(*c), GFP_KERNEL);
         if (!c) {
-                printk(KERN_ERR "i2o: Insufficient memory to allocate a I2O "
-                       "controller.\n");
+                osm_err("i2o: Insufficient memory to allocate a I2O controller."
+                        "\n");
                 return ERR_PTR(-ENOMEM);
         }
         memset(c, 0, sizeof(*c));
@@ -1137,6 +1109,16 @@ struct i2o_controller *i2o_iop_alloc(void)
         c->unit = unit++;
         sprintf(c->name, "iop%d", c->unit);
 
+        device_initialize(&c->device);
+        class_device_initialize(&c->classdev);
+
+        c->device.release = &i2o_iop_release;
+        c->classdev.class = &i2o_controller_class;
+        c->classdev.dev = &c->device;
+
+        snprintf(c->device.bus_id, BUS_ID_SIZE, "iop%d", c->unit);
+        snprintf(c->classdev.class_id, BUS_ID_SIZE, "iop%d", c->unit);
+
 #if BITS_PER_LONG == 64
         spin_lock_init(&c->context_list_lock);
         atomic_set(&c->context_list_counter, 0);
@@ -1147,15 +1129,6 @@ struct i2o_controller *i2o_iop_alloc(void)
 };
 
 /**
- *      i2o_iop_free - Free the i2o_controller struct
- *      @c: I2O controller to free
- */
-void i2o_iop_free(struct i2o_controller *c)
-{
-        kfree(c);
-};
-
-/**
  *      i2o_iop_add - Initialize the I2O controller and add him to the I2O core
  *      @c: controller
  *
@@ -1168,45 +1141,58 @@ int i2o_iop_add(struct i2o_controller *c)
 {
         int rc;
 
-        printk(KERN_INFO "%s: Activating I2O controller...\n", c->name);
-        printk(KERN_INFO "%s: This may take a few minutes if there are many "
-               "devices\n", c->name);
+        if ((rc = device_add(&c->device))) {
+                osm_err("%s: could not add controller\n", c->name);
+                goto iop_reset;
+        }
 
-        if ((rc = i2o_iop_activate(c))) {
-                printk(KERN_ERR "%s: could not activate controller\n",
-                       c->name);
-                i2o_iop_reset(c);
-                return rc;
+        if ((rc = class_device_add(&c->classdev))) {
+                osm_err("%s: could not add controller class\n", c->name);
+                goto device_del;
         }
 
-        pr_debug("%s: building sys table...\n", c->name);
+        osm_info("%s: Activating I2O controller...\n", c->name);
+        osm_info("%s: This may take a few minutes if there are many devices\n",
+                 c->name);
 
-        if ((rc = i2o_systab_build())) {
-                i2o_iop_reset(c);
-                return rc;
+        if ((rc = i2o_iop_activate(c))) {
+                osm_err("%s: could not activate controller\n", c->name);
+                goto class_del;
         }
 
-        pr_debug("%s: online controller...\n", c->name);
+        osm_debug("%s: building sys table...\n", c->name);
 
-        if ((rc = i2o_iop_online(c))) {
-                i2o_iop_reset(c);
-                return rc;
-        }
+        if ((rc = i2o_systab_build()))
+                goto class_del;
 
-        pr_debug("%s: getting LCT...\n", c->name);
+        osm_debug("%s: online controller...\n", c->name);
 
-        if ((rc = i2o_exec_lct_get(c))) {
-                i2o_iop_reset(c);
-                return rc;
-        }
+        if ((rc = i2o_iop_online(c)))
+                goto class_del;
+
+        osm_debug("%s: getting LCT...\n", c->name);
+
+        if ((rc = i2o_exec_lct_get(c)))
+                goto class_del;
 
         list_add(&c->list, &i2o_controllers);
 
         i2o_driver_notify_controller_add_all(c);
 
-        printk(KERN_INFO "%s: Controller added\n", c->name);
+        osm_info("%s: Controller added\n", c->name);
 
         return 0;
+
+      class_del:
+        class_device_del(&c->classdev);
+
+      device_del:
+        device_del(&c->device);
+
+      iop_reset:
+        i2o_iop_reset(c);
+
+        return rc;
 };
 
 /**
@@ -1264,16 +1250,18 @@ static int __init i2o_iop_init(void)
         if (rc)
                 goto exit;
 
-        rc = i2o_driver_init();
-        if (rc)
+        if ((rc = class_register(&i2o_controller_class))) {
+                osm_err("can't register class i2o_controller\n");
                 goto device_exit;
+        }
 
-        rc = i2o_exec_init();
-        if (rc)
+        if ((rc = i2o_driver_init()))
+                goto class_exit;
+
+        if ((rc = i2o_exec_init()))
                 goto driver_exit;
 
-        rc = i2o_pci_init();
-        if (rc < 0)
+        if ((rc = i2o_pci_init()))
                 goto exec_exit;
 
         return 0;
@@ -1284,6 +1272,9 @@ static int __init i2o_iop_init(void)
       driver_exit:
         i2o_driver_exit();
 
+      class_exit:
+        class_unregister(&i2o_controller_class);
+
       device_exit:
         i2o_device_exit();
 
@@ -1301,6 +1292,7 @@ static void __exit i2o_iop_exit(void)
         i2o_pci_exit();
         i2o_exec_exit();
         i2o_driver_exit();
+        class_unregister(&i2o_controller_class);
         i2o_device_exit();
 };
 
diff --git a/drivers/message/i2o/pci.c b/drivers/message/i2o/pci.c
index e772752f056d..7a60fd7be8ad 100644
--- a/drivers/message/i2o/pci.c
+++ b/drivers/message/i2o/pci.c
@@ -30,53 +30,18 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/i2o.h>
-
-#ifdef CONFIG_MTRR
-#include <asm/mtrr.h>
-#endif                          // CONFIG_MTRR
-
-/* Module internal functions from other sources */
-extern struct i2o_controller *i2o_iop_alloc(void);
-extern void i2o_iop_free(struct i2o_controller *);
-
-extern int i2o_iop_add(struct i2o_controller *);
-extern void i2o_iop_remove(struct i2o_controller *);
-
-extern int i2o_driver_dispatch(struct i2o_controller *, u32,
-                               struct i2o_message *);
+#include "core.h"
 
 /* PCI device id table for all I2O controllers */
 static struct pci_device_id __devinitdata i2o_pci_ids[] = {
         {PCI_DEVICE_CLASS(PCI_CLASS_INTELLIGENT_I2O << 8, 0xffff00)},
         {PCI_DEVICE(PCI_VENDOR_ID_DPT, 0xa511)},
+        {.vendor = PCI_VENDOR_ID_INTEL,.device = 0x1962,
+         .subvendor = PCI_VENDOR_ID_PROMISE,.subdevice = PCI_ANY_ID},
         {0}
 };
 
 /**
- *      i2o_dma_realloc - Realloc DMA memory
- *      @dev: struct device pointer to the PCI device of the I2O controller
- *      @addr: pointer to a i2o_dma struct DMA buffer
- *      @len: new length of memory
- *      @gfp_mask: GFP mask
- *
- *      If there was something allocated in the addr, free it first. If len > 0
- *      than try to allocate it and write the addresses back to the addr
- *      structure. If len == 0 set the virtual address to NULL.
- *
- *      Returns the 0 on success or negative error code on failure.
- */
-int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr, size_t len,
-                    unsigned int gfp_mask)
-{
-        i2o_dma_free(dev, addr);
-
-        if (len)
-                return i2o_dma_alloc(dev, addr, len, gfp_mask);
-
-        return 0;
-};
-
-/**
  *      i2o_pci_free - Frees the DMA memory for the I2O controller
  *      @c: I2O controller to free
  *
@@ -91,19 +56,11 @@ static void i2o_pci_free(struct i2o_controller *c)
 
         i2o_dma_free(dev, &c->out_queue);
         i2o_dma_free(dev, &c->status_block);
-        if (c->lct)
-                kfree(c->lct);
+        kfree(c->lct);
         i2o_dma_free(dev, &c->dlct);
         i2o_dma_free(dev, &c->hrt);
         i2o_dma_free(dev, &c->status);
 
-#ifdef CONFIG_MTRR
-        if (c->mtrr_reg0 >= 0)
-                mtrr_del(c->mtrr_reg0, 0, 0);
-        if (c->mtrr_reg1 >= 0)
-                mtrr_del(c->mtrr_reg1, 0, 0);
-#endif
-
         if (c->raptor && c->in_queue.virt)
                 iounmap(c->in_queue.virt);
 
@@ -178,14 +135,15 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
                        c->name, (unsigned long)c->base.phys,
                        (unsigned long)c->base.len);
 
-        c->base.virt = ioremap(c->base.phys, c->base.len);
+        c->base.virt = ioremap_nocache(c->base.phys, c->base.len);
         if (!c->base.virt) {
                 printk(KERN_ERR "%s: Unable to map controller.\n", c->name);
                 return -ENOMEM;
         }
 
         if (c->raptor) {
-                c->in_queue.virt = ioremap(c->in_queue.phys, c->in_queue.len);
+                c->in_queue.virt =
+                    ioremap_nocache(c->in_queue.phys, c->in_queue.len);
                 if (!c->in_queue.virt) {
                         printk(KERN_ERR "%s: Unable to map controller.\n",
                                c->name);
@@ -195,43 +153,10 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
         } else
                 c->in_queue = c->base;
 
-        c->irq_mask = c->base.virt + 0x34;
-        c->post_port = c->base.virt + 0x40;
-        c->reply_port = c->base.virt + 0x44;
-
-#ifdef CONFIG_MTRR
-        /* Enable Write Combining MTRR for IOP's memory region */
-        c->mtrr_reg0 = mtrr_add(c->in_queue.phys, c->in_queue.len,
-                                MTRR_TYPE_WRCOMB, 1);
-        c->mtrr_reg1 = -1;
-
-        if (c->mtrr_reg0 < 0)
-                printk(KERN_WARNING "%s: could not enable write combining "
-                       "MTRR\n", c->name);
-        else
-                printk(KERN_INFO "%s: using write combining MTRR\n", c->name);
-
-        /*
-         * If it is an INTEL i960 I/O processor then set the first 64K to
-         * Uncacheable since the region contains the messaging unit which
-         * shouldn't be cached.
-         */
-        if ((pdev->vendor == PCI_VENDOR_ID_INTEL ||
-             pdev->vendor == PCI_VENDOR_ID_DPT) && !c->raptor) {
-                printk(KERN_INFO "%s: MTRR workaround for Intel i960 processor"
-                       "\n", c->name);
-                c->mtrr_reg1 = mtrr_add(c->base.phys, 0x10000,
-                                        MTRR_TYPE_UNCACHABLE, 1);
-
-                if (c->mtrr_reg1 < 0) {
-                        printk(KERN_WARNING "%s: Error in setting "
-                               "MTRR_TYPE_UNCACHABLE\n", c->name);
-                        mtrr_del(c->mtrr_reg0, c->in_queue.phys,
-                                 c->in_queue.len);
-                        c->mtrr_reg0 = -1;
-                }
-        }
-#endif
+        c->irq_status = c->base.virt + I2O_IRQ_STATUS;
+        c->irq_mask = c->base.virt + I2O_IRQ_MASK;
+        c->in_port = c->base.virt + I2O_IN_PORT;
+        c->out_port = c->base.virt + I2O_OUT_PORT;
 
         if (i2o_dma_alloc(dev, &c->status, 8, GFP_KERNEL)) {
                 i2o_pci_free(c);
@@ -254,7 +179,10 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
                 return -ENOMEM;
         }
 
-        if (i2o_dma_alloc(dev, &c->out_queue, MSG_POOL_SIZE, GFP_KERNEL)) {
+        if (i2o_dma_alloc
+            (dev, &c->out_queue,
+             I2O_MAX_OUTBOUND_MSG_FRAMES * I2O_OUTBOUND_MSG_FRAME_SIZE *
+             sizeof(u32), GFP_KERNEL)) {
                 i2o_pci_free(c);
                 return -ENOMEM;
         }
@@ -276,51 +204,30 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
 static irqreturn_t i2o_pci_interrupt(int irq, void *dev_id, struct pt_regs *r)
 {
         struct i2o_controller *c = dev_id;
-        struct device *dev = &c->pdev->dev;
-        struct i2o_message *m;
-        u32 mv;
-
-        /*
-         * Old 960 steppings had a bug in the I2O unit that caused
-         * the queue to appear empty when it wasn't.
-         */
-        mv = I2O_REPLY_READ32(c);
-        if (mv == I2O_QUEUE_EMPTY) {
-                mv = I2O_REPLY_READ32(c);
-                if (unlikely(mv == I2O_QUEUE_EMPTY)) {
-                        return IRQ_NONE;
-                } else
-                        pr_debug("%s: 960 bug detected\n", c->name);
-        }
-
-        while (mv != I2O_QUEUE_EMPTY) {
-                /*
-                 * Map the message from the page frame map to kernel virtual.
-                 * Because bus_to_virt is deprecated, we have calculate the
-                 * location by ourself!
-                 */
-                m = i2o_msg_out_to_virt(c, mv);
-
-                /*
-                 *      Ensure this message is seen coherently but cachably by
-                 *      the processor
-                 */
-                dma_sync_single_for_cpu(dev, mv, MSG_FRAME_SIZE * 4,
-                                        PCI_DMA_FROMDEVICE);
+        u32 m;
+        irqreturn_t rc = IRQ_NONE;
+
+        while (readl(c->irq_status) & I2O_IRQ_OUTBOUND_POST) {
+                m = readl(c->out_port);
+                if (m == I2O_QUEUE_EMPTY) {
+                        /*
+                         * Old 960 steppings had a bug in the I2O unit that
+                         * caused the queue to appear empty when it wasn't.
+                         */
+                        m = readl(c->out_port);
+                        if (unlikely(m == I2O_QUEUE_EMPTY))
+                                break;
+                }
 
                 /* dispatch it */
-                if (i2o_driver_dispatch(c, mv, m))
+                if (i2o_driver_dispatch(c, m))
                         /* flush it if result != 0 */
-                        i2o_flush_reply(c, mv);
+                        i2o_flush_reply(c, m);
 
-                /*
-                 * That 960 bug again...
-                 */
-                mv = I2O_REPLY_READ32(c);
-                if (mv == I2O_QUEUE_EMPTY)
-                        mv = I2O_REPLY_READ32(c);
+                rc = IRQ_HANDLED;
         }
-        return IRQ_HANDLED;
+
+        return rc;
 }
 
 /**
@@ -336,7 +243,7 @@ static int i2o_pci_irq_enable(struct i2o_controller *c)
         struct pci_dev *pdev = c->pdev;
         int rc;
 
-        I2O_IRQ_WRITE32(c, 0xffffffff);
+        writel(0xffffffff, c->irq_mask);
 
         if (pdev->irq) {
                 rc = request_irq(pdev->irq, i2o_pci_interrupt, SA_SHIRQ,
@@ -348,7 +255,7 @@ static int i2o_pci_irq_enable(struct i2o_controller *c)
                 }
         }
 
-        I2O_IRQ_WRITE32(c, 0x00000000);
+        writel(0x00000000, c->irq_mask);
 
         printk(KERN_INFO "%s: Installed at IRQ %d\n", c->name, pdev->irq);
 
@@ -363,7 +270,7 @@ static int i2o_pci_irq_enable(struct i2o_controller *c)
  */
 static void i2o_pci_irq_disable(struct i2o_controller *c)
 {
-        I2O_IRQ_WRITE32(c, 0xffffffff);
+        writel(0xffffffff, c->irq_mask);
 
         if (c->pdev->irq > 0)
                 free_irq(c->pdev->irq, c);
@@ -385,28 +292,25 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
 {
         struct i2o_controller *c;
         int rc;
+        struct pci_dev *i960 = NULL;
 
         printk(KERN_INFO "i2o: Checking for PCI I2O controllers...\n");
 
         if ((pdev->class & 0xff) > 1) {
-                printk(KERN_WARNING "i2o: I2O controller found but does not "
-                       "support I2O 1.5 (skipping).\n");
+                printk(KERN_WARNING "i2o: %s does not support I2O 1.5 "
+                       "(skipping).\n", pci_name(pdev));
                 return -ENODEV;
         }
 
         if ((rc = pci_enable_device(pdev))) {
-                printk(KERN_WARNING "i2o: I2O controller found but could not be"
-                       " enabled.\n");
+                printk(KERN_WARNING "i2o: couldn't enable device %s\n",
+                       pci_name(pdev));
                 return rc;
         }
 
-        printk(KERN_INFO "i2o: I2O controller found on bus %d at %d.\n",
-               pdev->bus->number, pdev->devfn);
-
         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
-                printk(KERN_WARNING "i2o: I2O controller on bus %d at %d: No "
-                       "suitable DMA available!\n", pdev->bus->number,
-                       pdev->devfn);
+                printk(KERN_WARNING "i2o: no suitable DMA found for %s\n",
+                       pci_name(pdev));
                 rc = -ENODEV;
                 goto disable;
         }
@@ -415,14 +319,16 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
 
         c = i2o_iop_alloc();
         if (IS_ERR(c)) {
-                printk(KERN_ERR "i2o: memory for I2O controller could not be "
-                       "allocated\n");
+                printk(KERN_ERR "i2o: couldn't allocate memory for %s\n",
+                       pci_name(pdev));
                 rc = PTR_ERR(c);
                 goto disable;
-        }
+        } else
+                printk(KERN_INFO "%s: controller found (%s)\n", c->name,
+                       pci_name(pdev));
 
         c->pdev = pdev;
-        c->device = pdev->dev;
+        c->device.parent = get_device(&pdev->dev);
 
         /* Cards that fall apart if you hit them with large I/O loads... */
         if (pdev->vendor == PCI_VENDOR_ID_NCR && pdev->device == 0x0630) {
@@ -432,16 +338,48 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
         }
 
         if (pdev->subsystem_vendor == PCI_VENDOR_ID_PROMISE) {
+                /*
+                 * Expose the ship behind i960 for initialization, or it will
+                 * failed
+                 */
+                i960 =
+                    pci_find_slot(c->pdev->bus->number,
+                                  PCI_DEVFN(PCI_SLOT(c->pdev->devfn), 0));
+
+                if (i960)
+                        pci_write_config_word(i960, 0x42, 0);
+
                 c->promise = 1;
-                printk(KERN_INFO "%s: Promise workarounds activated.\n",
-                       c->name);
+                c->limit_sectors = 1;
         }
 
+        if (pdev->subsystem_vendor == PCI_VENDOR_ID_DPT)
+                c->adaptec = 1;
+
         /* Cards that go bananas if you quiesce them before you reset them. */
         if (pdev->vendor == PCI_VENDOR_ID_DPT) {
                 c->no_quiesce = 1;
                 if (pdev->device == 0xa511)
                         c->raptor = 1;
+
+                if (pdev->subsystem_device == 0xc05a) {
+                        c->limit_sectors = 1;
+                        printk(KERN_INFO
+                               "%s: limit sectors per request to %d\n", c->name,
+                               I2O_MAX_SECTORS_LIMITED);
+                }
+#ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
+                if (sizeof(dma_addr_t) > 4) {
+                        if (pci_set_dma_mask(pdev, DMA_64BIT_MASK))
+                                printk(KERN_INFO "%s: 64-bit DMA unavailable\n",
+                                       c->name);
+                        else {
+                                c->pae_support = 1;
+                                printk(KERN_INFO "%s: using 64-bit DMA\n",
+                                       c->name);
+                        }
+                }
+#endif
         }
 
         if ((rc = i2o_pci_alloc(c))) {
@@ -459,6 +397,11 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
         if ((rc = i2o_iop_add(c)))
                 goto uninstall;
 
+        get_device(&c->device);
+
+        if (i960)
+                pci_write_config_word(i960, 0x42, 0x03ff);
+
         return 0;
 
       uninstall:
@@ -469,6 +412,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
 
       free_controller:
         i2o_iop_free(c);
+        put_device(c->device.parent);
 
       disable:
         pci_disable_device(pdev);
@@ -492,15 +436,17 @@ static void __devexit i2o_pci_remove(struct pci_dev *pdev)
         i2o_pci_irq_disable(c);
         i2o_pci_free(c);
 
+        pci_disable_device(pdev);
+
         printk(KERN_INFO "%s: Controller removed.\n", c->name);
 
-        i2o_iop_free(c);
-        pci_disable_device(pdev);
+        put_device(c->device.parent);
+        put_device(&c->device);
 };
 
 /* PCI driver for I2O controller */
 static struct pci_driver i2o_pci_driver = {
-        .name = "I2O controller",
+        .name = "PCI_I2O",
         .id_table = i2o_pci_ids,
         .probe = i2o_pci_probe,
         .remove = __devexit_p(i2o_pci_remove),
@@ -523,6 +469,4 @@ void __exit i2o_pci_exit(void)
 {
         pci_unregister_driver(&i2o_pci_driver);
 };
-
-EXPORT_SYMBOL(i2o_dma_realloc);
 MODULE_DEVICE_TABLE(pci, i2o_pci_ids);