Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

244 files changed, 10946 insertions, 10859 deletions

diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 788da9781f80..0d90ff5fd117 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -418,13 +418,12 @@ static void acpi_processor_idle(void)
 
         cx = pr->power.state;
         if (!cx || acpi_idle_suspend) {
-                if (pm_idle_save)
-                        pm_idle_save();
-                else
+                if (pm_idle_save) {
+                        pm_idle_save(); /* enables IRQs */
+                } else {
                         acpi_safe_halt();
-
-                if (irqs_disabled())
                         local_irq_enable();
+                }
 
                 return;
         }
@@ -520,10 +519,12 @@ static void acpi_processor_idle(void)
                  * Use the appropriate idle routine, the one that would
                  * be used without acpi C-states.
                  */
-                if (pm_idle_save)
-                        pm_idle_save();
-                else
+                if (pm_idle_save) {
+                        pm_idle_save(); /* enables IRQs */
+                } else {
                         acpi_safe_halt();
+                        local_irq_enable();
+                }
 
                 /*
                  * TBD: Can't get time duration while in C1, as resumes
@@ -534,8 +535,6 @@ static void acpi_processor_idle(void)
                  *       skew otherwise.
                  */
                 sleep_ticks = 0xFFFFFFFF;
-                if (irqs_disabled())
-                        local_irq_enable();
 
                 break;
 
diff --git a/drivers/char/agp/amd-k7-agp.c b/drivers/char/agp/amd-k7-agp.c
index d28669992147..96bdb9296b07 100644
--- a/drivers/char/agp/amd-k7-agp.c
+++ b/drivers/char/agp/amd-k7-agp.c
@@ -436,8 +436,9 @@ static int __devinit agp_amdk7_probe(struct pci_dev *pdev,
            system controller may experience noise due to strong drive strengths
          */
         if (agp_bridge->dev->device == PCI_DEVICE_ID_AMD_FE_GATE_7006) {
-                u8 cap_ptr=0;
                 struct pci_dev *gfxcard=NULL;
+
+                cap_ptr = 0;
                 while (!cap_ptr) {
                         gfxcard = pci_get_class(PCI_CLASS_DISPLAY_VGA<<8, gfxcard);
                         if (!gfxcard) {
diff --git a/drivers/char/agp/frontend.c b/drivers/char/agp/frontend.c
index 55d7a82bd071..857b26227d87 100644
--- a/drivers/char/agp/frontend.c
+++ b/drivers/char/agp/frontend.c
@@ -967,7 +967,7 @@ int agpioc_chipset_flush_wrap(struct agp_file_private *priv)
         return 0;
 }
 
-static int agp_ioctl(struct inode *inode, struct file *file,
+static long agp_ioctl(struct file *file,
                      unsigned int cmd, unsigned long arg)
 {
         struct agp_file_private *curr_priv = file->private_data;
@@ -1058,7 +1058,7 @@ static const struct file_operations agp_fops =
         .llseek         = no_llseek,
         .read           = agp_read,
         .write          = agp_write,
-        .ioctl          = agp_ioctl,
+        .unlocked_ioctl = agp_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = compat_agp_ioctl,
 #endif
diff --git a/drivers/char/drm/ati_pcigart.c b/drivers/char/drm/ati_pcigart.c
index 141f4dfa0a11..b710426bab3e 100644
--- a/drivers/char/drm/ati_pcigart.c
+++ b/drivers/char/drm/ati_pcigart.c
@@ -167,13 +167,6 @@ int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *ga
                         page_base += ATI_PCIGART_PAGE_SIZE;
                 }
         }
-
-        if (gart_info->gart_table_location == DRM_ATI_GART_MAIN)
-                dma_sync_single_for_device(&dev->pdev->dev,
-                                           bus_address,
-                                           max_pages * sizeof(u32),
-                                           PCI_DMA_TODEVICE);
-
         ret = 1;
 
 #if defined(__i386__) || defined(__x86_64__)
diff --git a/drivers/char/drm/drm.h b/drivers/char/drm/drm.h
index 3a05c6d5ebe1..6874f31ca8ca 100644
--- a/drivers/char/drm/drm.h
+++ b/drivers/char/drm/drm.h
@@ -471,6 +471,7 @@ struct drm_irq_busid {
 enum drm_vblank_seq_type {
         _DRM_VBLANK_ABSOLUTE = 0x0,     /**< Wait for specific vblank sequence number */
         _DRM_VBLANK_RELATIVE = 0x1,     /**< Wait for given number of vblanks */
+        _DRM_VBLANK_FLIP = 0x8000000,   /**< Scheduled buffer swap should flip */
         _DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
         _DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
         _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */
@@ -503,6 +504,21 @@ union drm_wait_vblank {
         struct drm_wait_vblank_reply reply;
 };
 
+enum drm_modeset_ctl_cmd {
+        _DRM_PRE_MODESET = 1,
+        _DRM_POST_MODESET = 2,
+};
+
+/**
+ * DRM_IOCTL_MODESET_CTL ioctl argument type
+ *
+ * \sa drmModesetCtl().
+ */
+struct drm_modeset_ctl {
+        unsigned long arg;
+        enum drm_modeset_ctl_cmd cmd;
+};
+
 /**
  * DRM_IOCTL_AGP_ENABLE ioctl argument type.
  *
@@ -587,6 +603,7 @@ struct drm_set_version {
 #define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, struct drm_client)
 #define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, struct drm_stats)
 #define DRM_IOCTL_SET_VERSION           DRM_IOWR(0x07, struct drm_set_version)
+#define DRM_IOCTL_MODESET_CTL           DRM_IOW(0x08, struct drm_modeset_ctl)
 
 #define DRM_IOCTL_SET_UNIQUE            DRM_IOW( 0x10, struct drm_unique)
 #define DRM_IOCTL_AUTH_MAGIC            DRM_IOW( 0x11, struct drm_auth)
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index 6540948d5176..ecee3547a13f 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -100,10 +100,8 @@ struct drm_device;
 #define DRIVER_HAVE_DMA    0x20
 #define DRIVER_HAVE_IRQ    0x40
 #define DRIVER_IRQ_SHARED  0x80
-#define DRIVER_IRQ_VBL     0x100
 #define DRIVER_DMA_QUEUE   0x200
 #define DRIVER_FB_DMA      0x400
-#define DRIVER_IRQ_VBL2    0x800
 
 /***********************************************************************/
 /** \name Begin the DRM... */
@@ -379,13 +377,12 @@ struct drm_buf_entry {
 struct drm_file {
         int authenticated;
         int master;
-        int minor;
         pid_t pid;
         uid_t uid;
         drm_magic_t magic;
         unsigned long ioctl_count;
         struct list_head lhead;
-        struct drm_head *head;
+        struct drm_minor *minor;
         int remove_auth_on_close;
         unsigned long lock_count;
         struct file *filp;
@@ -580,10 +577,52 @@ struct drm_driver {
         int (*context_dtor) (struct drm_device *dev, int context);
         int (*kernel_context_switch) (struct drm_device *dev, int old,
                                       int new);
-        void (*kernel_context_switch_unlock) (struct drm_device *dev);
-        int (*vblank_wait) (struct drm_device *dev, unsigned int *sequence);
-        int (*vblank_wait2) (struct drm_device *dev, unsigned int *sequence);
-        int (*dri_library_name) (struct drm_device *dev, char *buf);
+        void (*kernel_context_switch_unlock) (struct drm_device * dev);
+        /**
+         * get_vblank_counter - get raw hardware vblank counter
+         * @dev: DRM device
+         * @crtc: counter to fetch
+         *
+         * Driver callback for fetching a raw hardware vblank counter
+         * for @crtc.  If a device doesn't have a hardware counter, the
+         * driver can simply return the value of drm_vblank_count and
+         * make the enable_vblank() and disable_vblank() hooks into no-ops,
+         * leaving interrupts enabled at all times.
+         *
+         * Wraparound handling and loss of events due to modesetting is dealt
+         * with in the DRM core code.
+         *
+         * RETURNS
+         * Raw vblank counter value.
+         */
+        u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
+
+        /**
+         * enable_vblank - enable vblank interrupt events
+         * @dev: DRM device
+         * @crtc: which irq to enable
+         *
+         * Enable vblank interrupts for @crtc.  If the device doesn't have
+         * a hardware vblank counter, this routine should be a no-op, since
+         * interrupts will have to stay on to keep the count accurate.
+         *
+         * RETURNS
+         * Zero on success, appropriate errno if the given @crtc's vblank
+         * interrupt cannot be enabled.
+         */
+        int (*enable_vblank) (struct drm_device *dev, int crtc);
+
+        /**
+         * disable_vblank - disable vblank interrupt events
+         * @dev: DRM device
+         * @crtc: which irq to enable
+         *
+         * Disable vblank interrupts for @crtc.  If the device doesn't have
+         * a hardware vblank counter, this routine should be a no-op, since
+         * interrupts will have to stay on to keep the count accurate.
+         */
+        void (*disable_vblank) (struct drm_device *dev, int crtc);
+        int (*dri_library_name) (struct drm_device *dev, char * buf);
 
         /**
          * Called by \c drm_device_is_agp.  Typically used to determine if a
@@ -602,7 +641,7 @@ struct drm_driver {
 
         irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
         void (*irq_preinstall) (struct drm_device *dev);
-        void (*irq_postinstall) (struct drm_device *dev);
+        int (*irq_postinstall) (struct drm_device *dev);
         void (*irq_uninstall) (struct drm_device *dev);
         void (*reclaim_buffers) (struct drm_device *dev,
                                  struct drm_file * file_priv);
@@ -630,16 +669,19 @@ struct drm_driver {
         struct pci_driver pci_driver;
 };
 
+#define DRM_MINOR_UNASSIGNED 0
+#define DRM_MINOR_LEGACY 1
+
 /**
- * DRM head structure. This structure represent a video head on a card
- * that may contain multiple heads. Embed one per head of these in the
- * private drm_device structure.
+ * DRM minor structure. This structure represents a drm minor number.
  */
-struct drm_head {
-        int minor;                      /**< Minor device number */
+struct drm_minor {
+        int index;                      /**< Minor device number */
+        int type;                       /**< Control or render */
+        dev_t device;                   /**< Device number for mknod */
+        struct device kdev;             /**< Linux device */
         struct drm_device *dev;
         struct proc_dir_entry *dev_root;  /**< proc directory entry */
-        dev_t device;                   /**< Device number for mknod */
 };
 
 /**
@@ -647,7 +689,6 @@ struct drm_head {
  * may contain multiple heads.
  */
 struct drm_device {
-        struct device dev;              /**< Linux device */
         char *unique;                   /**< Unique identifier: e.g., busid */
         int unique_len;                 /**< Length of unique field */
         char *devname;                  /**< For /proc/interrupts */
@@ -729,13 +770,21 @@ struct drm_device {
         /** \name VBLANK IRQ support */
         /*@{ */
 
-        wait_queue_head_t vbl_queue;    /**< VBLANK wait queue */
-        atomic_t vbl_received;
-        atomic_t vbl_received2;         /**< number of secondary VBLANK interrupts */
+        wait_queue_head_t *vbl_queue;   /**< VBLANK wait queue */
+        atomic_t *_vblank_count;        /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
         spinlock_t vbl_lock;
-        struct list_head vbl_sigs;              /**< signal list to send on VBLANK */
-        struct list_head vbl_sigs2;     /**< signals to send on secondary VBLANK */
-        unsigned int vbl_pending;
+        struct list_head *vbl_sigs;             /**< signal list to send on VBLANK */
+        atomic_t vbl_signal_pending;    /* number of signals pending on all crtcs*/
+        atomic_t *vblank_refcount;      /* number of users of vblank interrupts per crtc */
+        u32 *last_vblank;               /* protected by dev->vbl_lock, used */
+                                        /* for wraparound handling */
+        u32 *vblank_offset;             /* used to track how many vblanks */
+        int *vblank_enabled;            /* so we don't call enable more than
+                                           once per disable */
+        u32 *vblank_premodeset;         /*  were lost during modeset */
+        struct timer_list vblank_disable_timer;
+
+        unsigned long max_vblank_count; /**< size of vblank counter register */
         spinlock_t tasklet_lock;        /**< For drm_locked_tasklet */
         void (*locked_tasklet_func)(struct drm_device *dev);
 
@@ -755,6 +804,7 @@ struct drm_device {
 #ifdef __alpha__
         struct pci_controller *hose;
 #endif
+        int num_crtcs;                  /**< Number of CRTCs on this device */
         struct drm_sg_mem *sg;  /**< Scatter gather memory */
         void *dev_private;              /**< device private data */
         struct drm_sigdata sigdata;        /**< For block_all_signals */
@@ -763,7 +813,7 @@ struct drm_device {
         struct drm_driver *driver;
         drm_local_map_t *agp_buffer_map;
         unsigned int agp_buffer_token;
-        struct drm_head primary;                /**< primary screen head */
+        struct drm_minor *primary;              /**< render type primary screen head */
 
         /** \name Drawable information */
         /*@{ */
@@ -989,11 +1039,19 @@ extern void drm_driver_irq_preinstall(struct drm_device *dev);
 extern void drm_driver_irq_postinstall(struct drm_device *dev);
 extern void drm_driver_irq_uninstall(struct drm_device *dev);
 
-extern int drm_wait_vblank(struct drm_device *dev, void *data,
-                           struct drm_file *file_priv);
-extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
-extern void drm_vbl_send_signals(struct drm_device *dev);
+extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
+extern int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *filp);
+extern int drm_vblank_wait(struct drm_device * dev, unsigned int *vbl_seq);
 extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*));
+extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
+extern void drm_update_vblank_count(struct drm_device *dev, int crtc);
+extern void drm_handle_vblank(struct drm_device *dev, int crtc);
+extern int drm_vblank_get(struct drm_device *dev, int crtc);
+extern void drm_vblank_put(struct drm_device *dev, int crtc);
+
+                                /* Modesetting support */
+extern int drm_modeset_ctl(struct drm_device *dev, void *data,
+                           struct drm_file *file_priv);
 
                                 /* AGP/GART support (drm_agpsupport.h) */
 extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
@@ -1030,23 +1088,20 @@ extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
 extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                        struct drm_driver *driver);
 extern int drm_put_dev(struct drm_device *dev);
-extern int drm_put_head(struct drm_head *head);
+extern int drm_put_minor(struct drm_minor **minor);
 extern unsigned int drm_debug;
-extern unsigned int drm_cards_limit;
-extern struct drm_head **drm_heads;
+
 extern struct class *drm_class;
 extern struct proc_dir_entry *drm_proc_root;
 
+extern struct idr drm_minors_idr;
+
 extern drm_local_map_t *drm_getsarea(struct drm_device *dev);
 
                                 /* Proc support (drm_proc.h) */
-extern int drm_proc_init(struct drm_device *dev,
-                         int minor,
-                         struct proc_dir_entry *root,
-                         struct proc_dir_entry **dev_root);
-extern int drm_proc_cleanup(int minor,
-                            struct proc_dir_entry *root,
-                            struct proc_dir_entry *dev_root);
+extern int drm_proc_init(struct drm_minor *minor, int minor_id,
+                         struct proc_dir_entry *root);
+extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root);
 
                                 /* Scatter Gather Support (drm_scatter.h) */
 extern void drm_sg_cleanup(struct drm_sg_mem * entry);
@@ -1071,8 +1126,8 @@ extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
 struct drm_sysfs_class;
 extern struct class *drm_sysfs_create(struct module *owner, char *name);
 extern void drm_sysfs_destroy(void);
-extern int drm_sysfs_device_add(struct drm_device *dev, struct drm_head *head);
-extern void drm_sysfs_device_remove(struct drm_device *dev);
+extern int drm_sysfs_device_add(struct drm_minor *minor);
+extern void drm_sysfs_device_remove(struct drm_minor *minor);
 
 /*
  * Basic memory manager support (drm_mm.c)
diff --git a/drivers/char/drm/drm_agpsupport.c b/drivers/char/drm/drm_agpsupport.c
index 9468c7889ff1..aefa5ac4c0b1 100644
--- a/drivers/char/drm/drm_agpsupport.c
+++ b/drivers/char/drm/drm_agpsupport.c
@@ -122,7 +122,7 @@ EXPORT_SYMBOL(drm_agp_acquire);
 int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
-        return drm_agp_acquire((struct drm_device *) file_priv->head->dev);
+        return drm_agp_acquire((struct drm_device *) file_priv->minor->dev);
 }
 
 /**
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index 0e7af53c87de..fc54140551a7 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -313,35 +313,36 @@ static void drm_cleanup(struct drm_device * dev)
         drm_ht_remove(&dev->map_hash);
         drm_ctxbitmap_cleanup(dev);
 
-        drm_put_head(&dev->primary);
+        drm_put_minor(&dev->primary);
         if (drm_put_dev(dev))
                 DRM_ERROR("Cannot unload module\n");
 }
 
-void drm_exit(struct drm_driver *driver)
+int drm_minors_cleanup(int id, void *ptr, void *data)
 {
-        int i;
-        struct drm_device *dev = NULL;
-        struct drm_head *head;
+        struct drm_minor *minor = ptr;
+        struct drm_device *dev;
+        struct drm_driver *driver = data;
+
+        dev = minor->dev;
+        if (minor->dev->driver != driver)
+                return 0;
+
+        if (minor->type != DRM_MINOR_LEGACY)
+                return 0;
 
+        if (dev)
+                pci_dev_put(dev->pdev);
+        drm_cleanup(dev);
+        return 1;
+}
+
+void drm_exit(struct drm_driver *driver)
+{
         DRM_DEBUG("\n");
 
-        for (i = 0; i < drm_cards_limit; i++) {
-                head = drm_heads[i];
-                if (!head)
-                        continue;
-                if (!head->dev)
-                        continue;
-                if (head->dev->driver != driver)
-                        continue;
-                dev = head->dev;
-                if (dev) {
-                        /* release the pci driver */
-                        if (dev->pdev)
-                                pci_dev_put(dev->pdev);
-                        drm_cleanup(dev);
-                }
-        }
+        idr_for_each(&drm_minors_idr, &drm_minors_cleanup, driver);
+
         DRM_INFO("Module unloaded\n");
 }
 
@@ -357,13 +358,7 @@ static int __init drm_core_init(void)
 {
         int ret = -ENOMEM;
 
-        drm_cards_limit =
-            (drm_cards_limit <
-             DRM_MAX_MINOR + 1 ? drm_cards_limit : DRM_MAX_MINOR + 1);
-        drm_heads =
-            drm_calloc(drm_cards_limit, sizeof(*drm_heads), DRM_MEM_STUB);
-        if (!drm_heads)
-                goto err_p1;
+        idr_init(&drm_minors_idr);
 
         if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops))
                 goto err_p1;
@@ -391,7 +386,8 @@ err_p3:
         drm_sysfs_destroy();
 err_p2:
         unregister_chrdev(DRM_MAJOR, "drm");
-        drm_free(drm_heads, sizeof(*drm_heads) * drm_cards_limit, DRM_MEM_STUB);
+
+        idr_destroy(&drm_minors_idr);
 err_p1:
         return ret;
 }
@@ -403,7 +399,7 @@ static void __exit drm_core_exit(void)
 
         unregister_chrdev(DRM_MAJOR, "drm");
 
-        drm_free(drm_heads, sizeof(*drm_heads) * drm_cards_limit, DRM_MEM_STUB);
+        idr_destroy(&drm_minors_idr);
 }
 
 module_init(drm_core_init);
@@ -452,7 +448,7 @@ int drm_ioctl(struct inode *inode, struct file *filp,
               unsigned int cmd, unsigned long arg)
 {
         struct drm_file *file_priv = filp->private_data;
-        struct drm_device *dev = file_priv->head->dev;
+        struct drm_device *dev = file_priv->minor->dev;
         struct drm_ioctl_desc *ioctl;
         drm_ioctl_t *func;
         unsigned int nr = DRM_IOCTL_NR(cmd);
@@ -465,7 +461,7 @@ int drm_ioctl(struct inode *inode, struct file *filp,
 
         DRM_DEBUG("pid=%d, cmd=0x%02x, nr=0x%02x, dev 0x%lx, auth=%d\n",
                   task_pid_nr(current), cmd, nr,
-                  (long)old_encode_dev(file_priv->head->device),
+                  (long)old_encode_dev(file_priv->minor->device),
                   file_priv->authenticated);
 
         if ((nr >= DRM_CORE_IOCTL_COUNT) &&
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index f09d4b5002b0..68f0da801ed8 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -129,16 +129,15 @@ static int drm_setup(struct drm_device * dev)
 int drm_open(struct inode *inode, struct file *filp)
 {
         struct drm_device *dev = NULL;
-        int minor = iminor(inode);
+        int minor_id = iminor(inode);
+        struct drm_minor *minor;
         int retcode = 0;
 
-        if (!((minor >= 0) && (minor < drm_cards_limit)))
+        minor = idr_find(&drm_minors_idr, minor_id);
+        if (!minor)
                 return -ENODEV;
 
-        if (!drm_heads[minor])
-                return -ENODEV;
-
-        if (!(dev = drm_heads[minor]->dev))
+        if (!(dev = minor->dev))
                 return -ENODEV;
 
         retcode = drm_open_helper(inode, filp, dev);
@@ -168,19 +167,18 @@ EXPORT_SYMBOL(drm_open);
 int drm_stub_open(struct inode *inode, struct file *filp)
 {
         struct drm_device *dev = NULL;
-        int minor = iminor(inode);
+        struct drm_minor *minor;
+        int minor_id = iminor(inode);
         int err = -ENODEV;
         const struct file_operations *old_fops;
 
         DRM_DEBUG("\n");
 
-        if (!((minor >= 0) && (minor < drm_cards_limit)))
-                return -ENODEV;
-
-        if (!drm_heads[minor])
+        minor = idr_find(&drm_minors_idr, minor_id);
+        if (!minor)
                 return -ENODEV;
 
-        if (!(dev = drm_heads[minor]->dev))
+        if (!(dev = minor->dev))
                 return -ENODEV;
 
         old_fops = filp->f_op;
@@ -225,7 +223,7 @@ static int drm_cpu_valid(void)
 static int drm_open_helper(struct inode *inode, struct file *filp,
                            struct drm_device * dev)
 {
-        int minor = iminor(inode);
+        int minor_id = iminor(inode);
         struct drm_file *priv;
         int ret;
 
@@ -234,7 +232,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         if (!drm_cpu_valid())
                 return -EINVAL;
 
-        DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor);
+        DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor_id);
 
         priv = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
         if (!priv)
@@ -245,8 +243,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         priv->filp = filp;
         priv->uid = current->euid;
         priv->pid = task_pid_nr(current);
-        priv->minor = minor;
-        priv->head = drm_heads[minor];
+        priv->minor = idr_find(&drm_minors_idr, minor_id);
         priv->ioctl_count = 0;
         /* for compatibility root is always authenticated */
         priv->authenticated = capable(CAP_SYS_ADMIN);
@@ -297,11 +294,11 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 int drm_fasync(int fd, struct file *filp, int on)
 {
         struct drm_file *priv = filp->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         int retcode;
 
         DRM_DEBUG("fd = %d, device = 0x%lx\n", fd,
-                  (long)old_encode_dev(priv->head->device));
+                  (long)old_encode_dev(priv->minor->device));
         retcode = fasync_helper(fd, filp, on, &dev->buf_async);
         if (retcode < 0)
                 return retcode;
@@ -324,7 +321,7 @@ EXPORT_SYMBOL(drm_fasync);
 int drm_release(struct inode *inode, struct file *filp)
 {
         struct drm_file *file_priv = filp->private_data;
-        struct drm_device *dev = file_priv->head->dev;
+        struct drm_device *dev = file_priv->minor->dev;
         int retcode = 0;
         unsigned long irqflags;
 
@@ -341,14 +338,14 @@ int drm_release(struct inode *inode, struct file *filp)
 
         DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
                   task_pid_nr(current),
-                  (long)old_encode_dev(file_priv->head->device),
+                  (long)old_encode_dev(file_priv->minor->device),
                   dev->open_count);
 
         if (dev->driver->reclaim_buffers_locked && dev->lock.hw_lock) {
                 if (drm_i_have_hw_lock(dev, file_priv)) {
                         dev->driver->reclaim_buffers_locked(dev, file_priv);
                 } else {
-                        unsigned long _end=jiffies + 3*DRM_HZ;
+                        unsigned long endtime = jiffies + 3 * DRM_HZ;
                         int locked = 0;
 
                         drm_idlelock_take(&dev->lock);
@@ -366,7 +363,7 @@ int drm_release(struct inode *inode, struct file *filp)
                                 if (locked)
                                         break;
                                 schedule();
-                        } while (!time_after_eq(jiffies, _end));
+                        } while (!time_after_eq(jiffies, endtime));
 
                         if (!locked) {
                                 DRM_ERROR("reclaim_buffers_locked() deadlock. Please rework this\n"
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index 089c015c01d1..286f9d61e7d5 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -71,6 +71,117 @@ int drm_irq_by_busid(struct drm_device *dev, void *data,
         return 0;
 }
 
+static void vblank_disable_fn(unsigned long arg)
+{
+        struct drm_device *dev = (struct drm_device *)arg;
+        unsigned long irqflags;
+        int i;
+
+        for (i = 0; i < dev->num_crtcs; i++) {
+                spin_lock_irqsave(&dev->vbl_lock, irqflags);
+                if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
+                    dev->vblank_enabled[i]) {
+                        dev->driver->disable_vblank(dev, i);
+                        dev->vblank_enabled[i] = 0;
+                }
+                spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+        }
+}
+
+static void drm_vblank_cleanup(struct drm_device *dev)
+{
+        /* Bail if the driver didn't call drm_vblank_init() */
+        if (dev->num_crtcs == 0)
+                return;
+
+        del_timer(&dev->vblank_disable_timer);
+
+        vblank_disable_fn((unsigned long)dev);
+
+        drm_free(dev->vbl_queue, sizeof(*dev->vbl_queue) * dev->num_crtcs,
+                 DRM_MEM_DRIVER);
+        drm_free(dev->vbl_sigs, sizeof(*dev->vbl_sigs) * dev->num_crtcs,
+                 DRM_MEM_DRIVER);
+        drm_free(dev->_vblank_count, sizeof(*dev->_vblank_count) *
+                 dev->num_crtcs, DRM_MEM_DRIVER);
+        drm_free(dev->vblank_refcount, sizeof(*dev->vblank_refcount) *
+                 dev->num_crtcs, DRM_MEM_DRIVER);
+        drm_free(dev->vblank_enabled, sizeof(*dev->vblank_enabled) *
+                 dev->num_crtcs, DRM_MEM_DRIVER);
+        drm_free(dev->last_vblank, sizeof(*dev->last_vblank) * dev->num_crtcs,
+                 DRM_MEM_DRIVER);
+        drm_free(dev->vblank_premodeset, sizeof(*dev->vblank_premodeset) *
+                 dev->num_crtcs, DRM_MEM_DRIVER);
+        drm_free(dev->vblank_offset, sizeof(*dev->vblank_offset) * dev->num_crtcs,
+                 DRM_MEM_DRIVER);
+
+        dev->num_crtcs = 0;
+}
+
+int drm_vblank_init(struct drm_device *dev, int num_crtcs)
+{
+        int i, ret = -ENOMEM;
+
+        setup_timer(&dev->vblank_disable_timer, vblank_disable_fn,
+                    (unsigned long)dev);
+        spin_lock_init(&dev->vbl_lock);
+        atomic_set(&dev->vbl_signal_pending, 0);
+        dev->num_crtcs = num_crtcs;
+
+        dev->vbl_queue = drm_alloc(sizeof(wait_queue_head_t) * num_crtcs,
+                                   DRM_MEM_DRIVER);
+        if (!dev->vbl_queue)
+                goto err;
+
+        dev->vbl_sigs = drm_alloc(sizeof(struct list_head) * num_crtcs,
+                                  DRM_MEM_DRIVER);
+        if (!dev->vbl_sigs)
+                goto err;
+
+        dev->_vblank_count = drm_alloc(sizeof(atomic_t) * num_crtcs,
+                                      DRM_MEM_DRIVER);
+        if (!dev->_vblank_count)
+                goto err;
+
+        dev->vblank_refcount = drm_alloc(sizeof(atomic_t) * num_crtcs,
+                                         DRM_MEM_DRIVER);
+        if (!dev->vblank_refcount)
+                goto err;
+
+        dev->vblank_enabled = drm_calloc(num_crtcs, sizeof(int),
+                                         DRM_MEM_DRIVER);
+        if (!dev->vblank_enabled)
+                goto err;
+
+        dev->last_vblank = drm_calloc(num_crtcs, sizeof(u32), DRM_MEM_DRIVER);
+        if (!dev->last_vblank)
+                goto err;
+
+        dev->vblank_premodeset = drm_calloc(num_crtcs, sizeof(u32),
+                                            DRM_MEM_DRIVER);
+        if (!dev->vblank_premodeset)
+                goto err;
+
+        dev->vblank_offset = drm_calloc(num_crtcs, sizeof(u32), DRM_MEM_DRIVER);
+        if (!dev->vblank_offset)
+                goto err;
+
+        /* Zero per-crtc vblank stuff */
+        for (i = 0; i < num_crtcs; i++) {
+                init_waitqueue_head(&dev->vbl_queue[i]);
+                INIT_LIST_HEAD(&dev->vbl_sigs[i]);
+                atomic_set(&dev->_vblank_count[i], 0);
+                atomic_set(&dev->vblank_refcount[i], 0);
+        }
+
+        return 0;
+
+err:
+        drm_vblank_cleanup(dev);
+        return ret;
+}
+EXPORT_SYMBOL(drm_vblank_init);
+
 /**
  * Install IRQ handler.
  *
@@ -109,17 +220,6 @@ static int drm_irq_install(struct drm_device * dev)
 
         DRM_DEBUG("irq=%d\n", dev->irq);
 
-        if (drm_core_check_feature(dev, DRIVER_IRQ_VBL)) {
-                init_waitqueue_head(&dev->vbl_queue);
-
-                spin_lock_init(&dev->vbl_lock);
-
-                INIT_LIST_HEAD(&dev->vbl_sigs);
-                INIT_LIST_HEAD(&dev->vbl_sigs2);
-
-                dev->vbl_pending = 0;
-        }
-
         /* Before installing handler */
         dev->driver->irq_preinstall(dev);
 
@@ -137,9 +237,14 @@ static int drm_irq_install(struct drm_device * dev)
         }
 
         /* After installing handler */
-        dev->driver->irq_postinstall(dev);
+        ret = dev->driver->irq_postinstall(dev);
+        if (ret < 0) {
+                mutex_lock(&dev->struct_mutex);
+                dev->irq_enabled = 0;
+                mutex_unlock(&dev->struct_mutex);
+        }
 
-        return 0;
+        return ret;
 }
 
 /**
@@ -170,6 +275,8 @@ int drm_irq_uninstall(struct drm_device * dev)
 
         free_irq(dev->irq, dev);
 
+        drm_vblank_cleanup(dev);
+
         dev->locked_tasklet_func = NULL;
 
         return 0;
@@ -214,6 +321,148 @@ int drm_control(struct drm_device *dev, void *data,
 }
 
 /**
+ * drm_vblank_count - retrieve "cooked" vblank counter value
+ * @dev: DRM device
+ * @crtc: which counter to retrieve
+ *
+ * Fetches the "cooked" vblank count value that represents the number of
+ * vblank events since the system was booted, including lost events due to
+ * modesetting activity.
+ */
+u32 drm_vblank_count(struct drm_device *dev, int crtc)
+{
+        return atomic_read(&dev->_vblank_count[crtc]) +
+                dev->vblank_offset[crtc];
+}
+EXPORT_SYMBOL(drm_vblank_count);
+
+/**
+ * drm_update_vblank_count - update the master vblank counter
+ * @dev: DRM device
+ * @crtc: counter to update
+ *
+ * Call back into the driver to update the appropriate vblank counter
+ * (specified by @crtc).  Deal with wraparound, if it occurred, and
+ * update the last read value so we can deal with wraparound on the next
+ * call if necessary.
+ */
+void drm_update_vblank_count(struct drm_device *dev, int crtc)
+{
+        unsigned long irqflags;
+        u32 cur_vblank, diff;
+
+        /*
+         * Interrupts were disabled prior to this call, so deal with counter
+         * wrap if needed.
+         * NOTE!  It's possible we lost a full dev->max_vblank_count events
+         * here if the register is small or we had vblank interrupts off for
+         * a long time.
+         */
+        cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
+        spin_lock_irqsave(&dev->vbl_lock, irqflags);
+        if (cur_vblank < dev->last_vblank[crtc]) {
+                diff = dev->max_vblank_count -
+                        dev->last_vblank[crtc];
+                diff += cur_vblank;
+        } else {
+                diff = cur_vblank - dev->last_vblank[crtc];
+        }
+        dev->last_vblank[crtc] = cur_vblank;
+        spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+
+        atomic_add(diff, &dev->_vblank_count[crtc]);
+}
+EXPORT_SYMBOL(drm_update_vblank_count);
+
+/**
+ * drm_vblank_get - get a reference count on vblank events
+ * @dev: DRM device
+ * @crtc: which CRTC to own
+ *
+ * Acquire a reference count on vblank events to avoid having them disabled
+ * while in use.  Note callers will probably want to update the master counter
+ * using drm_update_vblank_count() above before calling this routine so that
+ * wakeups occur on the right vblank event.
+ *
+ * RETURNS
+ * Zero on success, nonzero on failure.
+ */
+int drm_vblank_get(struct drm_device *dev, int crtc)
+{
+        unsigned long irqflags;
+        int ret = 0;
+
+        spin_lock_irqsave(&dev->vbl_lock, irqflags);
+        /* Going from 0->1 means we have to enable interrupts again */
+        if (atomic_add_return(1, &dev->vblank_refcount[crtc]) == 1 &&
+            !dev->vblank_enabled[crtc]) {
+                ret = dev->driver->enable_vblank(dev, crtc);
+                if (ret)
+                        atomic_dec(&dev->vblank_refcount[crtc]);
+                else
+                        dev->vblank_enabled[crtc] = 1;
+        }
+        spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+
+        return ret;
+}
+EXPORT_SYMBOL(drm_vblank_get);
+
+/**
+ * drm_vblank_put - give up ownership of vblank events
+ * @dev: DRM device
+ * @crtc: which counter to give up
+ *
+ * Release ownership of a given vblank counter, turning off interrupts
+ * if possible.
+ */
+void drm_vblank_put(struct drm_device *dev, int crtc)
+{
+        /* Last user schedules interrupt disable */
+        if (atomic_dec_and_test(&dev->vblank_refcount[crtc]))
+            mod_timer(&dev->vblank_disable_timer, jiffies + 5*DRM_HZ);
+}
+EXPORT_SYMBOL(drm_vblank_put);
+
+/**
+ * drm_modeset_ctl - handle vblank event counter changes across mode switch
+ * @DRM_IOCTL_ARGS: standard ioctl arguments
+ *
+ * Applications should call the %_DRM_PRE_MODESET and %_DRM_POST_MODESET
+ * ioctls around modesetting so that any lost vblank events are accounted for.
+ */
+int drm_modeset_ctl(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
+{
+        struct drm_modeset_ctl *modeset = data;
+        int crtc, ret = 0;
+        u32 new;
+
+        crtc = modeset->arg;
+        if (crtc >= dev->num_crtcs) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        switch (modeset->cmd) {
+        case _DRM_PRE_MODESET:
+                dev->vblank_premodeset[crtc] =
+                        dev->driver->get_vblank_counter(dev, crtc);
+                break;
+        case _DRM_POST_MODESET:
+                new = dev->driver->get_vblank_counter(dev, crtc);
+                dev->vblank_offset[crtc] = dev->vblank_premodeset[crtc] - new;
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+out:
+        return ret;
+}
+
+/**
  * Wait for VBLANK.
  *
  * \param inode device inode.
@@ -232,12 +481,13 @@ int drm_control(struct drm_device *dev, void *data,
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int drm_wait_vblank(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
 {
         union drm_wait_vblank *vblwait = data;
         struct timeval now;
         int ret = 0;
-        unsigned int flags, seq;
+        unsigned int flags, seq, crtc;
 
         if ((!dev->irq) || (!dev->irq_enabled))
                 return -EINVAL;
@@ -251,13 +501,13 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
         }
 
         flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
+        crtc = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
 
-        if (!drm_core_check_feature(dev, (flags & _DRM_VBLANK_SECONDARY) ?
-                                    DRIVER_IRQ_VBL2 : DRIVER_IRQ_VBL))
+        if (crtc >= dev->num_crtcs)
                 return -EINVAL;
 
-        seq = atomic_read((flags & _DRM_VBLANK_SECONDARY) ? &dev->vbl_received2
-                          : &dev->vbl_received);
+        drm_update_vblank_count(dev, crtc);
+        seq = drm_vblank_count(dev, crtc);
 
         switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
         case _DRM_VBLANK_RELATIVE:
@@ -276,8 +526,7 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
 
         if (flags & _DRM_VBLANK_SIGNAL) {
                 unsigned long irqflags;
-                struct list_head *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
-                                      ? &dev->vbl_sigs2 : &dev->vbl_sigs;
+                struct list_head *vbl_sigs = &dev->vbl_sigs[crtc];
                 struct drm_vbl_sig *vbl_sig;
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
@@ -298,22 +547,26 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
                         }
                 }
 
-                if (dev->vbl_pending >= 100) {
+                if (atomic_read(&dev->vbl_signal_pending) >= 100) {
                         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
                         return -EBUSY;
                 }
 
-                dev->vbl_pending++;
-
                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 
-                if (!
-                    (vbl_sig =
-                     drm_alloc(sizeof(struct drm_vbl_sig), DRM_MEM_DRIVER))) {
+                vbl_sig = drm_calloc(1, sizeof(struct drm_vbl_sig),
+                                     DRM_MEM_DRIVER);
+                if (!vbl_sig)
                         return -ENOMEM;
+
+                ret = drm_vblank_get(dev, crtc);
+                if (ret) {
+                        drm_free(vbl_sig, sizeof(struct drm_vbl_sig),
+                                 DRM_MEM_DRIVER);
+                        return ret;
                 }
 
-                memset((void *)vbl_sig, 0, sizeof(*vbl_sig));
+                atomic_inc(&dev->vbl_signal_pending);
 
                 vbl_sig->sequence = vblwait->request.sequence;
                 vbl_sig->info.si_signo = vblwait->request.signal;
@@ -327,17 +580,20 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
 
                 vblwait->reply.sequence = seq;
         } else {
-                if (flags & _DRM_VBLANK_SECONDARY) {
-                        if (dev->driver->vblank_wait2)
-                                ret = dev->driver->vblank_wait2(dev, &vblwait->request.sequence);
-                } else if (dev->driver->vblank_wait)
-                        ret =
-                            dev->driver->vblank_wait(dev,
-                                                     &vblwait->request.sequence);
-
+                unsigned long cur_vblank;
+
+                ret = drm_vblank_get(dev, crtc);
+                if (ret)
+                        return ret;
+                DRM_WAIT_ON(ret, dev->vbl_queue[crtc], 3 * DRM_HZ,
+                            (((cur_vblank = drm_vblank_count(dev, crtc))
+                              - vblwait->request.sequence) <= (1 << 23)));
+                drm_vblank_put(dev, crtc);
                 do_gettimeofday(&now);
+
                 vblwait->reply.tval_sec = now.tv_sec;
                 vblwait->reply.tval_usec = now.tv_usec;
+                vblwait->reply.sequence = cur_vblank;
         }
 
       done:
@@ -348,44 +604,57 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
  * Send the VBLANK signals.
  *
  * \param dev DRM device.
+ * \param crtc CRTC where the vblank event occurred
  *
  * Sends a signal for each task in drm_device::vbl_sigs and empties the list.
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-void drm_vbl_send_signals(struct drm_device * dev)
+static void drm_vbl_send_signals(struct drm_device * dev, int crtc)
 {
+        struct drm_vbl_sig *vbl_sig, *tmp;
+        struct list_head *vbl_sigs;
+        unsigned int vbl_seq;
         unsigned long flags;
-        int i;
 
         spin_lock_irqsave(&dev->vbl_lock, flags);
 
-        for (i = 0; i < 2; i++) {
-                struct drm_vbl_sig *vbl_sig, *tmp;
-                struct list_head *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
-                unsigned int vbl_seq = atomic_read(i ? &dev->vbl_received2 :
-                                                   &dev->vbl_received);
+        vbl_sigs = &dev->vbl_sigs[crtc];
+        vbl_seq = drm_vblank_count(dev, crtc);
 
-                list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
-                        if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
-                                vbl_sig->info.si_code = vbl_seq;
-                                send_sig_info(vbl_sig->info.si_signo,
-                                              &vbl_sig->info, vbl_sig->task);
+        list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
+            if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
+                vbl_sig->info.si_code = vbl_seq;
+                send_sig_info(vbl_sig->info.si_signo,
+                              &vbl_sig->info, vbl_sig->task);
 
-                                list_del(&vbl_sig->head);
+                list_del(&vbl_sig->head);
 
-                                drm_free(vbl_sig, sizeof(*vbl_sig),
-                                         DRM_MEM_DRIVER);
-
-                                dev->vbl_pending--;
-                        }
-                }
+                drm_free(vbl_sig, sizeof(*vbl_sig),
+                         DRM_MEM_DRIVER);
+                atomic_dec(&dev->vbl_signal_pending);
+                drm_vblank_put(dev, crtc);
+            }
         }
 
         spin_unlock_irqrestore(&dev->vbl_lock, flags);
 }
 
-EXPORT_SYMBOL(drm_vbl_send_signals);
+/**
+ * drm_handle_vblank - handle a vblank event
+ * @dev: DRM device
+ * @crtc: where this event occurred
+ *
+ * Drivers should call this routine in their vblank interrupt handlers to
+ * update the vblank counter and send any signals that may be pending.
+ */
+void drm_handle_vblank(struct drm_device *dev, int crtc)
+{
+        drm_update_vblank_count(dev, crtc);
+        DRM_WAKEUP(&dev->vbl_queue[crtc]);
+        drm_vbl_send_signals(dev, crtc);
+}
+EXPORT_SYMBOL(drm_handle_vblank);
 
 /**
  * Tasklet wrapper function.
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index d9b560fe9bbe..93b1e0475c93 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -87,34 +87,35 @@ static struct drm_proc_list {
  * "/proc/dri/%minor%/", and each entry in proc_list as
  * "/proc/dri/%minor%/%name%".
  */
-int drm_proc_init(struct drm_device * dev, int minor,
-                  struct proc_dir_entry *root, struct proc_dir_entry **dev_root)
+int drm_proc_init(struct drm_minor *minor, int minor_id,
+                  struct proc_dir_entry *root)
 {
         struct proc_dir_entry *ent;
         int i, j;
         char name[64];
 
-        sprintf(name, "%d", minor);
-        *dev_root = proc_mkdir(name, root);
-        if (!*dev_root) {
+        sprintf(name, "%d", minor_id);
+        minor->dev_root = proc_mkdir(name, root);
+        if (!minor->dev_root) {
                 DRM_ERROR("Cannot create /proc/dri/%s\n", name);
                 return -1;
         }
 
         for (i = 0; i < DRM_PROC_ENTRIES; i++) {
                 ent = create_proc_entry(drm_proc_list[i].name,
-                                        S_IFREG | S_IRUGO, *dev_root);
+                                        S_IFREG | S_IRUGO, minor->dev_root);
                 if (!ent) {
                         DRM_ERROR("Cannot create /proc/dri/%s/%s\n",
                                   name, drm_proc_list[i].name);
                         for (j = 0; j < i; j++)
                                 remove_proc_entry(drm_proc_list[i].name,
-                                                  *dev_root);
+                                                  minor->dev_root);
                         remove_proc_entry(name, root);
+                        minor->dev_root = NULL;
                         return -1;
                 }
                 ent->read_proc = drm_proc_list[i].f;
-                ent->data = dev;
+                ent->data = minor;
         }
 
         return 0;
@@ -130,18 +131,17 @@ int drm_proc_init(struct drm_device * dev, int minor,
  *
  * Remove all proc entries created by proc_init().
  */
-int drm_proc_cleanup(int minor, struct proc_dir_entry *root,
-                     struct proc_dir_entry *dev_root)
+int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root)
 {
         int i;
         char name[64];
 
-        if (!root || !dev_root)
+        if (!root || !minor->dev_root)
                 return 0;
 
         for (i = 0; i < DRM_PROC_ENTRIES; i++)
-                remove_proc_entry(drm_proc_list[i].name, dev_root);
-        sprintf(name, "%d", minor);
+                remove_proc_entry(drm_proc_list[i].name, minor->dev_root);
+        sprintf(name, "%d", minor->index);
         remove_proc_entry(name, root);
 
         return 0;
@@ -163,7 +163,8 @@ int drm_proc_cleanup(int minor, struct proc_dir_entry *root,
 static int drm_name_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
 
         if (offset > DRM_PROC_LIMIT) {
@@ -205,7 +206,8 @@ static int drm_name_info(char *buf, char **start, off_t offset, int request,
 static int drm__vm_info(char *buf, char **start, off_t offset, int request,
                         int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
         struct drm_map *map;
         struct drm_map_list *r_list;
@@ -261,7 +263,8 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
 static int drm_vm_info(char *buf, char **start, off_t offset, int request,
                        int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -284,7 +287,8 @@ static int drm_vm_info(char *buf, char **start, off_t offset, int request,
 static int drm__queues_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
         int i;
         struct drm_queue *q;
@@ -334,7 +338,8 @@ static int drm__queues_info(char *buf, char **start, off_t offset,
 static int drm_queues_info(char *buf, char **start, off_t offset, int request,
                            int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -357,7 +362,8 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request,
 static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
                           int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
         struct drm_device_dma *dma = dev->dma;
         int i;
@@ -406,7 +412,8 @@ static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
 static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -429,7 +436,8 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
 static int drm__clients_info(char *buf, char **start, off_t offset,
                              int request, int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
         struct drm_file *priv;
 
@@ -445,7 +453,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
         list_for_each_entry(priv, &dev->filelist, lhead) {
                 DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
                                priv->authenticated ? 'y' : 'n',
-                               priv->minor,
+                               priv->minor->index,
                                priv->pid,
                                priv->uid, priv->magic, priv->ioctl_count);
         }
@@ -462,7 +470,8 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
 static int drm_clients_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -476,7 +485,8 @@ static int drm_clients_info(char *buf, char **start, off_t offset,
 static int drm__vma_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int len = 0;
         struct drm_vma_entry *pt;
         struct vm_area_struct *vma;
@@ -535,7 +545,8 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
 static int drm_vma_info(char *buf, char **start, off_t offset, int request,
                         int *eof, void *data)
 {
-        struct drm_device *dev = (struct drm_device *) data;
+        struct drm_minor *minor = (struct drm_minor *) data;
+        struct drm_device *dev = minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index d93a217f856a..c2f584f3b46c 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -36,23 +36,49 @@
 #include "drmP.h"
 #include "drm_core.h"
 
-unsigned int drm_cards_limit = 16;      /* Enough for one machine */
 unsigned int drm_debug = 0;     /* 1 to enable debug output */
 EXPORT_SYMBOL(drm_debug);
 
 MODULE_AUTHOR(CORE_AUTHOR);
 MODULE_DESCRIPTION(CORE_DESC);
 MODULE_LICENSE("GPL and additional rights");
-MODULE_PARM_DESC(cards_limit, "Maximum number of graphics cards");
 MODULE_PARM_DESC(debug, "Enable debug output");
 
-module_param_named(cards_limit, drm_cards_limit, int, 0444);
 module_param_named(debug, drm_debug, int, 0600);
 
-struct drm_head **drm_heads;
+struct idr drm_minors_idr;
+
 struct class *drm_class;
 struct proc_dir_entry *drm_proc_root;
 
+static int drm_minor_get_id(struct drm_device *dev, int type)
+{
+        int new_id;
+        int ret;
+        int base = 0, limit = 63;
+
+again:
+        if (idr_pre_get(&drm_minors_idr, GFP_KERNEL) == 0) {
+                DRM_ERROR("Out of memory expanding drawable idr\n");
+                return -ENOMEM;
+        }
+        mutex_lock(&dev->struct_mutex);
+        ret = idr_get_new_above(&drm_minors_idr, NULL,
+                                base, &new_id);
+        mutex_unlock(&dev->struct_mutex);
+        if (ret == -EAGAIN) {
+                goto again;
+        } else if (ret) {
+                return ret;
+        }
+
+        if (new_id >= limit) {
+                idr_remove(&drm_minors_idr, new_id);
+                return -EINVAL;
+        }
+        return new_id;
+}
+
 static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
                            const struct pci_device_id *ent,
                            struct drm_driver *driver)
@@ -145,48 +171,60 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
  * create the proc init entry via proc_init(). This routines assigns
  * minor numbers to secondary heads of multi-headed cards
  */
-static int drm_get_head(struct drm_device * dev, struct drm_head * head)
+static int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
 {
-        struct drm_head **heads = drm_heads;
+        struct drm_minor *new_minor;
         int ret;
-        int minor;
+        int minor_id;
 
         DRM_DEBUG("\n");
 
-        for (minor = 0; minor < drm_cards_limit; minor++, heads++) {
-                if (!*heads) {
-
-                        *head = (struct drm_head) {
-                        .dev = dev,.device =
-                                    MKDEV(DRM_MAJOR, minor),.minor = minor,};
-
-                        if ((ret =
-                             drm_proc_init(dev, minor, drm_proc_root,
-                                           &head->dev_root))) {
-                                printk(KERN_ERR
-                                       "DRM: Failed to initialize /proc/dri.\n");
-                                goto err_g1;
-                        }
-
-                        ret = drm_sysfs_device_add(dev, head);
-                        if (ret) {
-                                printk(KERN_ERR
-                                       "DRM: Error sysfs_device_add.\n");
-                                goto err_g2;
-                        }
-                        *heads = head;
-
-                        DRM_DEBUG("new minor assigned %d\n", minor);
-                        return 0;
+        minor_id = drm_minor_get_id(dev, type);
+        if (minor_id < 0)
+                return minor_id;
+
+        new_minor = kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
+        if (!new_minor) {
+                ret = -ENOMEM;
+                goto err_idr;
+        }
+
+        new_minor->type = type;
+        new_minor->device = MKDEV(DRM_MAJOR, minor_id);
+        new_minor->dev = dev;
+        new_minor->index = minor_id;
+
+        idr_replace(&drm_minors_idr, new_minor, minor_id);
+
+        if (type == DRM_MINOR_LEGACY) {
+                ret = drm_proc_init(new_minor, minor_id, drm_proc_root);
+                if (ret) {
+                        DRM_ERROR("DRM: Failed to initialize /proc/dri.\n");
+                        goto err_mem;
                 }
+        } else
+                new_minor->dev_root = NULL;
+
+        ret = drm_sysfs_device_add(new_minor);
+        if (ret) {
+                printk(KERN_ERR
+                       "DRM: Error sysfs_device_add.\n");
+                goto err_g2;
         }
-        DRM_ERROR("out of minors\n");
-        return -ENOMEM;
-      err_g2:
-        drm_proc_cleanup(minor, drm_proc_root, head->dev_root);
-      err_g1:
-        *head = (struct drm_head) {
-        .dev = NULL};
+        *minor = new_minor;
+
+        DRM_DEBUG("new minor assigned %d\n", minor_id);
+        return 0;
+
+
+err_g2:
+        if (new_minor->type == DRM_MINOR_LEGACY)
+                drm_proc_cleanup(new_minor, drm_proc_root);
+err_mem:
+        kfree(new_minor);
+err_idr:
+        idr_remove(&drm_minors_idr, minor_id);
+        *minor = NULL;
         return ret;
 }
 
@@ -222,12 +260,12 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                 printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
                 goto err_g2;
         }
-        if ((ret = drm_get_head(dev, &dev->primary)))
+        if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
                 goto err_g2;
 
         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
                  driver->name, driver->major, driver->minor, driver->patchlevel,
-                 driver->date, dev->primary.minor);
+                 driver->date, dev->primary->index);
 
         return 0;
 
@@ -276,18 +314,18 @@ int drm_put_dev(struct drm_device * dev)
  * last minor released.
  *
  */
-int drm_put_head(struct drm_head * head)
+int drm_put_minor(struct drm_minor **minor_p)
 {
-        int minor = head->minor;
-
-        DRM_DEBUG("release secondary minor %d\n", minor);
-
-        drm_proc_cleanup(minor, drm_proc_root, head->dev_root);
-        drm_sysfs_device_remove(head->dev);
+        struct drm_minor *minor = *minor_p;
+        DRM_DEBUG("release secondary minor %d\n", minor->index);
 
-        *head = (struct drm_head) {.dev = NULL};
+        if (minor->type == DRM_MINOR_LEGACY)
+                drm_proc_cleanup(minor, drm_proc_root);
+        drm_sysfs_device_remove(minor);
 
-        drm_heads[minor] = NULL;
+        idr_remove(&drm_minors_idr, minor->index);
 
+        kfree(minor);
+        *minor_p = NULL;
         return 0;
 }
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 05ed5043254f..7a1d9a782ddb 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -19,7 +19,7 @@
 #include "drm_core.h"
 #include "drmP.h"
 
-#define to_drm_device(d) container_of(d, struct drm_device, dev)
+#define to_drm_minor(d) container_of(d, struct drm_minor, kdev)
 
 /**
  * drm_sysfs_suspend - DRM class suspend hook
@@ -31,7 +31,8 @@
  */
 static int drm_sysfs_suspend(struct device *dev, pm_message_t state)
 {
-        struct drm_device *drm_dev = to_drm_device(dev);
+        struct drm_minor *drm_minor = to_drm_minor(dev);
+        struct drm_device *drm_dev = drm_minor->dev;
 
         printk(KERN_ERR "%s\n", __FUNCTION__);
 
@@ -50,7 +51,8 @@ static int drm_sysfs_suspend(struct device *dev, pm_message_t state)
  */
 static int drm_sysfs_resume(struct device *dev)
 {
-        struct drm_device *drm_dev = to_drm_device(dev);
+        struct drm_minor *drm_minor = to_drm_minor(dev);
+        struct drm_device *drm_dev = drm_minor->dev;
 
         if (drm_dev->driver->resume)
                 return drm_dev->driver->resume(drm_dev);
@@ -120,10 +122,11 @@ void drm_sysfs_destroy(void)
 static ssize_t show_dri(struct device *device, struct device_attribute *attr,
                         char *buf)
 {
-        struct drm_device *dev = to_drm_device(device);
-        if (dev->driver->dri_library_name)
-                return dev->driver->dri_library_name(dev, buf);
-        return snprintf(buf, PAGE_SIZE, "%s\n", dev->driver->pci_driver.name);
+        struct drm_minor *drm_minor = to_drm_minor(device);
+        struct drm_device *drm_dev = drm_minor->dev;
+        if (drm_dev->driver->dri_library_name)
+                return drm_dev->driver->dri_library_name(drm_dev, buf);
+        return snprintf(buf, PAGE_SIZE, "%s\n", drm_dev->driver->pci_driver.name);
 }
 
 static struct device_attribute device_attrs[] = {
@@ -152,25 +155,28 @@ static void drm_sysfs_device_release(struct device *dev)
  * as the parent for the Linux device, and make sure it has a file containing
  * the driver we're using (for userspace compatibility).
  */
-int drm_sysfs_device_add(struct drm_device *dev, struct drm_head *head)
+int drm_sysfs_device_add(struct drm_minor *minor)
 {
         int err;
         int i, j;
+        char *minor_str;
 
-        dev->dev.parent = &dev->pdev->dev;
-        dev->dev.class = drm_class;
-        dev->dev.release = drm_sysfs_device_release;
-        dev->dev.devt = head->device;
-        snprintf(dev->dev.bus_id, BUS_ID_SIZE, "card%d", head->minor);
+        minor->kdev.parent = &minor->dev->pdev->dev;
+        minor->kdev.class = drm_class;
+        minor->kdev.release = drm_sysfs_device_release;
+        minor->kdev.devt = minor->device;
+        minor_str = "card%d";
 
-        err = device_register(&dev->dev);
+        snprintf(minor->kdev.bus_id, BUS_ID_SIZE, minor_str, minor->index);
+
+        err = device_register(&minor->kdev);
         if (err) {
                 DRM_ERROR("device add failed: %d\n", err);
                 goto err_out;
         }
 
         for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
-                err = device_create_file(&dev->dev, &device_attrs[i]);
+                err = device_create_file(&minor->kdev, &device_attrs[i]);
                 if (err)
                         goto err_out_files;
         }
@@ -180,8 +186,8 @@ int drm_sysfs_device_add(struct drm_device *dev, struct drm_head *head)
 err_out_files:
         if (i > 0)
                 for (j = 0; j < i; j++)
-                        device_remove_file(&dev->dev, &device_attrs[i]);
-        device_unregister(&dev->dev);
+                        device_remove_file(&minor->kdev, &device_attrs[i]);
+        device_unregister(&minor->kdev);
 err_out:
 
         return err;
@@ -194,11 +200,11 @@ err_out:
  * This call unregisters and cleans up a class device that was created with a
  * call to drm_sysfs_device_add()
  */
-void drm_sysfs_device_remove(struct drm_device *dev)
+void drm_sysfs_device_remove(struct drm_minor *minor)
 {
         int i;
 
         for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
-                device_remove_file(&dev->dev, &device_attrs[i]);
-        device_unregister(&dev->dev);
+                device_remove_file(&minor->kdev, &device_attrs[i]);
+        device_unregister(&minor->kdev);
 }
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index 945df72a51a9..c234c6f24a8d 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -90,7 +90,7 @@ static pgprot_t drm_dma_prot(uint32_t map_type, struct vm_area_struct *vma)
 static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_map *map = NULL;
         struct drm_map_list *r_list;
         struct drm_hash_item *hash;
@@ -207,7 +207,7 @@ static int drm_do_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 static void drm_vm_shm_close(struct vm_area_struct *vma)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_vma_entry *pt, *temp;
         struct drm_map *map;
         struct drm_map_list *r_list;
@@ -286,7 +286,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 static int drm_do_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_device_dma *dma = dev->dma;
         unsigned long offset;
         unsigned long page_nr;
@@ -321,7 +321,7 @@ static int drm_do_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct drm_map *map = (struct drm_map *) vma->vm_private_data;
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_sg_mem *entry = dev->sg;
         unsigned long offset;
         unsigned long map_offset;
@@ -402,7 +402,7 @@ static struct vm_operations_struct drm_vm_sg_ops = {
 static void drm_vm_open_locked(struct vm_area_struct *vma)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_vma_entry *vma_entry;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -420,7 +420,7 @@ static void drm_vm_open_locked(struct vm_area_struct *vma)
 static void drm_vm_open(struct vm_area_struct *vma)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
 
         mutex_lock(&dev->struct_mutex);
         drm_vm_open_locked(vma);
@@ -438,7 +438,7 @@ static void drm_vm_open(struct vm_area_struct *vma)
 static void drm_vm_close(struct vm_area_struct *vma)
 {
         struct drm_file *priv = vma->vm_file->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_vma_entry *pt, *temp;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -473,7 +473,7 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
         struct drm_device_dma *dma;
         unsigned long length = vma->vm_end - vma->vm_start;
 
-        dev = priv->head->dev;
+        dev = priv->minor->dev;
         dma = dev->dma;
         DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
                   vma->vm_start, vma->vm_end, vma->vm_pgoff);
@@ -543,7 +543,7 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
 static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 {
         struct drm_file *priv = filp->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         struct drm_map *map = NULL;
         unsigned long offset = 0;
         struct drm_hash_item *hash;
@@ -640,12 +640,12 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
                 /* Don't let this area swap.  Change when
                    DRM_KERNEL advisory is supported. */
                 vma->vm_flags |= VM_RESERVED;
-                vma->vm_page_prot = drm_dma_prot(map->type, vma);
                 break;
         case _DRM_SCATTER_GATHER:
                 vma->vm_ops = &drm_vm_sg_ops;
                 vma->vm_private_data = (void *)map;
                 vma->vm_flags |= VM_RESERVED;
+                vma->vm_page_prot = drm_dma_prot(map->type, vma);
                 break;
         default:
                 return -EINVAL; /* This should never happen. */
@@ -661,7 +661,7 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         struct drm_file *priv = filp->private_data;
-        struct drm_device *dev = priv->head->dev;
+        struct drm_device *dev = priv->minor->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index 8d7ea81c4b66..e5de8ea41544 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -94,7 +94,7 @@ static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
         drm_i810_buf_priv_t *buf_priv;
 
         lock_kernel();
-        dev = priv->head->dev;
+        dev = priv->minor->dev;
         dev_priv = dev->dev_private;
         buf = dev_priv->mmap_buffer;
         buf_priv = buf->dev_private;
@@ -122,7 +122,7 @@ static const struct file_operations i810_buffer_fops = {
 
 static int i810_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
+        struct drm_device *dev = file_priv->minor->dev;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         drm_i810_private_t *dev_priv = dev->dev_private;
         const struct file_operations *old_fops;
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 9df08105f4f3..60c9376be486 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -96,7 +96,7 @@ static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
         drm_i830_buf_priv_t *buf_priv;
 
         lock_kernel();
-        dev = priv->head->dev;
+        dev = priv->minor->dev;
         dev_priv = dev->dev_private;
         buf = dev_priv->mmap_buffer;
         buf_priv = buf->dev_private;
@@ -124,7 +124,7 @@ static const struct file_operations i830_buffer_fops = {
 
 static int i830_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
+        struct drm_device *dev = file_priv->minor->dev;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         drm_i830_private_t *dev_priv = dev->dev_private;
         const struct file_operations *old_fops;
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index a043bb12301a..ef7bf143a80c 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -415,10 +415,13 @@ static void i915_emit_breadcrumb(struct drm_device *dev)
         drm_i915_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
 
-        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
+        if (++dev_priv->counter > BREADCRUMB_MASK) {
+                 dev_priv->counter = 1;
+                 DRM_DEBUG("Breadcrumb counter wrapped around\n");
+        }
 
-        if (dev_priv->counter > 0x7FFFFFFFUL)
-                dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
+        if (dev_priv->sarea_priv)
+                dev_priv->sarea_priv->last_enqueue = dev_priv->counter;
 
         BEGIN_LP_RING(4);
         OUT_RING(CMD_STORE_DWORD_IDX);
@@ -428,6 +431,26 @@ static void i915_emit_breadcrumb(struct drm_device *dev)
         ADVANCE_LP_RING();
 }
 
+int i915_emit_mi_flush(struct drm_device *dev, uint32_t flush)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        uint32_t flush_cmd = CMD_MI_FLUSH;
+        RING_LOCALS;
+
+        flush_cmd |= flush;
+
+        i915_kernel_lost_context(dev);
+
+        BEGIN_LP_RING(4);
+        OUT_RING(flush_cmd);
+        OUT_RING(0);
+        OUT_RING(0);
+        OUT_RING(0);
+        ADVANCE_LP_RING();
+
+        return 0;
+}
+
 static int i915_dispatch_cmdbuffer(struct drm_device * dev,
                                    drm_i915_cmdbuffer_t * cmd)
 {
@@ -511,52 +534,74 @@ static int i915_dispatch_batchbuffer(struct drm_device * dev,
         return 0;
 }
 
-static int i915_dispatch_flip(struct drm_device * dev)
+static void i915_do_dispatch_flip(struct drm_device * dev, int plane, int sync)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
+        u32 num_pages, current_page, next_page, dspbase;
+        int shift = 2 * plane, x, y;
         RING_LOCALS;
 
-        DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
-                  __FUNCTION__,
-                  dev_priv->current_page,
-                  dev_priv->sarea_priv->pf_current_page);
+        /* Calculate display base offset */
+        num_pages = dev_priv->sarea_priv->third_handle ? 3 : 2;
+        current_page = (dev_priv->sarea_priv->pf_current_page >> shift) & 0x3;
+        next_page = (current_page + 1) % num_pages;
 
-        i915_kernel_lost_context(dev);
-
-        BEGIN_LP_RING(2);
-        OUT_RING(INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE);
-        OUT_RING(0);
-        ADVANCE_LP_RING();
+        switch (next_page) {
+        default:
+        case 0:
+                dspbase = dev_priv->sarea_priv->front_offset;
+                break;
+        case 1:
+                dspbase = dev_priv->sarea_priv->back_offset;
+                break;
+        case 2:
+                dspbase = dev_priv->sarea_priv->third_offset;
+                break;
+        }
 
-        BEGIN_LP_RING(6);
-        OUT_RING(CMD_OP_DISPLAYBUFFER_INFO | ASYNC_FLIP);
-        OUT_RING(0);
-        if (dev_priv->current_page == 0) {
-                OUT_RING(dev_priv->back_offset);
-                dev_priv->current_page = 1;
+        if (plane == 0) {
+                x = dev_priv->sarea_priv->planeA_x;
+                y = dev_priv->sarea_priv->planeA_y;
         } else {
-                OUT_RING(dev_priv->front_offset);
-                dev_priv->current_page = 0;
+                x = dev_priv->sarea_priv->planeB_x;
+                y = dev_priv->sarea_priv->planeB_y;
         }
-        OUT_RING(0);
-        ADVANCE_LP_RING();
 
-        BEGIN_LP_RING(2);
-        OUT_RING(MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP);
-        OUT_RING(0);
-        ADVANCE_LP_RING();
+        dspbase += (y * dev_priv->sarea_priv->pitch + x) * dev_priv->cpp;
 
-        dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
+        DRM_DEBUG("plane=%d current_page=%d dspbase=0x%x\n", plane, current_page,
+                  dspbase);
 
         BEGIN_LP_RING(4);
-        OUT_RING(CMD_STORE_DWORD_IDX);
-        OUT_RING(20);
-        OUT_RING(dev_priv->counter);
-        OUT_RING(0);
+        OUT_RING(sync ? 0 :
+                 (MI_WAIT_FOR_EVENT | (plane ? MI_WAIT_FOR_PLANE_B_FLIP :
+                                       MI_WAIT_FOR_PLANE_A_FLIP)));
+        OUT_RING(CMD_OP_DISPLAYBUFFER_INFO | (sync ? 0 : ASYNC_FLIP) |
+                 (plane ? DISPLAY_PLANE_B : DISPLAY_PLANE_A));
+        OUT_RING(dev_priv->sarea_priv->pitch * dev_priv->cpp);
+        OUT_RING(dspbase);
         ADVANCE_LP_RING();
 
-        dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
-        return 0;
+        dev_priv->sarea_priv->pf_current_page &= ~(0x3 << shift);
+        dev_priv->sarea_priv->pf_current_page |= next_page << shift;
+}
+
+void i915_dispatch_flip(struct drm_device * dev, int planes, int sync)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        int i;
+
+        DRM_DEBUG("planes=0x%x pfCurrentPage=%d\n",
+                  planes, dev_priv->sarea_priv->pf_current_page);
+
+        i915_emit_mi_flush(dev, MI_READ_FLUSH | MI_EXE_FLUSH);
+
+        for (i = 0; i < 2; i++)
+                if (planes & (1 << i))
+                        i915_do_dispatch_flip(dev, i, sync);
+
+        i915_emit_breadcrumb(dev);
+
 }
 
 static int i915_quiescent(struct drm_device * dev)
@@ -579,7 +624,6 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
                             struct drm_file *file_priv)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u32 *hw_status = dev_priv->hw_status_page;
         drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
             dev_priv->sarea_priv;
         drm_i915_batchbuffer_t *batch = data;
@@ -602,7 +646,7 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
 
         ret = i915_dispatch_batchbuffer(dev, batch);
 
-        sarea_priv->last_dispatch = (int)hw_status[5];
+        sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
         return ret;
 }
 
@@ -610,7 +654,6 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u32 *hw_status = dev_priv->hw_status_page;
         drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
             dev_priv->sarea_priv;
         drm_i915_cmdbuffer_t *cmdbuf = data;
@@ -635,18 +678,51 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                 return ret;
         }
 
-        sarea_priv->last_dispatch = (int)hw_status[5];
+        sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
+        return 0;
+}
+
+static int i915_do_cleanup_pageflip(struct drm_device * dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        int i, planes, num_pages = dev_priv->sarea_priv->third_handle ? 3 : 2;
+
+        DRM_DEBUG("\n");
+
+        for (i = 0, planes = 0; i < 2; i++)
+                if (dev_priv->sarea_priv->pf_current_page & (0x3 << (2 * i))) {
+                        dev_priv->sarea_priv->pf_current_page =
+                                (dev_priv->sarea_priv->pf_current_page &
+                                 ~(0x3 << (2 * i))) | ((num_pages - 1) << (2 * i));
+
+                        planes |= 1 << i;
+                }
+
+        if (planes)
+                i915_dispatch_flip(dev, planes, 0);
+
         return 0;
 }
 
 static int i915_flip_bufs(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
-        DRM_DEBUG("%s\n", __FUNCTION__);
+        drm_i915_flip_t *param = data;
+
+        DRM_DEBUG("\n");
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        return i915_dispatch_flip(dev);
+        /* This is really planes */
+        if (param->pipes & ~0x3) {
+                DRM_ERROR("Invalid planes 0x%x, only <= 0x3 is valid\n",
+                          param->pipes);
+                return -EINVAL;
+        }
+
+        i915_dispatch_flip(dev, param->pipes, 0);
+
+        return 0;
 }
 
 static int i915_getparam(struct drm_device *dev, void *data,
@@ -807,6 +883,8 @@ void i915_driver_lastclose(struct drm_device * dev)
         if (!dev_priv)
                 return;
 
+        if (drm_getsarea(dev) && dev_priv->sarea_priv)
+                i915_do_cleanup_pageflip(dev);
         if (dev_priv->agp_heap)
                 i915_mem_takedown(&(dev_priv->agp_heap));
 
diff --git a/drivers/char/drm/i915_drm.h b/drivers/char/drm/i915_drm.h
index 05c66cf03a9e..0431c00e2289 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -105,14 +105,29 @@ typedef struct _drm_i915_sarea {
         unsigned int rotated_tiled;
         unsigned int rotated2_tiled;
 
-        int pipeA_x;
-        int pipeA_y;
-        int pipeA_w;
-        int pipeA_h;
-        int pipeB_x;
-        int pipeB_y;
-        int pipeB_w;
-        int pipeB_h;
+        int planeA_x;
+        int planeA_y;
+        int planeA_w;
+        int planeA_h;
+        int planeB_x;
+        int planeB_y;
+        int planeB_w;
+        int planeB_h;
+
+        /* Triple buffering */
+        drm_handle_t third_handle;
+        int third_offset;
+        int third_size;
+        unsigned int third_tiled;
+
+        /* buffer object handles for the static buffers.  May change
+         * over the lifetime of the client, though it doesn't in our current
+         * implementation.
+         */
+        unsigned int front_bo_handle;
+        unsigned int back_bo_handle;
+        unsigned int third_bo_handle;
+        unsigned int depth_bo_handle;
 } drm_i915_sarea_t;
 
 /* Flags for perf_boxes
@@ -146,7 +161,7 @@ typedef struct _drm_i915_sarea {
 
 #define DRM_IOCTL_I915_INIT             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)
 #define DRM_IOCTL_I915_FLUSH            DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
-#define DRM_IOCTL_I915_FLIP             DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLIP)
+#define DRM_IOCTL_I915_FLIP             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_FLIP, drm_i915_flip_t)
 #define DRM_IOCTL_I915_BATCHBUFFER      DRM_IOW( DRM_COMMAND_BASE + DRM_I915_BATCHBUFFER, drm_i915_batchbuffer_t)
 #define DRM_IOCTL_I915_IRQ_EMIT         DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_IRQ_EMIT, drm_i915_irq_emit_t)
 #define DRM_IOCTL_I915_IRQ_WAIT         DRM_IOW( DRM_COMMAND_BASE + DRM_I915_IRQ_WAIT, drm_i915_irq_wait_t)
@@ -161,6 +176,18 @@ typedef struct _drm_i915_sarea {
 #define DRM_IOCTL_I915_GET_VBLANK_PIPE  DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
 #define DRM_IOCTL_I915_VBLANK_SWAP      DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t)
 
+/* Asynchronous page flipping:
+ */
+typedef struct drm_i915_flip {
+        /*
+         * This is really talking about planes, and we could rename it
+         * except for the fact that some of the duplicated i915_drm.h files
+         * out there check for HAVE_I915_FLIP and so might pick up this
+         * version.
+         */
+        int pipes;
+} drm_i915_flip_t;
+
 /* Allow drivers to submit batchbuffers directly to hardware, relying
  * on the security mechanisms provided by hardware.
  */
diff --git a/drivers/char/drm/i915_drv.c b/drivers/char/drm/i915_drv.c
index b2b451dc4460..bb8f1b2fb383 100644
--- a/drivers/char/drm/i915_drv.c
+++ b/drivers/char/drm/i915_drv.c
@@ -533,8 +533,7 @@ static struct drm_driver driver = {
          */
         .driver_features =
             DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | /* DRIVER_USE_MTRR |*/
-            DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL |
-            DRIVER_IRQ_VBL2,
+            DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED,
         .load = i915_driver_load,
         .unload = i915_driver_unload,
         .lastclose = i915_driver_lastclose,
@@ -542,8 +541,9 @@ static struct drm_driver driver = {
         .suspend = i915_suspend,
         .resume = i915_resume,
         .device_is_agp = i915_driver_device_is_agp,
-        .vblank_wait = i915_driver_vblank_wait,
-        .vblank_wait2 = i915_driver_vblank_wait2,
+        .get_vblank_counter = i915_get_vblank_counter,
+        .enable_vblank = i915_enable_vblank,
+        .disable_vblank = i915_disable_vblank,
         .irq_preinstall = i915_driver_irq_preinstall,
         .irq_postinstall = i915_driver_irq_postinstall,
         .irq_uninstall = i915_driver_irq_uninstall,
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index 675d88bda066..c614d78b3dfd 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -76,8 +76,9 @@ struct mem_block {
 typedef struct _drm_i915_vbl_swap {
         struct list_head head;
         drm_drawable_t drw_id;
-        unsigned int pipe;
+        unsigned int plane;
         unsigned int sequence;
+        int flip;
 } drm_i915_vbl_swap_t;
 
 typedef struct drm_i915_private {
@@ -90,7 +91,7 @@ typedef struct drm_i915_private {
         drm_dma_handle_t *status_page_dmah;
         void *hw_status_page;
         dma_addr_t dma_status_page;
-        unsigned long counter;
+        uint32_t counter;
         unsigned int status_gfx_addr;
         drm_local_map_t hws_map;
 
@@ -103,13 +104,18 @@ typedef struct drm_i915_private {
 
         wait_queue_head_t irq_queue;
         atomic_t irq_received;
-        atomic_t irq_emitted;
+        atomic_t irq_emited;
 
         int tex_lru_log_granularity;
         int allow_batchbuffer;
         struct mem_block *agp_heap;
         unsigned int sr01, adpa, ppcr, dvob, dvoc, lvds;
         int vblank_pipe;
+        spinlock_t user_irq_lock;
+        int user_irq_refcount;
+        int fence_irq_on;
+        uint32_t irq_enable_reg;
+        int irq_enabled;
 
         spinlock_t swaps_lock;
         drm_i915_vbl_swap_t vbl_swaps;
@@ -216,7 +222,7 @@ extern void i915_driver_preclose(struct drm_device *dev,
 extern int i915_driver_device_is_agp(struct drm_device * dev);
 extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,
                               unsigned long arg);
-
+extern void i915_dispatch_flip(struct drm_device * dev, int pipes, int sync);
 /* i915_irq.c */
 extern int i915_irq_emit(struct drm_device *dev, void *data,
                          struct drm_file *file_priv);
@@ -227,7 +233,7 @@ extern int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequenc
 extern int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence);
 extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
 extern void i915_driver_irq_preinstall(struct drm_device * dev);
-extern void i915_driver_irq_postinstall(struct drm_device * dev);
+extern int i915_driver_irq_postinstall(struct drm_device * dev);
 extern void i915_driver_irq_uninstall(struct drm_device * dev);
 extern int i915_vblank_pipe_set(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
@@ -235,6 +241,9 @@ extern int i915_vblank_pipe_get(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
 extern int i915_vblank_swap(struct drm_device *dev, void *data,
                             struct drm_file *file_priv);
+extern int i915_enable_vblank(struct drm_device *dev, int crtc);
+extern void i915_disable_vblank(struct drm_device *dev, int crtc);
+extern u32 i915_get_vblank_counter(struct drm_device *dev, int crtc);
 
 /* i915_mem.c */
 extern int i915_mem_alloc(struct drm_device *dev, void *data,
@@ -379,21 +388,91 @@ extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 
 /* Interrupt bits:
  */
-#define USER_INT_FLAG    (1<<1)
-#define VSYNC_PIPEB_FLAG (1<<5)
-#define VSYNC_PIPEA_FLAG (1<<7)
-#define HWB_OOM_FLAG     (1<<13) /* binner out of memory */
+#define I915_PIPE_CONTROL_NOTIFY_INTERRUPT              (1<<18)
+#define I915_DISPLAY_PORT_INTERRUPT                     (1<<17)
+#define I915_RENDER_COMMAND_PARSER_ERROR_INTERRUPT      (1<<15)
+#define I915_GMCH_THERMAL_SENSOR_EVENT_INTERRUPT        (1<<14)
+#define I915_HWB_OOM_INTERRUPT                          (1<<13) /* binner out of memory */
+#define I915_SYNC_STATUS_INTERRUPT                      (1<<12)
+#define I915_DISPLAY_PLANE_A_FLIP_PENDING_INTERRUPT     (1<<11)
+#define I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT     (1<<10)
+#define I915_OVERLAY_PLANE_FLIP_PENDING_INTERRUPT       (1<<9)
+#define I915_DISPLAY_PLANE_C_FLIP_PENDING_INTERRUPT     (1<<8)
+#define I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT            (1<<7)
+#define I915_DISPLAY_PIPE_A_EVENT_INTERRUPT             (1<<6)
+#define I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT            (1<<5)
+#define I915_DISPLAY_PIPE_B_EVENT_INTERRUPT             (1<<4)
+#define I915_DEBUG_INTERRUPT                            (1<<2)
+#define I915_USER_INTERRUPT                             (1<<1)
+
 
 #define I915REG_HWSTAM          0x02098
 #define I915REG_INT_IDENTITY_R  0x020a4
 #define I915REG_INT_MASK_R      0x020a8
 #define I915REG_INT_ENABLE_R    0x020a0
+#define I915REG_INSTPM          0x020c0
+
+#define PIPEADSL                0x70000
+#define PIPEBDSL                0x71000
 
 #define I915REG_PIPEASTAT       0x70024
 #define I915REG_PIPEBSTAT       0x71024
+/*
+ * The two pipe frame counter registers are not synchronized, so
+ * reading a stable value is somewhat tricky. The following code
+ * should work:
+ *
+ *  do {
+ *    high1 = ((INREG(PIPEAFRAMEHIGH) & PIPE_FRAME_HIGH_MASK) >>
+ *             PIPE_FRAME_HIGH_SHIFT;
+ *    low1 =  ((INREG(PIPEAFRAMEPIXEL) & PIPE_FRAME_LOW_MASK) >>
+ *             PIPE_FRAME_LOW_SHIFT);
+ *    high2 = ((INREG(PIPEAFRAMEHIGH) & PIPE_FRAME_HIGH_MASK) >>
+ *             PIPE_FRAME_HIGH_SHIFT);
+ *  } while (high1 != high2);
+ *  frame = (high1 << 8) | low1;
+ */
+#define PIPEAFRAMEHIGH          0x70040
+#define PIPEBFRAMEHIGH          0x71040
+#define PIPE_FRAME_HIGH_MASK    0x0000ffff
+#define PIPE_FRAME_HIGH_SHIFT   0
+#define PIPEAFRAMEPIXEL         0x70044
+#define PIPEBFRAMEPIXEL         0x71044
 
-#define I915_VBLANK_INTERRUPT_ENABLE    (1UL<<17)
-#define I915_VBLANK_CLEAR               (1UL<<1)
+#define PIPE_FRAME_LOW_MASK     0xff000000
+#define PIPE_FRAME_LOW_SHIFT    24
+/*
+ * Pixel within the current frame is counted in the PIPEAFRAMEPIXEL register
+ * and is 24 bits wide.
+ */
+#define PIPE_PIXEL_MASK         0x00ffffff
+#define PIPE_PIXEL_SHIFT        0
+
+#define I915_FIFO_UNDERRUN_STATUS               (1UL<<31)
+#define I915_CRC_ERROR_ENABLE                   (1UL<<29)
+#define I915_CRC_DONE_ENABLE                    (1UL<<28)
+#define I915_GMBUS_EVENT_ENABLE                 (1UL<<27)
+#define I915_VSYNC_INTERRUPT_ENABLE             (1UL<<25)
+#define I915_DISPLAY_LINE_COMPARE_ENABLE        (1UL<<24)
+#define I915_DPST_EVENT_ENABLE                  (1UL<<23)
+#define I915_LEGACY_BLC_EVENT_ENABLE            (1UL<<22)
+#define I915_ODD_FIELD_INTERRUPT_ENABLE         (1UL<<21)
+#define I915_EVEN_FIELD_INTERRUPT_ENABLE        (1UL<<20)
+#define I915_START_VBLANK_INTERRUPT_ENABLE      (1UL<<18)       /* 965 or later */
+#define I915_VBLANK_INTERRUPT_ENABLE            (1UL<<17)
+#define I915_OVERLAY_UPDATED_ENABLE             (1UL<<16)
+#define I915_CRC_ERROR_INTERRUPT_STATUS         (1UL<<13)
+#define I915_CRC_DONE_INTERRUPT_STATUS          (1UL<<12)
+#define I915_GMBUS_INTERRUPT_STATUS             (1UL<<11)
+#define I915_VSYNC_INTERRUPT_STATUS             (1UL<<9)
+#define I915_DISPLAY_LINE_COMPARE_STATUS        (1UL<<8)
+#define I915_DPST_EVENT_STATUS                  (1UL<<7)
+#define I915_LEGACY_BLC_EVENT_STATUS            (1UL<<6)
+#define I915_ODD_FIELD_INTERRUPT_STATUS         (1UL<<5)
+#define I915_EVEN_FIELD_INTERRUPT_STATUS        (1UL<<4)
+#define I915_START_VBLANK_INTERRUPT_STATUS      (1UL<<2)        /* 965 or later */
+#define I915_VBLANK_INTERRUPT_STATUS            (1UL<<1)
+#define I915_OVERLAY_UPDATED_STATUS             (1UL<<0)
 
 #define SRX_INDEX               0x3c4
 #define SRX_DATA                0x3c5
@@ -566,6 +645,8 @@ extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 #define XY_SRC_COPY_BLT_CMD             ((2<<29)|(0x53<<22)|6)
 #define XY_SRC_COPY_BLT_WRITE_ALPHA     (1<<21)
 #define XY_SRC_COPY_BLT_WRITE_RGB       (1<<20)
+#define XY_SRC_COPY_BLT_SRC_TILED       (1<<15)
+#define XY_SRC_COPY_BLT_DST_TILED       (1<<11)
 
 #define MI_BATCH_BUFFER         ((0x30<<23)|1)
 #define MI_BATCH_BUFFER_START   (0x31<<23)
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index 92653b38e64c..023ce66ef3ab 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -38,6 +38,109 @@
 #define MAX_NOPID ((u32)~0)
 
 /**
+ * i915_get_pipe - return the the pipe associated with a given plane
+ * @dev: DRM device
+ * @plane: plane to look for
+ *
+ * The Intel Mesa & 2D drivers call the vblank routines with a plane number
+ * rather than a pipe number, since they may not always be equal.  This routine
+ * maps the given @plane back to a pipe number.
+ */
+static int
+i915_get_pipe(struct drm_device *dev, int plane)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        u32 dspcntr;
+
+        dspcntr = plane ? I915_READ(DSPBCNTR) : I915_READ(DSPACNTR);
+
+        return dspcntr & DISPPLANE_SEL_PIPE_MASK ? 1 : 0;
+}
+
+/**
+ * i915_get_plane - return the the plane associated with a given pipe
+ * @dev: DRM device
+ * @pipe: pipe to look for
+ *
+ * The Intel Mesa & 2D drivers call the vblank routines with a plane number
+ * rather than a plane number, since they may not always be equal.  This routine
+ * maps the given @pipe back to a plane number.
+ */
+static int
+i915_get_plane(struct drm_device *dev, int pipe)
+{
+        if (i915_get_pipe(dev, 0) == pipe)
+                return 0;
+        return 1;
+}
+
+/**
+ * i915_pipe_enabled - check if a pipe is enabled
+ * @dev: DRM device
+ * @pipe: pipe to check
+ *
+ * Reading certain registers when the pipe is disabled can hang the chip.
+ * Use this routine to make sure the PLL is running and the pipe is active
+ * before reading such registers if unsure.
+ */
+static int
+i915_pipe_enabled(struct drm_device *dev, int pipe)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        unsigned long pipeconf = pipe ? PIPEBCONF : PIPEACONF;
+
+        if (I915_READ(pipeconf) & PIPEACONF_ENABLE)
+                return 1;
+
+        return 0;
+}
+
+/**
+ * Emit a synchronous flip.
+ *
+ * This function must be called with the drawable spinlock held.
+ */
+static void
+i915_dispatch_vsync_flip(struct drm_device *dev, struct drm_drawable_info *drw,
+                         int plane)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
+        u16 x1, y1, x2, y2;
+        int pf_planes = 1 << plane;
+
+        /* If the window is visible on the other plane, we have to flip on that
+         * plane as well.
+         */
+        if (plane == 1) {
+                x1 = sarea_priv->planeA_x;
+                y1 = sarea_priv->planeA_y;
+                x2 = x1 + sarea_priv->planeA_w;
+                y2 = y1 + sarea_priv->planeA_h;
+        } else {
+                x1 = sarea_priv->planeB_x;
+                y1 = sarea_priv->planeB_y;
+                x2 = x1 + sarea_priv->planeB_w;
+                y2 = y1 + sarea_priv->planeB_h;
+        }
+
+        if (x2 > 0 && y2 > 0) {
+                int i, num_rects = drw->num_rects;
+                struct drm_clip_rect *rect = drw->rects;
+
+                for (i = 0; i < num_rects; i++)
+                        if (!(rect[i].x1 >= x2 || rect[i].y1 >= y2 ||
+                              rect[i].x2 <= x1 || rect[i].y2 <= y1)) {
+                                pf_planes = 0x3;
+
+                                break;
+                        }
+        }
+
+        i915_dispatch_flip(dev, pf_planes, 1);
+}
+
+/**
  * Emit blits for scheduled buffer swaps.
  *
  * This function will be called with the HW lock held.
@@ -45,40 +148,59 @@
 static void i915_vblank_tasklet(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        unsigned long irqflags;
         struct list_head *list, *tmp, hits, *hit;
-        int nhits, nrects, slice[2], upper[2], lower[2], i;
-        unsigned counter[2] = { atomic_read(&dev->vbl_received),
-                                atomic_read(&dev->vbl_received2) };
+        int nhits, nrects, slice[2], upper[2], lower[2], i, num_pages;
+        unsigned counter[2];
         struct drm_drawable_info *drw;
         drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        u32 cpp = dev_priv->cpp;
+        u32 cpp = dev_priv->cpp,  offsets[3];
         u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
                                 XY_SRC_COPY_BLT_WRITE_ALPHA |
                                 XY_SRC_COPY_BLT_WRITE_RGB)
                              : XY_SRC_COPY_BLT_CMD;
-        u32 pitchropcpp = (sarea_priv->pitch * cpp) | (0xcc << 16) |
-                          (cpp << 23) | (1 << 24);
+        u32 src_pitch = sarea_priv->pitch * cpp;
+        u32 dst_pitch = sarea_priv->pitch * cpp;
+        /* COPY rop (0xcc), map cpp to magic color depth constants */
+        u32 ropcpp = (0xcc << 16) | ((cpp - 1) << 24);
         RING_LOCALS;
 
+        if (sarea_priv->front_tiled) {
+                cmd |= XY_SRC_COPY_BLT_DST_TILED;
+                dst_pitch >>= 2;
+        }
+        if (sarea_priv->back_tiled) {
+                cmd |= XY_SRC_COPY_BLT_SRC_TILED;
+                src_pitch >>= 2;
+        }
+
+        counter[0] = drm_vblank_count(dev, 0);
+        counter[1] = drm_vblank_count(dev, 1);
+
         DRM_DEBUG("\n");
 
         INIT_LIST_HEAD(&hits);
 
         nhits = nrects = 0;
 
-        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+        /* No irqsave/restore necessary.  This tasklet may be run in an
+         * interrupt context or normal context, but we don't have to worry
+         * about getting interrupted by something acquiring the lock, because
+         * we are the interrupt context thing that acquires the lock.
+         */
+        spin_lock(&dev_priv->swaps_lock);
 
         /* Find buffer swaps scheduled for this vertical blank */
         list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
                 drm_i915_vbl_swap_t *vbl_swap =
                         list_entry(list, drm_i915_vbl_swap_t, head);
+                int pipe = i915_get_pipe(dev, vbl_swap->plane);
 
-                if ((counter[vbl_swap->pipe] - vbl_swap->sequence) > (1<<23))
+                if ((counter[pipe] - vbl_swap->sequence) > (1<<23))
                         continue;
 
                 list_del(list);
                 dev_priv->swaps_pending--;
+                drm_vblank_put(dev, pipe);
 
                 spin_unlock(&dev_priv->swaps_lock);
                 spin_lock(&dev->drw_lock);
@@ -116,33 +238,23 @@ static void i915_vblank_tasklet(struct drm_device *dev)
                 spin_lock(&dev_priv->swaps_lock);
         }
 
-        if (nhits == 0) {
-                spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-                return;
-        }
-
         spin_unlock(&dev_priv->swaps_lock);
 
-        i915_kernel_lost_context(dev);
-
-        BEGIN_LP_RING(6);
-
-        OUT_RING(GFX_OP_DRAWRECT_INFO);
-        OUT_RING(0);
-        OUT_RING(0);
-        OUT_RING(sarea_priv->width | sarea_priv->height << 16);
-        OUT_RING(sarea_priv->width | sarea_priv->height << 16);
-        OUT_RING(0);
-
-        ADVANCE_LP_RING();
+        if (nhits == 0)
+                return;
 
-        sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;
+        i915_kernel_lost_context(dev);
 
         upper[0] = upper[1] = 0;
-        slice[0] = max(sarea_priv->pipeA_h / nhits, 1);
-        slice[1] = max(sarea_priv->pipeB_h / nhits, 1);
-        lower[0] = sarea_priv->pipeA_y + slice[0];
-        lower[1] = sarea_priv->pipeB_y + slice[0];
+        slice[0] = max(sarea_priv->planeA_h / nhits, 1);
+        slice[1] = max(sarea_priv->planeB_h / nhits, 1);
+        lower[0] = sarea_priv->planeA_y + slice[0];
+        lower[1] = sarea_priv->planeB_y + slice[0];
+
+        offsets[0] = sarea_priv->front_offset;
+        offsets[1] = sarea_priv->back_offset;
+        offsets[2] = sarea_priv->third_offset;
+        num_pages = sarea_priv->third_handle ? 3 : 2;
 
         spin_lock(&dev->drw_lock);
 
@@ -154,6 +266,8 @@ static void i915_vblank_tasklet(struct drm_device *dev)
         for (i = 0; i++ < nhits;
              upper[0] = lower[0], lower[0] += slice[0],
              upper[1] = lower[1], lower[1] += slice[1]) {
+                int init_drawrect = 1;
+
                 if (i == nhits)
                         lower[0] = lower[1] = sarea_priv->height;
 
@@ -161,7 +275,7 @@ static void i915_vblank_tasklet(struct drm_device *dev)
                         drm_i915_vbl_swap_t *swap_hit =
                                 list_entry(hit, drm_i915_vbl_swap_t, head);
                         struct drm_clip_rect *rect;
-                        int num_rects, pipe;
+                        int num_rects, plane, front, back;
                         unsigned short top, bottom;
 
                         drw = drm_get_drawable_info(dev, swap_hit->drw_id);
@@ -169,10 +283,50 @@ static void i915_vblank_tasklet(struct drm_device *dev)
                         if (!drw)
                                 continue;
 
+                        plane = swap_hit->plane;
+
+                        if (swap_hit->flip) {
+                                i915_dispatch_vsync_flip(dev, drw, plane);
+                                continue;
+                        }
+
+                        if (init_drawrect) {
+                                int width  = sarea_priv->width;
+                                int height = sarea_priv->height;
+                                if (IS_I965G(dev)) {
+                                        BEGIN_LP_RING(4);
+
+                                        OUT_RING(GFX_OP_DRAWRECT_INFO_I965);
+                                        OUT_RING(0);
+                                        OUT_RING(((width - 1) & 0xffff) | ((height - 1) << 16));
+                                        OUT_RING(0);
+
+                                        ADVANCE_LP_RING();
+                                } else {
+                                        BEGIN_LP_RING(6);
+
+                                        OUT_RING(GFX_OP_DRAWRECT_INFO);
+                                        OUT_RING(0);
+                                        OUT_RING(0);
+                                        OUT_RING(((width - 1) & 0xffff) | ((height - 1) << 16));
+                                        OUT_RING(0);
+                                        OUT_RING(0);
+
+                                        ADVANCE_LP_RING();
+                                }
+
+                                sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;
+
+                                init_drawrect = 0;
+                        }
+
                         rect = drw->rects;
-                        pipe = swap_hit->pipe;
-                        top = upper[pipe];
-                        bottom = lower[pipe];
+                        top = upper[plane];
+                        bottom = lower[plane];
+
+                        front = (dev_priv->sarea_priv->pf_current_page >>
+                                 (2 * plane)) & 0x3;
+                        back = (front + 1) % num_pages;
 
                         for (num_rects = drw->num_rects; num_rects--; rect++) {
                                 int y1 = max(rect->y1, top);
@@ -184,20 +338,20 @@ static void i915_vblank_tasklet(struct drm_device *dev)
                                 BEGIN_LP_RING(8);
 
                                 OUT_RING(cmd);
-                                OUT_RING(pitchropcpp);
+                                OUT_RING(ropcpp | dst_pitch);
                                 OUT_RING((y1 << 16) | rect->x1);
                                 OUT_RING((y2 << 16) | rect->x2);
-                                OUT_RING(sarea_priv->front_offset);
+                                OUT_RING(offsets[front]);
                                 OUT_RING((y1 << 16) | rect->x1);
-                                OUT_RING(pitchropcpp & 0xffff);
-                                OUT_RING(sarea_priv->back_offset);
+                                OUT_RING(src_pitch);
+                                OUT_RING(offsets[back]);
 
                                 ADVANCE_LP_RING();
                         }
                 }
         }
 
-        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+        spin_unlock(&dev->drw_lock);
 
         list_for_each_safe(hit, tmp, &hits) {
                 drm_i915_vbl_swap_t *swap_hit =
@@ -209,67 +363,112 @@ static void i915_vblank_tasklet(struct drm_device *dev)
         }
 }
 
+u32 i915_get_vblank_counter(struct drm_device *dev, int plane)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        unsigned long high_frame;
+        unsigned long low_frame;
+        u32 high1, high2, low, count;
+        int pipe;
+
+        pipe = i915_get_pipe(dev, plane);
+        high_frame = pipe ? PIPEBFRAMEHIGH : PIPEAFRAMEHIGH;
+        low_frame = pipe ? PIPEBFRAMEPIXEL : PIPEAFRAMEPIXEL;
+
+        if (!i915_pipe_enabled(dev, pipe)) {
+            printk(KERN_ERR "trying to get vblank count for disabled "
+                   "pipe %d\n", pipe);
+            return 0;
+        }
+
+        /*
+         * High & low register fields aren't synchronized, so make sure
+         * we get a low value that's stable across two reads of the high
+         * register.
+         */
+        do {
+                high1 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
+                         PIPE_FRAME_HIGH_SHIFT);
+                low =  ((I915_READ(low_frame) & PIPE_FRAME_LOW_MASK) >>
+                        PIPE_FRAME_LOW_SHIFT);
+                high2 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
+                         PIPE_FRAME_HIGH_SHIFT);
+        } while (high1 != high2);
+
+        count = (high1 << 8) | low;
+
+        /* count may be reset by other driver(e.g. 2D driver),
+           we have no way to know if it is wrapped or resetted
+           when count is zero. do a rough guess.
+        */
+        if (count == 0 && dev->last_vblank[pipe] < dev->max_vblank_count/2)
+                dev->last_vblank[pipe] = 0;
+
+        return count;
+}
+
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u16 temp;
+        u32 iir;
         u32 pipea_stats, pipeb_stats;
-
-        pipea_stats = I915_READ(I915REG_PIPEASTAT);
-        pipeb_stats = I915_READ(I915REG_PIPEBSTAT);
-
-        temp = I915_READ16(I915REG_INT_IDENTITY_R);
-
-        temp &= (USER_INT_FLAG | VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG);
-
-        DRM_DEBUG("%s flag=%08x\n", __FUNCTION__, temp);
-
-        if (temp == 0)
+        int vblank = 0;
+
+        iir = I915_READ(I915REG_INT_IDENTITY_R);
+        if (iir == 0) {
+                DRM_DEBUG ("iir 0x%08x im 0x%08x ie 0x%08x pipea 0x%08x pipeb 0x%08x\n",
+                           iir,
+                           I915_READ(I915REG_INT_MASK_R),
+                           I915_READ(I915REG_INT_ENABLE_R),
+                           I915_READ(I915REG_PIPEASTAT),
+                           I915_READ(I915REG_PIPEBSTAT));
                 return IRQ_NONE;
+        }
 
-        I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
-        (void) I915_READ16(I915REG_INT_IDENTITY_R);
-        DRM_READMEMORYBARRIER();
-
-        dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
+        /*
+         * Clear the PIPE(A|B)STAT regs before the IIR otherwise
+         * we may get extra interrupts.
+         */
+        if (iir & I915_DISPLAY_PIPE_A_EVENT_INTERRUPT) {
+                pipea_stats = I915_READ(I915REG_PIPEASTAT);
+                if (pipea_stats & (I915_START_VBLANK_INTERRUPT_STATUS|
+                                   I915_VBLANK_INTERRUPT_STATUS))
+                {
+                        vblank++;
+                        drm_handle_vblank(dev, i915_get_plane(dev, 0));
+                }
+                I915_WRITE(I915REG_PIPEASTAT, pipea_stats);
+        }
+        if (iir & I915_DISPLAY_PIPE_B_EVENT_INTERRUPT) {
+                pipeb_stats = I915_READ(I915REG_PIPEBSTAT);
+                if (pipeb_stats & (I915_START_VBLANK_INTERRUPT_STATUS|
+                                   I915_VBLANK_INTERRUPT_STATUS))
+                {
+                        vblank++;
+                        drm_handle_vblank(dev, i915_get_plane(dev, 1));
+                }
+                I915_WRITE(I915REG_PIPEBSTAT, pipeb_stats);
+        }
 
-        if (temp & USER_INT_FLAG)
-                DRM_WAKEUP(&dev_priv->irq_queue);
+        if (dev_priv->sarea_priv)
+            dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 
-        if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
-                int vblank_pipe = dev_priv->vblank_pipe;
-
-                if ((vblank_pipe &
-                     (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B))
-                    == (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B)) {
-                        if (temp & VSYNC_PIPEA_FLAG)
-                                atomic_inc(&dev->vbl_received);
-                        if (temp & VSYNC_PIPEB_FLAG)
-                                atomic_inc(&dev->vbl_received2);
-                } else if (((temp & VSYNC_PIPEA_FLAG) &&
-                            (vblank_pipe & DRM_I915_VBLANK_PIPE_A)) ||
-                           ((temp & VSYNC_PIPEB_FLAG) &&
-                            (vblank_pipe & DRM_I915_VBLANK_PIPE_B)))
-                        atomic_inc(&dev->vbl_received);
-
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
+        I915_WRITE(I915REG_INT_IDENTITY_R, iir);
+        (void) I915_READ(I915REG_INT_IDENTITY_R); /* Flush posted write */
 
+        if (iir & I915_USER_INTERRUPT) {
+                DRM_WAKEUP(&dev_priv->irq_queue);
+        }
+        if (vblank) {
                 if (dev_priv->swaps_pending > 0)
                         drm_locked_tasklet(dev, i915_vblank_tasklet);
-                I915_WRITE(I915REG_PIPEASTAT,
-                        pipea_stats|I915_VBLANK_INTERRUPT_ENABLE|
-                        I915_VBLANK_CLEAR);
-                I915_WRITE(I915REG_PIPEBSTAT,
-                        pipeb_stats|I915_VBLANK_INTERRUPT_ENABLE|
-                        I915_VBLANK_CLEAR);
         }
 
         return IRQ_HANDLED;
 }
 
-static int i915_emit_irq(struct drm_device * dev)
+static int i915_emit_irq(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -316,42 +515,12 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
                           READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
         }
 
-        dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
-        return ret;
-}
-
-static int i915_driver_vblank_do_wait(struct drm_device *dev, unsigned int *sequence,
-                                      atomic_t *counter)
-{
-        drm_i915_private_t *dev_priv = dev->dev_private;
-        unsigned int cur_vblank;
-        int ret = 0;
-
-        if (!dev_priv) {
-                DRM_ERROR("called with no initialization\n");
-                return -EINVAL;
-        }
-
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(counter))
-                        - *sequence) <= (1<<23)));
-
-        *sequence = cur_vblank;
-
+        if (dev_priv->sarea_priv)
+                dev_priv->sarea_priv->last_dispatch =
+                        READ_BREADCRUMB(dev_priv);
         return ret;
 }
 
-
-int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
-{
-        return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received);
-}
-
-int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
-{
-        return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received2);
-}
-
 /* Needs the lock as it touches the ring.
  */
 int i915_irq_emit(struct drm_device *dev, void *data,
@@ -394,18 +563,96 @@ int i915_irq_wait(struct drm_device *dev, void *data,
         return i915_wait_irq(dev, irqwait->irq_seq);
 }
 
+int i915_enable_vblank(struct drm_device *dev, int plane)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        int pipe = i915_get_pipe(dev, plane);
+        u32     pipestat_reg = 0;
+        u32     pipestat;
+
+        switch (pipe) {
+        case 0:
+                pipestat_reg = I915REG_PIPEASTAT;
+                dev_priv->irq_enable_reg |= I915_DISPLAY_PIPE_A_EVENT_INTERRUPT;
+                break;
+        case 1:
+                pipestat_reg = I915REG_PIPEBSTAT;
+                dev_priv->irq_enable_reg |= I915_DISPLAY_PIPE_B_EVENT_INTERRUPT;
+                break;
+        default:
+                DRM_ERROR("tried to enable vblank on non-existent pipe %d\n",
+                          pipe);
+                break;
+        }
+
+        if (pipestat_reg)
+        {
+                pipestat = I915_READ (pipestat_reg);
+                /*
+                 * Older chips didn't have the start vblank interrupt,
+                 * but
+                 */
+                if (IS_I965G (dev))
+                        pipestat |= I915_START_VBLANK_INTERRUPT_ENABLE;
+                else
+                        pipestat |= I915_VBLANK_INTERRUPT_ENABLE;
+                /*
+                 * Clear any pending status
+                 */
+                pipestat |= (I915_START_VBLANK_INTERRUPT_STATUS |
+                             I915_VBLANK_INTERRUPT_STATUS);
+                I915_WRITE(pipestat_reg, pipestat);
+        }
+        I915_WRITE(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
+
+        return 0;
+}
+
+void i915_disable_vblank(struct drm_device *dev, int plane)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        int pipe = i915_get_pipe(dev, plane);
+        u32     pipestat_reg = 0;
+        u32     pipestat;
+
+        switch (pipe) {
+        case 0:
+                pipestat_reg = I915REG_PIPEASTAT;
+                dev_priv->irq_enable_reg &= ~I915_DISPLAY_PIPE_A_EVENT_INTERRUPT;
+                break;
+        case 1:
+                pipestat_reg = I915REG_PIPEBSTAT;
+                dev_priv->irq_enable_reg &= ~I915_DISPLAY_PIPE_B_EVENT_INTERRUPT;
+                break;
+        default:
+                DRM_ERROR("tried to disable vblank on non-existent pipe %d\n",
+                          pipe);
+                break;
+        }
+
+        I915_WRITE(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
+        if (pipestat_reg)
+        {
+                pipestat = I915_READ (pipestat_reg);
+                pipestat &= ~(I915_START_VBLANK_INTERRUPT_ENABLE |
+                              I915_VBLANK_INTERRUPT_ENABLE);
+                /*
+                 * Clear any pending status
+                 */
+                pipestat |= (I915_START_VBLANK_INTERRUPT_STATUS |
+                             I915_VBLANK_INTERRUPT_STATUS);
+                I915_WRITE(pipestat_reg, pipestat);
+        }
+}
+
 static void i915_enable_interrupt (struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u16 flag;
 
-        flag = 0;
-        if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
-                flag |= VSYNC_PIPEA_FLAG;
-        if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
-                flag |= VSYNC_PIPEB_FLAG;
+        dev_priv->irq_enable_reg |= I915_USER_INTERRUPT;
 
-        I915_WRITE16(I915REG_INT_ENABLE_R, USER_INT_FLAG | flag);
+        I915_WRITE(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
+        dev_priv->irq_enabled = 1;
 }
 
 /* Set the vblank monitor pipe
@@ -428,8 +675,6 @@ int i915_vblank_pipe_set(struct drm_device *dev, void *data,
 
         dev_priv->vblank_pipe = pipe->pipe;
 
-        i915_enable_interrupt (dev);
-
         return 0;
 }
 
@@ -447,9 +692,9 @@ int i915_vblank_pipe_get(struct drm_device *dev, void *data,
 
         flag = I915_READ(I915REG_INT_ENABLE_R);
         pipe->pipe = 0;
-        if (flag & VSYNC_PIPEA_FLAG)
+        if (flag & I915_DISPLAY_PIPE_A_EVENT_INTERRUPT)
                 pipe->pipe |= DRM_I915_VBLANK_PIPE_A;
-        if (flag & VSYNC_PIPEB_FLAG)
+        if (flag & I915_DISPLAY_PIPE_B_EVENT_INTERRUPT)
                 pipe->pipe |= DRM_I915_VBLANK_PIPE_B;
 
         return 0;
@@ -464,27 +709,30 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
         drm_i915_private_t *dev_priv = dev->dev_private;
         drm_i915_vblank_swap_t *swap = data;
         drm_i915_vbl_swap_t *vbl_swap;
-        unsigned int pipe, seqtype, curseq;
+        unsigned int pipe, seqtype, curseq, plane;
         unsigned long irqflags;
         struct list_head *list;
+        int ret;
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __func__);
                 return -EINVAL;
         }
 
-        if (dev_priv->sarea_priv->rotation) {
+        if (!dev_priv->sarea_priv || dev_priv->sarea_priv->rotation) {
                 DRM_DEBUG("Rotation not supported\n");
                 return -EINVAL;
         }
 
         if (swap->seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
-                             _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
+                             _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS |
+                             _DRM_VBLANK_FLIP)) {
                 DRM_ERROR("Invalid sequence type 0x%x\n", swap->seqtype);
                 return -EINVAL;
         }
 
-        pipe = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+        plane = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+        pipe = i915_get_pipe(dev, plane);
 
         seqtype = swap->seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
 
@@ -495,6 +743,11 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
 
         spin_lock_irqsave(&dev->drw_lock, irqflags);
 
+        /* It makes no sense to schedule a swap for a drawable that doesn't have
+         * valid information at this point. E.g. this could mean that the X
+         * server is too old to push drawable information to the DRM, in which
+         * case all such swaps would become ineffective.
+         */
         if (!drm_get_drawable_info(dev, swap->drawable)) {
                 spin_unlock_irqrestore(&dev->drw_lock, irqflags);
                 DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
@@ -503,7 +756,8 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
 
         spin_unlock_irqrestore(&dev->drw_lock, irqflags);
 
-        curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
+        drm_update_vblank_count(dev, pipe);
+        curseq = drm_vblank_count(dev, pipe);
 
         if (seqtype == _DRM_VBLANK_RELATIVE)
                 swap->sequence += curseq;
@@ -517,14 +771,43 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
                 }
         }
 
+        if (swap->seqtype & _DRM_VBLANK_FLIP) {
+                swap->sequence--;
+
+                if ((curseq - swap->sequence) <= (1<<23)) {
+                        struct drm_drawable_info *drw;
+
+                        LOCK_TEST_WITH_RETURN(dev, file_priv);
+
+                        spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+                        drw = drm_get_drawable_info(dev, swap->drawable);
+
+                        if (!drw) {
+                                spin_unlock_irqrestore(&dev->drw_lock,
+                                    irqflags);
+                                DRM_DEBUG("Invalid drawable ID %d\n",
+                                          swap->drawable);
+                                return -EINVAL;
+                        }
+
+                        i915_dispatch_vsync_flip(dev, drw, plane);
+
+                        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+                        return 0;
+                }
+        }
+
         spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
 
         list_for_each(list, &dev_priv->vbl_swaps.head) {
                 vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
 
                 if (vbl_swap->drw_id == swap->drawable &&
-                    vbl_swap->pipe == pipe &&
+                    vbl_swap->plane == plane &&
                     vbl_swap->sequence == swap->sequence) {
+                        vbl_swap->flip = (swap->seqtype & _DRM_VBLANK_FLIP);
                         spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
                         DRM_DEBUG("Already scheduled\n");
                         return 0;
@@ -547,9 +830,19 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
 
         DRM_DEBUG("\n");
 
+        ret = drm_vblank_get(dev, pipe);
+        if (ret) {
+                drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
+                return ret;
+        }
+
         vbl_swap->drw_id = swap->drawable;
-        vbl_swap->pipe = pipe;
+        vbl_swap->plane = plane;
         vbl_swap->sequence = swap->sequence;
+        vbl_swap->flip = (swap->seqtype & _DRM_VBLANK_FLIP);
+
+        if (vbl_swap->flip)
+                swap->sequence++;
 
         spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
 
@@ -567,37 +860,57 @@ void i915_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
-        I915_WRITE16(I915REG_HWSTAM, 0xfffe);
+        I915_WRITE16(I915REG_HWSTAM, 0xeffe);
         I915_WRITE16(I915REG_INT_MASK_R, 0x0);
         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 }
 
-void i915_driver_irq_postinstall(struct drm_device * dev)
+int i915_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        int ret, num_pipes = 2;
 
         spin_lock_init(&dev_priv->swaps_lock);
         INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
         dev_priv->swaps_pending = 0;
 
-        if (!dev_priv->vblank_pipe)
-                dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A;
+        dev_priv->user_irq_refcount = 0;
+        dev_priv->irq_enable_reg = 0;
+
+        ret = drm_vblank_init(dev, num_pipes);
+        if (ret)
+                return ret;
+
+        dev->max_vblank_count = 0xffffff; /* only 24 bits of frame count */
+
         i915_enable_interrupt(dev);
         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
+
+        /*
+         * Initialize the hardware status page IRQ location.
+         */
+
+        I915_WRITE(I915REG_INSTPM, (1 << 5) | (1 << 21));
+        return 0;
 }
 
 void i915_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u16 temp;
+        u32 temp;
 
         if (!dev_priv)
                 return;
 
-        I915_WRITE16(I915REG_HWSTAM, 0xffff);
-        I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
-        I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
-
-        temp = I915_READ16(I915REG_INT_IDENTITY_R);
-        I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
+        dev_priv->irq_enabled = 0;
+        I915_WRITE(I915REG_HWSTAM, 0xffffffff);
+        I915_WRITE(I915REG_INT_MASK_R, 0xffffffff);
+        I915_WRITE(I915REG_INT_ENABLE_R, 0x0);
+
+        temp = I915_READ(I915REG_PIPEASTAT);
+        I915_WRITE(I915REG_PIPEASTAT, temp);
+        temp = I915_READ(I915REG_PIPEBSTAT);
+        I915_WRITE(I915REG_PIPEBSTAT, temp);
+        temp = I915_READ(I915REG_INT_IDENTITY_R);
+        I915_WRITE(I915REG_INT_IDENTITY_R, temp);
 }
diff --git a/drivers/char/drm/mga_drv.c b/drivers/char/drm/mga_drv.c
index 5572939fc7d1..6b3790939e76 100644
--- a/drivers/char/drm/mga_drv.c
+++ b/drivers/char/drm/mga_drv.c
@@ -45,15 +45,16 @@ static struct pci_device_id pciidlist[] = {
 static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA |
-            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
-            DRIVER_IRQ_VBL,
+            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED,
         .dev_priv_size = sizeof(drm_mga_buf_priv_t),
         .load = mga_driver_load,
         .unload = mga_driver_unload,
         .lastclose = mga_driver_lastclose,
         .dma_quiescent = mga_driver_dma_quiescent,
         .device_is_agp = mga_driver_device_is_agp,
-        .vblank_wait = mga_driver_vblank_wait,
+        .get_vblank_counter = mga_get_vblank_counter,
+        .enable_vblank = mga_enable_vblank,
+        .disable_vblank = mga_disable_vblank,
         .irq_preinstall = mga_driver_irq_preinstall,
         .irq_postinstall = mga_driver_irq_postinstall,
         .irq_uninstall = mga_driver_irq_uninstall,
diff --git a/drivers/char/drm/mga_drv.h b/drivers/char/drm/mga_drv.h
index f6ebd24bd587..8f7291f36363 100644
--- a/drivers/char/drm/mga_drv.h
+++ b/drivers/char/drm/mga_drv.h
@@ -120,6 +120,7 @@ typedef struct drm_mga_private {
         u32 clear_cmd;
         u32 maccess;
 
+        atomic_t vbl_received;          /**< Number of vblanks received. */
         wait_queue_head_t fence_queue;
         atomic_t last_fence_retired;
         u32 next_fence_to_post;
@@ -181,11 +182,14 @@ extern int mga_warp_install_microcode(drm_mga_private_t * dev_priv);
 extern int mga_warp_init(drm_mga_private_t * dev_priv);
 
                                 /* mga_irq.c */
+extern int mga_enable_vblank(struct drm_device *dev, int crtc);
+extern void mga_disable_vblank(struct drm_device *dev, int crtc);
+extern u32 mga_get_vblank_counter(struct drm_device *dev, int crtc);
 extern int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence);
 extern int mga_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
 extern irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS);
 extern void mga_driver_irq_preinstall(struct drm_device * dev);
-extern void mga_driver_irq_postinstall(struct drm_device * dev);
+extern int mga_driver_irq_postinstall(struct drm_device * dev);
 extern void mga_driver_irq_uninstall(struct drm_device * dev);
 extern long mga_compat_ioctl(struct file *filp, unsigned int cmd,
                              unsigned long arg);
diff --git a/drivers/char/drm/mga_irq.c b/drivers/char/drm/mga_irq.c
index 9302cb8f0f83..06852fb4b278 100644
--- a/drivers/char/drm/mga_irq.c
+++ b/drivers/char/drm/mga_irq.c
@@ -35,6 +35,20 @@
 #include "mga_drm.h"
 #include "mga_drv.h"
 
+u32 mga_get_vblank_counter(struct drm_device *dev, int crtc)
+{
+        const drm_mga_private_t *const dev_priv =
+                (drm_mga_private_t *) dev->dev_private;
+
+        if (crtc != 0) {
+                return 0;
+        }
+
+
+        return atomic_read(&dev_priv->vbl_received);
+}
+
+
 irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
@@ -47,9 +61,8 @@ irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
         /* VBLANK interrupt */
         if (status & MGA_VLINEPEN) {
                 MGA_WRITE(MGA_ICLEAR, MGA_VLINEICLR);
-                atomic_inc(&dev->vbl_received);
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
+                atomic_inc(&dev_priv->vbl_received);
+                drm_handle_vblank(dev, 0);
                 handled = 1;
         }
 
@@ -78,22 +91,34 @@ irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_NONE;
 }
 
-int mga_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
+int mga_enable_vblank(struct drm_device *dev, int crtc)
 {
-        unsigned int cur_vblank;
-        int ret = 0;
+        drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
 
-        /* Assume that the user has missed the current sequence number
-         * by about a day rather than she wants to wait for years
-         * using vertical blanks...
-         */
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received))
-                      - *sequence) <= (1 << 23)));
+        if (crtc != 0) {
+                DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
+                          crtc);
+                return 0;
+        }
 
-        *sequence = cur_vblank;
+        MGA_WRITE(MGA_IEN, MGA_VLINEIEN | MGA_SOFTRAPEN);
+        return 0;
+}
 
-        return ret;
+
+void mga_disable_vblank(struct drm_device *dev, int crtc)
+{
+        if (crtc != 0) {
+                DRM_ERROR("tried to disable vblank on non-existent crtc %d\n",
+                          crtc);
+        }
+
+        /* Do *NOT* disable the vertical refresh interrupt.  MGA doesn't have
+         * a nice hardware counter that tracks the number of refreshes when
+         * the interrupt is disabled, and the kernel doesn't know the refresh
+         * rate to calculate an estimate.
+         */
+        /* MGA_WRITE(MGA_IEN, MGA_VLINEIEN | MGA_SOFTRAPEN); */
 }
 
 int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence)
@@ -125,14 +150,22 @@ void mga_driver_irq_preinstall(struct drm_device * dev)
         MGA_WRITE(MGA_ICLEAR, ~0);
 }
 
-void mga_driver_irq_postinstall(struct drm_device * dev)
+int mga_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
+        int ret;
+
+        ret = drm_vblank_init(dev, 1);
+        if (ret)
+                return ret;
 
         DRM_INIT_WAITQUEUE(&dev_priv->fence_queue);
 
-        /* Turn on vertical blank interrupt and soft trap interrupt. */
-        MGA_WRITE(MGA_IEN, MGA_VLINEIEN | MGA_SOFTRAPEN);
+        /* Turn on soft trap interrupt.  Vertical blank interrupts are enabled
+         * in mga_enable_vblank.
+         */
+        MGA_WRITE(MGA_IEN, MGA_SOFTRAPEN);
+        return 0;
 }
 
 void mga_driver_irq_uninstall(struct drm_device * dev)
diff --git a/drivers/char/drm/r128_drv.c b/drivers/char/drm/r128_drv.c
index 6108e7587e12..2888aa01ebc7 100644
--- a/drivers/char/drm/r128_drv.c
+++ b/drivers/char/drm/r128_drv.c
@@ -43,12 +43,13 @@ static struct pci_device_id pciidlist[] = {
 static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG |
-            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
-            DRIVER_IRQ_VBL,
+            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED,
         .dev_priv_size = sizeof(drm_r128_buf_priv_t),
         .preclose = r128_driver_preclose,
         .lastclose = r128_driver_lastclose,
-        .vblank_wait = r128_driver_vblank_wait,
+        .get_vblank_counter = r128_get_vblank_counter,
+        .enable_vblank = r128_enable_vblank,
+        .disable_vblank = r128_disable_vblank,
         .irq_preinstall = r128_driver_irq_preinstall,
         .irq_postinstall = r128_driver_irq_postinstall,
         .irq_uninstall = r128_driver_irq_uninstall,
diff --git a/drivers/char/drm/r128_drv.h b/drivers/char/drm/r128_drv.h
index 011105e51ac6..80af9e09e75d 100644
--- a/drivers/char/drm/r128_drv.h
+++ b/drivers/char/drm/r128_drv.h
@@ -97,6 +97,8 @@ typedef struct drm_r128_private {
         u32 crtc_offset;
         u32 crtc_offset_cntl;
 
+        atomic_t vbl_received;
+
         u32 color_fmt;
         unsigned int front_offset;
         unsigned int front_pitch;
@@ -149,11 +151,12 @@ extern int r128_wait_ring(drm_r128_private_t * dev_priv, int n);
 extern int r128_do_cce_idle(drm_r128_private_t * dev_priv);
 extern int r128_do_cleanup_cce(struct drm_device * dev);
 
-extern int r128_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
-
+extern int r128_enable_vblank(struct drm_device *dev, int crtc);
+extern void r128_disable_vblank(struct drm_device *dev, int crtc);
+extern u32 r128_get_vblank_counter(struct drm_device *dev, int crtc);
 extern irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS);
 extern void r128_driver_irq_preinstall(struct drm_device * dev);
-extern void r128_driver_irq_postinstall(struct drm_device * dev);
+extern int r128_driver_irq_postinstall(struct drm_device * dev);
 extern void r128_driver_irq_uninstall(struct drm_device * dev);
 extern void r128_driver_lastclose(struct drm_device * dev);
 extern void r128_driver_preclose(struct drm_device * dev,
diff --git a/drivers/char/drm/r128_irq.c b/drivers/char/drm/r128_irq.c
index c76fdca7662d..5b95bd898f95 100644
--- a/drivers/char/drm/r128_irq.c
+++ b/drivers/char/drm/r128_irq.c
@@ -35,6 +35,16 @@
 #include "r128_drm.h"
 #include "r128_drv.h"
 
+u32 r128_get_vblank_counter(struct drm_device *dev, int crtc)
+{
+        const drm_r128_private_t *dev_priv = dev->dev_private;
+
+        if (crtc != 0)
+                return 0;
+
+        return atomic_read(&dev_priv->vbl_received);
+}
+
 irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
@@ -46,30 +56,38 @@ irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS)
         /* VBLANK interrupt */
         if (status & R128_CRTC_VBLANK_INT) {
                 R128_WRITE(R128_GEN_INT_STATUS, R128_CRTC_VBLANK_INT_AK);
-                atomic_inc(&dev->vbl_received);
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
+                atomic_inc(&dev_priv->vbl_received);
+                drm_handle_vblank(dev, 0);
                 return IRQ_HANDLED;
         }
         return IRQ_NONE;
 }
 
-int r128_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
+int r128_enable_vblank(struct drm_device *dev, int crtc)
 {
-        unsigned int cur_vblank;
-        int ret = 0;
+        drm_r128_private_t *dev_priv = dev->dev_private;
 
-        /* Assume that the user has missed the current sequence number
-         * by about a day rather than she wants to wait for years
-         * using vertical blanks...
-         */
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received))
-                      - *sequence) <= (1 << 23)));
+        if (crtc != 0) {
+                DRM_ERROR("%s:  bad crtc %d\n", __FUNCTION__, crtc);
+                return -EINVAL;
+        }
 
-        *sequence = cur_vblank;
+        R128_WRITE(R128_GEN_INT_CNTL, R128_CRTC_VBLANK_INT_EN);
+        return 0;
+}
+
+void r128_disable_vblank(struct drm_device *dev, int crtc)
+{
+        if (crtc != 0)
+                DRM_ERROR("%s:  bad crtc %d\n", __FUNCTION__, crtc);
 
-        return ret;
+        /*
+         * FIXME: implement proper interrupt disable by using the vblank
+         * counter register (if available)
+         *
+         * R128_WRITE(R128_GEN_INT_CNTL,
+         *            R128_READ(R128_GEN_INT_CNTL) & ~R128_CRTC_VBLANK_INT_EN);
+         */
 }
 
 void r128_driver_irq_preinstall(struct drm_device * dev)
@@ -82,12 +100,9 @@ void r128_driver_irq_preinstall(struct drm_device * dev)
         R128_WRITE(R128_GEN_INT_STATUS, R128_CRTC_VBLANK_INT_AK);
 }
 
-void r128_driver_irq_postinstall(struct drm_device * dev)
+int r128_driver_irq_postinstall(struct drm_device * dev)
 {
-        drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
-
-        /* Turn on VBL interrupt */
-        R128_WRITE(R128_GEN_INT_CNTL, R128_CRTC_VBLANK_INT_EN);
+        return drm_vblank_init(dev, 1);
 }
 
 void r128_driver_irq_uninstall(struct drm_device * dev)
diff --git a/drivers/char/drm/radeon_drv.c b/drivers/char/drm/radeon_drv.c
index 349ac3d3b848..a2610319624d 100644
--- a/drivers/char/drm/radeon_drv.c
+++ b/drivers/char/drm/radeon_drv.c
@@ -59,8 +59,7 @@ static struct pci_device_id pciidlist[] = {
 static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG |
-            DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED |
-            DRIVER_IRQ_VBL | DRIVER_IRQ_VBL2,
+            DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED,
         .dev_priv_size = sizeof(drm_radeon_buf_priv_t),
         .load = radeon_driver_load,
         .firstopen = radeon_driver_firstopen,
@@ -69,8 +68,9 @@ static struct drm_driver driver = {
         .postclose = radeon_driver_postclose,
         .lastclose = radeon_driver_lastclose,
         .unload = radeon_driver_unload,
-        .vblank_wait = radeon_driver_vblank_wait,
-        .vblank_wait2 = radeon_driver_vblank_wait2,
+        .get_vblank_counter = radeon_get_vblank_counter,
+        .enable_vblank = radeon_enable_vblank,
+        .disable_vblank = radeon_disable_vblank,
         .dri_library_name = dri_library_name,
         .irq_preinstall = radeon_driver_irq_preinstall,
         .irq_postinstall = radeon_driver_irq_postinstall,
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index 173ae620223a..b791420bd3d9 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -304,6 +304,9 @@ typedef struct drm_radeon_private {
 
         u32 scratch_ages[5];
 
+        unsigned int crtc_last_cnt;
+        unsigned int crtc2_last_cnt;
+
         /* starting from here on, data is preserved accross an open */
         uint32_t flags;         /* see radeon_chip_flags */
         unsigned long fb_aper_offset;
@@ -374,13 +377,13 @@ extern int radeon_irq_emit(struct drm_device *dev, void *data, struct drm_file *
 extern int radeon_irq_wait(struct drm_device *dev, void *data, struct drm_file *file_priv);
 
 extern void radeon_do_release(struct drm_device * dev);
-extern int radeon_driver_vblank_wait(struct drm_device * dev,
-                                     unsigned int *sequence);
-extern int radeon_driver_vblank_wait2(struct drm_device * dev,
-                                      unsigned int *sequence);
+extern u32 radeon_get_vblank_counter(struct drm_device *dev, int crtc);
+extern int radeon_enable_vblank(struct drm_device *dev, int crtc);
+extern void radeon_disable_vblank(struct drm_device *dev, int crtc);
+extern void radeon_do_release(struct drm_device * dev);
 extern irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS);
 extern void radeon_driver_irq_preinstall(struct drm_device * dev);
-extern void radeon_driver_irq_postinstall(struct drm_device * dev);
+extern int radeon_driver_irq_postinstall(struct drm_device * dev);
 extern void radeon_driver_irq_uninstall(struct drm_device * dev);
 extern int radeon_vblank_crtc_get(struct drm_device *dev);
 extern int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value);
@@ -558,6 +561,12 @@ extern int r300_do_cp_cmdbuf(struct drm_device * dev,
                                 ? DRM_READ32( dev_priv->ring_rptr, RADEON_SCRATCHOFF(x) ) \
                                 : RADEON_READ( RADEON_SCRATCH_REG0 + 4*(x) ) )
 
+#define RADEON_CRTC_CRNT_FRAME 0x0214
+#define RADEON_CRTC2_CRNT_FRAME 0x0314
+
+#define RADEON_CRTC_STATUS              0x005c
+#define RADEON_CRTC2_STATUS             0x03fc
+
 #define RADEON_GEN_INT_CNTL             0x0040
 #       define RADEON_CRTC_VBLANK_MASK          (1 << 0)
 #       define RADEON_CRTC2_VBLANK_MASK         (1 << 9)
diff --git a/drivers/char/drm/radeon_irq.c b/drivers/char/drm/radeon_irq.c
index 009af3814b6f..507d6b747a13 100644
--- a/drivers/char/drm/radeon_irq.c
+++ b/drivers/char/drm/radeon_irq.c
@@ -35,12 +35,61 @@
 #include "radeon_drm.h"
 #include "radeon_drv.h"
 
-static __inline__ u32 radeon_acknowledge_irqs(drm_radeon_private_t * dev_priv,
-                                              u32 mask)
+static void radeon_irq_set_state(struct drm_device *dev, u32 mask, int state)
 {
-        u32 irqs = RADEON_READ(RADEON_GEN_INT_STATUS) & mask;
+        drm_radeon_private_t *dev_priv = dev->dev_private;
+
+        if (state)
+                dev_priv->irq_enable_reg |= mask;
+        else
+                dev_priv->irq_enable_reg &= ~mask;
+
+        RADEON_WRITE(RADEON_GEN_INT_CNTL, dev_priv->irq_enable_reg);
+}
+
+int radeon_enable_vblank(struct drm_device *dev, int crtc)
+{
+        switch (crtc) {
+        case 0:
+                radeon_irq_set_state(dev, RADEON_CRTC_VBLANK_MASK, 1);
+                break;
+        case 1:
+                radeon_irq_set_state(dev, RADEON_CRTC2_VBLANK_MASK, 1);
+                break;
+        default:
+                DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
+                          crtc);
+                return EINVAL;
+        }
+
+        return 0;
+}
+
+void radeon_disable_vblank(struct drm_device *dev, int crtc)
+{
+        switch (crtc) {
+        case 0:
+                radeon_irq_set_state(dev, RADEON_CRTC_VBLANK_MASK, 0);
+                break;
+        case 1:
+                radeon_irq_set_state(dev, RADEON_CRTC2_VBLANK_MASK, 0);
+                break;
+        default:
+                DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
+                          crtc);
+                break;
+        }
+}
+
+static __inline__ u32 radeon_acknowledge_irqs(drm_radeon_private_t * dev_priv)
+{
+        u32 irqs = RADEON_READ(RADEON_GEN_INT_STATUS) &
+                (RADEON_SW_INT_TEST | RADEON_CRTC_VBLANK_STAT |
+                 RADEON_CRTC2_VBLANK_STAT);
+
         if (irqs)
                 RADEON_WRITE(RADEON_GEN_INT_STATUS, irqs);
+
         return irqs;
 }
 
@@ -72,39 +121,21 @@ irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS)
         /* Only consider the bits we're interested in - others could be used
          * outside the DRM
          */
-        stat = radeon_acknowledge_irqs(dev_priv, (RADEON_SW_INT_TEST_ACK |
-                                                  RADEON_CRTC_VBLANK_STAT |
-                                                  RADEON_CRTC2_VBLANK_STAT));
+        stat = radeon_acknowledge_irqs(dev_priv);
         if (!stat)
                 return IRQ_NONE;
 
         stat &= dev_priv->irq_enable_reg;
 
         /* SW interrupt */
-        if (stat & RADEON_SW_INT_TEST) {
+        if (stat & RADEON_SW_INT_TEST)
                 DRM_WAKEUP(&dev_priv->swi_queue);
-        }
 
         /* VBLANK interrupt */
-        if (stat & (RADEON_CRTC_VBLANK_STAT|RADEON_CRTC2_VBLANK_STAT)) {
-                int vblank_crtc = dev_priv->vblank_crtc;
-
-                if ((vblank_crtc &
-                     (DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) ==
-                    (DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) {
-                        if (stat & RADEON_CRTC_VBLANK_STAT)
-                                atomic_inc(&dev->vbl_received);
-                        if (stat & RADEON_CRTC2_VBLANK_STAT)
-                                atomic_inc(&dev->vbl_received2);
-                } else if (((stat & RADEON_CRTC_VBLANK_STAT) &&
-                           (vblank_crtc & DRM_RADEON_VBLANK_CRTC1)) ||
-                           ((stat & RADEON_CRTC2_VBLANK_STAT) &&
-                            (vblank_crtc & DRM_RADEON_VBLANK_CRTC2)))
-                        atomic_inc(&dev->vbl_received);
-
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
-        }
+        if (stat & RADEON_CRTC_VBLANK_STAT)
+                drm_handle_vblank(dev, 0);
+        if (stat & RADEON_CRTC2_VBLANK_STAT)
+                drm_handle_vblank(dev, 1);
 
         return IRQ_HANDLED;
 }
@@ -144,54 +175,27 @@ static int radeon_wait_irq(struct drm_device * dev, int swi_nr)
         return ret;
 }
 
-static int radeon_driver_vblank_do_wait(struct drm_device * dev,
-                                        unsigned int *sequence, int crtc)
+u32 radeon_get_vblank_counter(struct drm_device *dev, int crtc)
 {
-        drm_radeon_private_t *dev_priv =
-            (drm_radeon_private_t *) dev->dev_private;
-        unsigned int cur_vblank;
-        int ret = 0;
-        int ack = 0;
-        atomic_t *counter;
+        drm_radeon_private_t *dev_priv = dev->dev_private;
+        u32 crtc_cnt_reg, crtc_status_reg;
+
         if (!dev_priv) {
                 DRM_ERROR("called with no initialization\n");
                 return -EINVAL;
         }
 
-        if (crtc == DRM_RADEON_VBLANK_CRTC1) {
-                counter = &dev->vbl_received;
-                ack |= RADEON_CRTC_VBLANK_STAT;
-        } else if (crtc == DRM_RADEON_VBLANK_CRTC2) {
-                counter = &dev->vbl_received2;
-                ack |= RADEON_CRTC2_VBLANK_STAT;
-        } else
+        if (crtc == 0) {
+                crtc_cnt_reg = RADEON_CRTC_CRNT_FRAME;
+                crtc_status_reg = RADEON_CRTC_STATUS;
+        } else if (crtc == 1) {
+                crtc_cnt_reg = RADEON_CRTC2_CRNT_FRAME;
+                crtc_status_reg = RADEON_CRTC2_STATUS;
+        } else {
                 return -EINVAL;
+        }
 
-        radeon_acknowledge_irqs(dev_priv, ack);
-
-        dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
-
-        /* Assume that the user has missed the current sequence number
-         * by about a day rather than she wants to wait for years
-         * using vertical blanks...
-         */
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(counter))
-                      - *sequence) <= (1 << 23)));
-
-        *sequence = cur_vblank;
-
-        return ret;
-}
-
-int radeon_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
-{
-        return radeon_driver_vblank_do_wait(dev, sequence, DRM_RADEON_VBLANK_CRTC1);
-}
-
-int radeon_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
-{
-        return radeon_driver_vblank_do_wait(dev, sequence, DRM_RADEON_VBLANK_CRTC2);
+        return RADEON_READ(crtc_cnt_reg) + (RADEON_READ(crtc_status_reg) & 1);
 }
 
 /* Needs the lock as it touches the ring.
@@ -234,21 +238,6 @@ int radeon_irq_wait(struct drm_device *dev, void *data, struct drm_file *file_pr
         return radeon_wait_irq(dev, irqwait->irq_seq);
 }
 
-static void radeon_enable_interrupt(struct drm_device *dev)
-{
-        drm_radeon_private_t *dev_priv = (drm_radeon_private_t *) dev->dev_private;
-
-        dev_priv->irq_enable_reg = RADEON_SW_INT_ENABLE;
-        if (dev_priv->vblank_crtc & DRM_RADEON_VBLANK_CRTC1)
-                dev_priv->irq_enable_reg |= RADEON_CRTC_VBLANK_MASK;
-
-        if (dev_priv->vblank_crtc & DRM_RADEON_VBLANK_CRTC2)
-                dev_priv->irq_enable_reg |= RADEON_CRTC2_VBLANK_MASK;
-
-        RADEON_WRITE(RADEON_GEN_INT_CNTL, dev_priv->irq_enable_reg);
-        dev_priv->irq_enabled = 1;
-}
-
 /* drm_dma.h hooks
 */
 void radeon_driver_irq_preinstall(struct drm_device * dev)
@@ -260,20 +249,27 @@ void radeon_driver_irq_preinstall(struct drm_device * dev)
         RADEON_WRITE(RADEON_GEN_INT_CNTL, 0);
 
         /* Clear bits if they're already high */
-        radeon_acknowledge_irqs(dev_priv, (RADEON_SW_INT_TEST_ACK |
-                                           RADEON_CRTC_VBLANK_STAT |
-                                           RADEON_CRTC2_VBLANK_STAT));
+        radeon_acknowledge_irqs(dev_priv);
 }
 
-void radeon_driver_irq_postinstall(struct drm_device * dev)
+int radeon_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
+        int ret;
 
         atomic_set(&dev_priv->swi_emitted, 0);
         DRM_INIT_WAITQUEUE(&dev_priv->swi_queue);
 
-        radeon_enable_interrupt(dev);
+        ret = drm_vblank_init(dev, 2);
+        if (ret)
+                return ret;
+
+        dev->max_vblank_count = 0x001fffff;
+
+        radeon_irq_set_state(dev, RADEON_SW_INT_ENABLE, 1);
+
+        return 0;
 }
 
 void radeon_driver_irq_uninstall(struct drm_device * dev)
@@ -315,6 +311,5 @@ int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value)
                 return -EINVAL;
         }
         dev_priv->vblank_crtc = (unsigned int)value;
-        radeon_enable_interrupt(dev);
         return 0;
 }
diff --git a/drivers/char/drm/via_drv.c b/drivers/char/drm/via_drv.c
index 80c01cdfa37d..37870a4a3dc7 100644
--- a/drivers/char/drm/via_drv.c
+++ b/drivers/char/drm/via_drv.c
@@ -40,11 +40,13 @@ static struct pci_device_id pciidlist[] = {
 static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ |
-            DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
+            DRIVER_IRQ_SHARED,
         .load = via_driver_load,
         .unload = via_driver_unload,
         .context_dtor = via_final_context,
-        .vblank_wait = via_driver_vblank_wait,
+        .get_vblank_counter = via_get_vblank_counter,
+        .enable_vblank = via_enable_vblank,
+        .disable_vblank = via_disable_vblank,
         .irq_preinstall = via_driver_irq_preinstall,
         .irq_postinstall = via_driver_irq_postinstall,
         .irq_uninstall = via_driver_irq_uninstall,
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index 2daae81874cd..fe67030e39ac 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -75,6 +75,7 @@ typedef struct drm_via_private {
         struct timeval last_vblank;
         int last_vblank_valid;
         unsigned usec_per_vblank;
+        atomic_t vbl_received;
         drm_via_state_t hc_state;
         char pci_buf[VIA_PCI_BUF_SIZE];
         const uint32_t *fire_offsets[VIA_FIRE_BUF_SIZE];
@@ -130,11 +131,13 @@ extern int via_init_context(struct drm_device * dev, int context);
 extern int via_final_context(struct drm_device * dev, int context);
 
 extern int via_do_cleanup_map(struct drm_device * dev);
-extern int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
+extern u32 via_get_vblank_counter(struct drm_device *dev, int crtc);
+extern int via_enable_vblank(struct drm_device *dev, int crtc);
+extern void via_disable_vblank(struct drm_device *dev, int crtc);
 
 extern irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS);
 extern void via_driver_irq_preinstall(struct drm_device * dev);
-extern void via_driver_irq_postinstall(struct drm_device * dev);
+extern int via_driver_irq_postinstall(struct drm_device * dev);
 extern void via_driver_irq_uninstall(struct drm_device * dev);
 
 extern int via_dma_cleanup(struct drm_device * dev);
diff --git a/drivers/char/drm/via_irq.c b/drivers/char/drm/via_irq.c
index c6bb978a1106..f1ab6fc7c07e 100644
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -92,8 +92,17 @@ static int via_irqmap_unichrome[] = {-1, -1, -1, 0, -1, 1};
 static unsigned time_diff(struct timeval *now, struct timeval *then)
 {
         return (now->tv_usec >= then->tv_usec) ?
-            now->tv_usec - then->tv_usec :
-            1000000 - (then->tv_usec - now->tv_usec);
+                now->tv_usec - then->tv_usec :
+                1000000 - (then->tv_usec - now->tv_usec);
+}
+
+u32 via_get_vblank_counter(struct drm_device *dev, int crtc)
+{
+        drm_via_private_t *dev_priv = dev->dev_private;
+        if (crtc != 0)
+                return 0;
+
+        return atomic_read(&dev_priv->vbl_received);
 }
 
 irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
@@ -108,8 +117,8 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
 
         status = VIA_READ(VIA_REG_INTERRUPT);
         if (status & VIA_IRQ_VBLANK_PENDING) {
-                atomic_inc(&dev->vbl_received);
-                if (!(atomic_read(&dev->vbl_received) & 0x0F)) {
+                atomic_inc(&dev_priv->vbl_received);
+                if (!(atomic_read(&dev_priv->vbl_received) & 0x0F)) {
                         do_gettimeofday(&cur_vblank);
                         if (dev_priv->last_vblank_valid) {
                                 dev_priv->usec_per_vblank =
@@ -119,12 +128,11 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
                         dev_priv->last_vblank = cur_vblank;
                         dev_priv->last_vblank_valid = 1;
                 }
-                if (!(atomic_read(&dev->vbl_received) & 0xFF)) {
+                if (!(atomic_read(&dev_priv->vbl_received) & 0xFF)) {
                         DRM_DEBUG("US per vblank is: %u\n",
                                   dev_priv->usec_per_vblank);
                 }
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
+                drm_handle_vblank(dev, 0);
                 handled = 1;
         }
 
@@ -163,31 +171,34 @@ static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
         }
 }
 
-int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
+int via_enable_vblank(struct drm_device *dev, int crtc)
 {
-        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
-        unsigned int cur_vblank;
-        int ret = 0;
+        drm_via_private_t *dev_priv = dev->dev_private;
+        u32 status;
 
-        DRM_DEBUG("\n");
-        if (!dev_priv) {
-                DRM_ERROR("called with no initialization\n");
+        if (crtc != 0) {
+                DRM_ERROR("%s:  bad crtc %d\n", __FUNCTION__, crtc);
                 return -EINVAL;
         }
 
-        viadrv_acknowledge_irqs(dev_priv);
+        status = VIA_READ(VIA_REG_INTERRUPT);
+        VIA_WRITE(VIA_REG_INTERRUPT, status & VIA_IRQ_VBLANK_ENABLE);
 
-        /* Assume that the user has missed the current sequence number
-         * by about a day rather than she wants to wait for years
-         * using vertical blanks...
-         */
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
 
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received)) -
-                      *sequence) <= (1 << 23)));
+        return 0;
+}
 
-        *sequence = cur_vblank;
-        return ret;
+void via_disable_vblank(struct drm_device *dev, int crtc)
+{
+        drm_via_private_t *dev_priv = dev->dev_private;
+
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) & ~0x30);
+
+        if (crtc != 0)
+                DRM_ERROR("%s:  bad crtc %d\n", __FUNCTION__, crtc);
 }
 
 static int
@@ -292,23 +303,25 @@ void via_driver_irq_preinstall(struct drm_device * dev)
         }
 }
 
-void via_driver_irq_postinstall(struct drm_device * dev)
+int via_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
 
-        DRM_DEBUG("\n");
-        if (dev_priv) {
-                status = VIA_READ(VIA_REG_INTERRUPT);
-                VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL
-                          | dev_priv->irq_enable_mask);
+        DRM_DEBUG("via_driver_irq_postinstall\n");
+        if (!dev_priv)
+                return -EINVAL;
 
-                /* Some magic, oh for some data sheets ! */
+        drm_vblank_init(dev, 1);
+        status = VIA_READ(VIA_REG_INTERRUPT);
+        VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL
+                  | dev_priv->irq_enable_mask);
 
-                VIA_WRITE8(0x83d4, 0x11);
-                VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
+        /* Some magic, oh for some data sheets ! */
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
 
-        }
+        return 0;
 }
 
 void via_driver_irq_uninstall(struct drm_device * dev)
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 87532034d105..3f9e10001e19 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -1031,7 +1031,7 @@ comment "Other IDE chipsets support"
 comment "Note: most of these also require special kernel boot parameters"
 
 config BLK_DEV_4DRIVES
-        bool "Generic 4 drives/port support"
+        tristate "Generic 4 drives/port support"
         help
           Certain older chipsets, including the Tekram 690CD, use a single set
           of I/O ports at 0x1f0 to control up to four drives, instead of the
diff --git a/drivers/ide/arm/bast-ide.c b/drivers/ide/arm/bast-ide.c
index ec46c44b061c..713cef20622e 100644
--- a/drivers/ide/arm/bast-ide.c
+++ b/drivers/ide/arm/bast-ide.c
@@ -21,6 +21,8 @@
 #include <asm/arch/bast-map.h>
 #include <asm/arch/bast-irq.h>
 
+#define DRV_NAME "bast-ide"
+
 static int __init bastide_register(unsigned int base, unsigned int aux, int irq)
 {
         ide_hwif_t *hwif;
@@ -33,27 +35,23 @@ static int __init bastide_register(unsigned int base, unsigned int aux, int irq)
         base += BAST_IDE_CS;
         aux  += BAST_IDE_CS;
 
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
-                hw.io_ports[i] = (unsigned long)base;
+        for (i = 0; i <= 7; i++) {
+                hw.io_ports_array[i] = (unsigned long)base;
                 base += 0x20;
         }
 
-        hw.io_ports[IDE_CONTROL_OFFSET] = aux + (6 * 0x20);
+        hw.io_ports.ctl_addr = aux + (6 * 0x20);
         hw.irq = irq;
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif == NULL)
                 goto out;
 
         i = hwif->index;
 
-        if (hwif->present)
-                ide_unregister(i);
-        else
-                ide_init_port_data(hwif, i);
-
+        ide_init_port_data(hwif, i);
         ide_init_port_hw(hwif, &hw);
-        hwif->quirkproc = NULL;
+        hwif->port_ops = NULL;
 
         idx[0] = i;
 
@@ -64,6 +62,8 @@ out:
 
 static int __init bastide_init(void)
 {
+        unsigned long base = BAST_VA_IDEPRI + BAST_IDE_CS;
+
         /* we can treat the VR1000 and the BAST the same */
 
         if (!(machine_is_bast() || machine_is_vr1000()))
@@ -71,6 +71,11 @@ static int __init bastide_init(void)
 
         printk("BAST: IDE driver, (c) 2003-2004 Simtec Electronics\n");
 
+        if (!request_mem_region(base, 0x400000, DRV_NAME)) {
+                printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
+                return -EBUSY;
+        }
+
         bastide_register(BAST_VA_IDEPRI, BAST_VA_IDEPRIAUX, IRQ_IDE0);
         bastide_register(BAST_VA_IDESEC, BAST_VA_IDESECAUX, IRQ_IDE1);
 
diff --git a/drivers/ide/arm/icside.c b/drivers/ide/arm/icside.c
index e816b0ffcfe6..124445c20921 100644
--- a/drivers/ide/arm/icside.c
+++ b/drivers/ide/arm/icside.c
@@ -191,6 +191,10 @@ static void icside_maskproc(ide_drive_t *drive, int mask)
         local_irq_restore(flags);
 }
 
+static const struct ide_port_ops icside_v6_no_dma_port_ops = {
+        .maskproc               = icside_maskproc,
+};
+
 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
 /*
  * SG-DMA support.
@@ -266,6 +270,11 @@ static void icside_set_dma_mode(ide_drive_t *drive, const u8 xfer_mode)
                 ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
 }
 
+static const struct ide_port_ops icside_v6_port_ops = {
+        .set_dma_mode           = icside_set_dma_mode,
+        .maskproc               = icside_maskproc,
+};
+
 static void icside_dma_host_set(ide_drive_t *drive, int on)
 {
 }
@@ -375,32 +384,40 @@ static void icside_dma_lost_irq(ide_drive_t *drive)
         printk(KERN_ERR "%s: IRQ lost\n", drive->name);
 }
 
-static void icside_dma_init(ide_hwif_t *hwif)
+static int icside_dma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
         hwif->dmatable_cpu      = NULL;
         hwif->dmatable_dma      = 0;
-        hwif->set_dma_mode      = icside_set_dma_mode;
-
-        hwif->dma_host_set      = icside_dma_host_set;
-        hwif->dma_setup         = icside_dma_setup;
-        hwif->dma_exec_cmd      = icside_dma_exec_cmd;
-        hwif->dma_start         = icside_dma_start;
-        hwif->ide_dma_end       = icside_dma_end;
-        hwif->ide_dma_test_irq  = icside_dma_test_irq;
-        hwif->dma_timeout       = icside_dma_timeout;
-        hwif->dma_lost_irq      = icside_dma_lost_irq;
+
+        return 0;
 }
+
+static const struct ide_dma_ops icside_v6_dma_ops = {
+        .dma_host_set           = icside_dma_host_set,
+        .dma_setup              = icside_dma_setup,
+        .dma_exec_cmd           = icside_dma_exec_cmd,
+        .dma_start              = icside_dma_start,
+        .dma_end                = icside_dma_end,
+        .dma_test_irq           = icside_dma_test_irq,
+        .dma_timeout            = icside_dma_timeout,
+        .dma_lost_irq           = icside_dma_lost_irq,
+};
 #else
-#define icside_dma_init(hwif)   (0)
+#define icside_v6_dma_ops NULL
 #endif
 
+static int icside_dma_off_init(ide_hwif_t *hwif, const struct ide_port_info *d)
+{
+        return -EOPNOTSUPP;
+}
+
 static ide_hwif_t *
 icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *ec)
 {
         unsigned long port = (unsigned long)base + info->dataoffset;
         ide_hwif_t *hwif;
 
-        hwif = ide_find_port(port);
+        hwif = ide_find_port();
         if (hwif) {
                 int i;
 
@@ -408,15 +425,14 @@ icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *e
                  * Ensure we're using MMIO
                  */
                 default_hwif_mmiops(hwif);
-                hwif->mmio = 1;
 
-                for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
-                        hwif->io_ports[i] = port;
+                for (i = 0; i <= 7; i++) {
+                        hwif->io_ports_array[i] = port;
                         port += 1 << info->stepping;
                 }
-                hwif->io_ports[IDE_CONTROL_OFFSET] = (unsigned long)base + info->ctrloffset;
+                hwif->io_ports.ctl_addr =
+                        (unsigned long)base + info->ctrloffset;
                 hwif->irq     = ec->irq;
-                hwif->noprobe = 0;
                 hwif->chipset = ide_acorn;
                 hwif->gendev.parent = &ec->dev;
                 hwif->dev = &ec->dev;
@@ -462,9 +478,10 @@ icside_register_v5(struct icside_state *state, struct expansion_card *ec)
 }
 
 static const struct ide_port_info icside_v6_port_info __initdata = {
-        .host_flags             = IDE_HFLAG_SERIALIZE |
-                                  IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
-                                  IDE_HFLAG_NO_AUTOTUNE,
+        .init_dma               = icside_dma_off_init,
+        .port_ops               = &icside_v6_no_dma_port_ops,
+        .dma_ops                = &icside_v6_dma_ops,
+        .host_flags             = IDE_HFLAG_SERIALIZE,
         .mwdma_mask             = ATA_MWDMA2,
         .swdma_mask             = ATA_SWDMA2,
 };
@@ -526,21 +543,19 @@ icside_register_v6(struct icside_state *state, struct expansion_card *ec)
         state->hwif[0]    = hwif;
         state->hwif[1]    = mate;
 
-        hwif->maskproc    = icside_maskproc;
         hwif->hwif_data   = state;
         hwif->config_data = (unsigned long)ioc_base;
         hwif->select_data = sel;
 
-        mate->maskproc    = icside_maskproc;
         mate->hwif_data   = state;
         mate->config_data = (unsigned long)ioc_base;
         mate->select_data = sel | 1;
 
         if (ec->dma != NO_DMA && !request_dma(ec->dma, hwif->name)) {
-                icside_dma_init(hwif);
-                icside_dma_init(mate);
-        } else
-                d.mwdma_mask = d.swdma_mask = 0;
+                d.init_dma = icside_dma_init;
+                d.port_ops = &icside_v6_port_ops;
+                d.dma_ops = NULL;
+        }
 
         idx[0] = hwif->index;
         idx[1] = mate->index;
diff --git a/drivers/ide/arm/ide_arm.c b/drivers/ide/arm/ide_arm.c
index be9ff7334c52..4263ffd4ab20 100644
--- a/drivers/ide/arm/ide_arm.c
+++ b/drivers/ide/arm/ide_arm.c
@@ -14,6 +14,8 @@
 #include <asm/mach-types.h>
 #include <asm/irq.h>
 
+#define DRV_NAME "ide_arm"
+
 #ifdef CONFIG_ARCH_CLPS7500
 # include <asm/arch/hardware.h>
 #
@@ -28,13 +30,27 @@ static int __init ide_arm_init(void)
 {
         ide_hwif_t *hwif;
         hw_regs_t hw;
+        unsigned long base = IDE_ARM_IO, ctl = IDE_ARM_IO + 0x206;
         u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
 
+        if (!request_region(base, 8, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                DRV_NAME, base, base + 7);
+                return -EBUSY;
+        }
+
+        if (!request_region(ctl, 1, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                DRV_NAME, ctl);
+                release_region(base, 8);
+                return -EBUSY;
+        }
+
         memset(&hw, 0, sizeof(hw));
-        ide_std_init_ports(&hw, IDE_ARM_IO, IDE_ARM_IO + 0x206);
+        ide_std_init_ports(&hw, base, ctl);
         hw.irq = IDE_ARM_IRQ;
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif) {
                 ide_init_port_hw(hwif, &hw);
                 idx[0] = hwif->index;
diff --git a/drivers/ide/arm/palm_bk3710.c b/drivers/ide/arm/palm_bk3710.c
index 420fcb78a7cd..aaf32541622d 100644
--- a/drivers/ide/arm/palm_bk3710.c
+++ b/drivers/ide/arm/palm_bk3710.c
@@ -96,11 +96,11 @@ static void palm_bk3710_setudmamode(void __iomem *base, unsigned int dev,
         u16 val16;
 
         /* DMA Data Setup */
-        t0 = (palm_bk3710_udmatimings[mode].cycletime + ide_palm_clk - 1)
-                        / ide_palm_clk - 1;
-        tenv = (20 + ide_palm_clk - 1) / ide_palm_clk - 1;
-        trp = (palm_bk3710_udmatimings[mode].rptime + ide_palm_clk - 1)
-                        / ide_palm_clk - 1;
+        t0 = DIV_ROUND_UP(palm_bk3710_udmatimings[mode].cycletime,
+                          ide_palm_clk) - 1;
+        tenv = DIV_ROUND_UP(20, ide_palm_clk) - 1;
+        trp = DIV_ROUND_UP(palm_bk3710_udmatimings[mode].rptime,
+                           ide_palm_clk) - 1;
 
         /* udmatim Register */
         val16 = readw(base + BK3710_UDMATIM) & (dev ? 0xFF0F : 0xFFF0);
@@ -141,8 +141,8 @@ static void palm_bk3710_setdmamode(void __iomem *base, unsigned int dev,
         cycletime = max_t(int, t->cycle, min_cycle);
 
         /* DMA Data Setup */
-        t0 = (cycletime + ide_palm_clk - 1) / ide_palm_clk;
-        td = (t->active + ide_palm_clk - 1) / ide_palm_clk;
+        t0 = DIV_ROUND_UP(cycletime, ide_palm_clk);
+        td = DIV_ROUND_UP(t->active, ide_palm_clk);
         tkw = t0 - td - 1;
         td -= 1;
 
@@ -168,9 +168,9 @@ static void palm_bk3710_setpiomode(void __iomem *base, ide_drive_t *mate,
         struct ide_timing *t;
 
         /* PIO Data Setup */
-        t0 = (cycletime + ide_palm_clk - 1) / ide_palm_clk;
-        t2 = (ide_timing_find_mode(XFER_PIO_0 + mode)->active +
-              ide_palm_clk - 1) / ide_palm_clk;
+        t0 = DIV_ROUND_UP(cycletime, ide_palm_clk);
+        t2 = DIV_ROUND_UP(ide_timing_find_mode(XFER_PIO_0 + mode)->active,
+                          ide_palm_clk);
 
         t2i = t0 - t2 - 1;
         t2 -= 1;
@@ -192,8 +192,8 @@ static void palm_bk3710_setpiomode(void __iomem *base, ide_drive_t *mate,
 
         /* TASKFILE Setup */
         t = ide_timing_find_mode(XFER_PIO_0 + mode);
-        t0 = (t->cyc8b + ide_palm_clk - 1) / ide_palm_clk;
-        t2 = (t->act8b + ide_palm_clk - 1) / ide_palm_clk;
+        t0 = DIV_ROUND_UP(t->cyc8b, ide_palm_clk);
+        t2 = DIV_ROUND_UP(t->act8b, ide_palm_clk);
 
         t2i = t0 - t2 - 1;
         t2 -= 1;
@@ -317,17 +317,31 @@ static u8 __devinit palm_bk3710_cable_detect(ide_hwif_t *hwif)
         return ATA_CBL_PATA80;
 }
 
-static void __devinit palm_bk3710_init_hwif(ide_hwif_t *hwif)
+static int __devinit palm_bk3710_init_dma(ide_hwif_t *hwif,
+                                          const struct ide_port_info *d)
 {
-        hwif->set_pio_mode = palm_bk3710_set_pio_mode;
-        hwif->set_dma_mode = palm_bk3710_set_dma_mode;
+        unsigned long base =
+                hwif->io_ports.data_addr - IDE_PALM_ATA_PRI_REG_OFFSET;
 
-        hwif->cable_detect = palm_bk3710_cable_detect;
+        printk(KERN_INFO "    %s: MMIO-DMA\n", hwif->name);
+
+        if (ide_allocate_dma_engine(hwif))
+                return -1;
+
+        ide_setup_dma(hwif, base);
+
+        return 0;
 }
 
+static const struct ide_port_ops palm_bk3710_ports_ops = {
+        .set_pio_mode           = palm_bk3710_set_pio_mode,
+        .set_dma_mode           = palm_bk3710_set_dma_mode,
+        .cable_detect           = palm_bk3710_cable_detect,
+};
+
 static const struct ide_port_info __devinitdata palm_bk3710_port_info = {
-        .init_hwif              = palm_bk3710_init_hwif,
-        .host_flags             = IDE_HFLAG_NO_DMA, /* hack (no PCI) */
+        .init_dma               = palm_bk3710_init_dma,
+        .port_ops               = &palm_bk3710_ports_ops,
         .pio_mask               = ATA_PIO4,
         .udma_mask              = ATA_UDMA4,    /* (input clk 99MHz) */
         .mwdma_mask             = ATA_MWDMA2,
@@ -372,30 +386,24 @@ static int __devinit palm_bk3710_probe(struct platform_device *pdev)
 
         pribase = mem->start + IDE_PALM_ATA_PRI_REG_OFFSET;
         for (i = 0; i < IDE_NR_PORTS - 2; i++)
-                hw.io_ports[i] = pribase + i;
-        hw.io_ports[IDE_CONTROL_OFFSET] = mem->start +
+                hw.io_ports_array[i] = pribase + i;
+        hw.io_ports.ctl_addr = mem->start +
                         IDE_PALM_ATA_PRI_CTL_OFFSET;
         hw.irq = irq->start;
         hw.chipset = ide_palm3710;
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif == NULL)
                 goto out;
 
         i = hwif->index;
 
-        if (hwif->present)
-                ide_unregister(i);
-        else
-                ide_init_port_data(hwif, i);
-
+        ide_init_port_data(hwif, i);
         ide_init_port_hw(hwif, &hw);
 
         hwif->mmio = 1;
         default_hwif_mmiops(hwif);
 
-        ide_setup_dma(hwif, mem->start);
-
         idx[0] = i;
 
         ide_device_add(idx, &palm_bk3710_port_info);
diff --git a/drivers/ide/arm/rapide.c b/drivers/ide/arm/rapide.c
index b30adcf321c3..babc1a5e128d 100644
--- a/drivers/ide/arm/rapide.c
+++ b/drivers/ide/arm/rapide.c
@@ -17,11 +17,11 @@ static void rapide_setup_ports(hw_regs_t *hw, void __iomem *base,
         unsigned long port = (unsigned long)base;
         int i;
 
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
-                hw->io_ports[i] = port;
+        for (i = 0; i <= 7; i++) {
+                hw->io_ports_array[i] = port;
                 port += sz;
         }
-        hw->io_ports[IDE_CONTROL_OFFSET] = (unsigned long)ctrl;
+        hw->io_ports.ctl_addr = (unsigned long)ctrl;
         hw->irq = irq;
 }
 
@@ -44,7 +44,7 @@ rapide_probe(struct expansion_card *ec, const struct ecard_id *id)
                 goto release;
         }
 
-        hwif = ide_find_port((unsigned long)base);
+        hwif = ide_find_port();
         if (hwif) {
                 memset(&hw, 0, sizeof(hw));
                 rapide_setup_ports(&hw, base, base + 0x818, 1 << 6, ec->irq);
@@ -53,7 +53,6 @@ rapide_probe(struct expansion_card *ec, const struct ecard_id *id)
 
                 ide_init_port_hw(hwif, &hw);
 
-                hwif->mmio = 1;
                 default_hwif_mmiops(hwif);
 
                 idx[0] = hwif->index;
@@ -76,7 +75,7 @@ static void __devexit rapide_remove(struct expansion_card *ec)
 
         ecard_set_drvdata(ec, NULL);
 
-        ide_unregister(hwif->index);
+        ide_unregister(hwif);
 
         ecard_release_resources(ec);
 }
diff --git a/drivers/ide/cris/ide-cris.c b/drivers/ide/cris/ide-cris.c
index 31266d278095..9df26855bc05 100644
--- a/drivers/ide/cris/ide-cris.c
+++ b/drivers/ide/cris/ide-cris.c
@@ -88,8 +88,8 @@ enum /* Transfer types */
 int
 cris_ide_ack_intr(ide_hwif_t* hwif)
 {
-        reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2,
-                                 int, hwif->io_ports[0]);
+        reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2, int,
+                                               hwif->io_ports.data_addr);
         REG_WR_INT(ata, regi_ata, rw_ack_intr, 1 << ctrl2.sel);
         return 1;
 }
@@ -231,7 +231,7 @@ cris_ide_start_dma(ide_drive_t *drive, cris_dma_descr_type *d, int dir,int type,
         ide_hwif_t *hwif = drive->hwif;
 
         reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2, int,
-                                               hwif->io_ports[IDE_DATA_OFFSET]);
+                                               hwif->io_ports.data_addr);
         reg_ata_rw_trf_cnt trf_cnt = {0};
 
         mycontext.saved_data = (dma_descr_data*)virt_to_phys(d);
@@ -271,7 +271,7 @@ static int cris_dma_test_irq(ide_drive_t *drive)
         int intr = REG_RD_INT(ata, regi_ata, r_intr);
 
         reg_ata_rw_ctrl2 ctrl2 = REG_TYPE_CONV(reg_ata_rw_ctrl2, int,
-                                               hwif->io_ports[IDE_DATA_OFFSET]);
+                                               hwif->io_ports.data_addr);
 
         return intr & (1 << ctrl2.sel) ? 1 : 0;
 }
@@ -531,7 +531,7 @@ static void cris_ide_start_dma(ide_drive_t *drive, cris_dma_descr_type *d, int d
         *R_ATA_CTRL_DATA =
                 cmd |
                 IO_FIELD(R_ATA_CTRL_DATA, data,
-                         drive->hwif->io_ports[IDE_DATA_OFFSET]) |
+                         drive->hwif->io_ports.data_addr) |
                 IO_STATE(R_ATA_CTRL_DATA, src_dst,  dma)  |
                 IO_STATE(R_ATA_CTRL_DATA, multi,    on)   |
                 IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
@@ -550,7 +550,7 @@ static int cris_dma_test_irq(ide_drive_t *drive)
 {
         int intr = *R_IRQ_MASK0_RD;
         int bus = IO_EXTRACT(R_ATA_CTRL_DATA, sel,
-                             drive->hwif->io_ports[IDE_DATA_OFFSET]);
+                             drive->hwif->io_ports.data_addr);
 
         return intr & (1 << (bus + IO_BITNR(R_IRQ_MASK0_RD, ata_irq0))) ? 1 : 0;
 }
@@ -644,7 +644,7 @@ cris_ide_inw(unsigned long reg) {
                  * call will also timeout on busy, but as long as the
                  * write is still performed, everything will be fine.
                  */
-                if (cris_ide_get_reg(reg) == IDE_STATUS_OFFSET)
+                if (cris_ide_get_reg(reg) == 7)
                         return BUSY_STAT;
                 else
                         /* For other rare cases we assume 0 is good enough.  */
@@ -673,11 +673,6 @@ cris_ide_inb(unsigned long reg)
         return (unsigned char)cris_ide_inw(reg);
 }
 
-static int cris_dma_end (ide_drive_t *drive);
-static int cris_dma_setup (ide_drive_t *drive);
-static void cris_dma_exec_cmd (ide_drive_t *drive, u8 command);
-static int cris_dma_test_irq(ide_drive_t *drive);
-static void cris_dma_start(ide_drive_t *drive);
 static void cris_ide_input_data (ide_drive_t *drive, void *, unsigned int);
 static void cris_ide_output_data (ide_drive_t *drive, void *, unsigned int);
 static void cris_atapi_input_bytes(ide_drive_t *drive, void *, unsigned int);
@@ -770,20 +765,29 @@ static void __init cris_setup_ports(hw_regs_t *hw, unsigned long base)
         memset(hw, 0, sizeof(*hw));
 
         for (i = 0; i <= 7; i++)
-                hw->io_ports[i] = base + cris_ide_reg_addr(i, 0, 1);
+                hw->io_ports_array[i] = base + cris_ide_reg_addr(i, 0, 1);
 
         /*
          * the IDE control register is at ATA address 6,
          * with CS1 active instead of CS0
          */
-        hw->io_ports[IDE_CONTROL_OFFSET] = base + cris_ide_reg_addr(6, 1, 0);
+        hw->io_ports.ctl_addr = base + cris_ide_reg_addr(6, 1, 0);
 
         hw->irq = ide_default_irq(0);
         hw->ack_intr = cris_ide_ack_intr;
 }
 
+static const struct ide_port_ops cris_port_ops = {
+        .set_pio_mode           = cris_set_pio_mode,
+        .set_dma_mode           = cris_set_dma_mode,
+};
+
+static const struct ide_dma_ops cris_dma_ops;
+
 static const struct ide_port_info cris_port_info __initdata = {
         .chipset                = ide_etrax100,
+        .port_ops               = &cris_port_ops,
+        .dma_ops                = &cris_dma_ops,
         .host_flags             = IDE_HFLAG_NO_ATAPI_DMA |
                                   IDE_HFLAG_NO_DMA, /* no SFF-style DMA */
         .pio_mask               = ATA_PIO4,
@@ -804,24 +808,16 @@ static int __init init_e100_ide(void)
 
                 cris_setup_ports(&hw, cris_ide_base_address(h));
 
-                hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+                hwif = ide_find_port();
                 if (hwif == NULL)
                         continue;
                 ide_init_port_data(hwif, hwif->index);
                 ide_init_port_hw(hwif, &hw);
-                hwif->mmio = 1;
-                hwif->set_pio_mode = &cris_set_pio_mode;
-                hwif->set_dma_mode = &cris_set_dma_mode;
+
                 hwif->ata_input_data = &cris_ide_input_data;
                 hwif->ata_output_data = &cris_ide_output_data;
                 hwif->atapi_input_bytes = &cris_atapi_input_bytes;
                 hwif->atapi_output_bytes = &cris_atapi_output_bytes;
-                hwif->dma_host_set = &cris_dma_host_set;
-                hwif->ide_dma_end = &cris_dma_end;
-                hwif->dma_setup = &cris_dma_setup;
-                hwif->dma_exec_cmd = &cris_dma_exec_cmd;
-                hwif->ide_dma_test_irq = &cris_dma_test_irq;
-                hwif->dma_start = &cris_dma_start;
                 hwif->OUTB = &cris_ide_outb;
                 hwif->OUTW = &cris_ide_outw;
                 hwif->OUTBSYNC = &cris_ide_outbsync;
@@ -1076,6 +1072,15 @@ static void cris_dma_start(ide_drive_t *drive)
         }
 }
 
+static const struct ide_dma_ops cris_dma_ops = {
+        .dma_host_set           = cris_dma_host_set,
+        .dma_setup              = cris_dma_setup,
+        .dma_exec_cmd           = cris_dma_exec_cmd,
+        .dma_start              = cris_dma_start,
+        .dma_end                = cris_dma_end,
+        .dma_test_irq           = cris_dma_test_irq,
+};
+
 module_init(init_e100_ide);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/ide/h8300/ide-h8300.c b/drivers/ide/h8300/ide-h8300.c
index 4108ec4ffa7f..fd23f12e17aa 100644
--- a/drivers/ide/h8300/ide-h8300.c
+++ b/drivers/ide/h8300/ide-h8300.c
@@ -63,9 +63,9 @@ static inline void hw_setup(hw_regs_t *hw)
         int i;
 
         memset(hw, 0, sizeof(hw_regs_t));
-        for (i = 0; i <= IDE_STATUS_OFFSET; i++)
-                hw->io_ports[i] = CONFIG_H8300_IDE_BASE + H8300_IDE_GAP*i;
-        hw->io_ports[IDE_CONTROL_OFFSET] = CONFIG_H8300_IDE_ALT;
+        for (i = 0; i <= 7; i++)
+                hw->io_ports_array[i] = CONFIG_H8300_IDE_BASE + H8300_IDE_GAP*i;
+        hw->io_ports.ctl_addr = CONFIG_H8300_IDE_ALT;
         hw->irq = EXT_IRQ0 + CONFIG_H8300_IDE_IRQ;
         hw->chipset = ide_generic;
 }
@@ -74,7 +74,6 @@ static inline void hwif_setup(ide_hwif_t *hwif)
 {
         default_hwif_iops(hwif);
 
-        hwif->mmio  = 1;
         hwif->OUTW  = mm_outw;
         hwif->OUTSW = mm_outsw;
         hwif->INW   = mm_inw;
@@ -99,8 +98,7 @@ static int __init h8300_ide_init(void)
 
         hw_setup(&hw);
 
-        /* register if */
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif == NULL) {
                 printk(KERN_ERR "ide-h8300: IDE I/F register failed\n");
                 return -ENOENT;
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index 0f6fb6b72dd9..9d3601fa5680 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -55,14 +55,22 @@ struct ide_acpi_hwif_link {
 /* note: adds function name and KERN_DEBUG */
 #ifdef DEBUGGING
 #define DEBPRINT(fmt, args...)  \
-                printk(KERN_DEBUG "%s: " fmt, __FUNCTION__, ## args)
+                printk(KERN_DEBUG "%s: " fmt, __func__, ## args)
 #else
 #define DEBPRINT(fmt, args...)  do {} while (0)
 #endif  /* DEBUGGING */
 
-extern int ide_noacpi;
-extern int ide_noacpitfs;
-extern int ide_noacpionboot;
+int ide_noacpi;
+module_param_named(noacpi, ide_noacpi, bool, 0);
+MODULE_PARM_DESC(noacpi, "disable IDE ACPI support");
+
+int ide_acpigtf;
+module_param_named(acpigtf, ide_acpigtf, bool, 0);
+MODULE_PARM_DESC(acpigtf, "enable IDE ACPI _GTF support");
+
+int ide_acpionboot;
+module_param_named(acpionboot, ide_acpionboot, bool, 0);
+MODULE_PARM_DESC(acpionboot, "call IDE ACPI methods on boot");
 
 static bool ide_noacpi_psx;
 static int no_acpi_psx(const struct dmi_system_id *id)
@@ -309,7 +317,7 @@ static int do_drive_get_GTF(ide_drive_t *drive,
         if (ACPI_FAILURE(status)) {
                 printk(KERN_DEBUG
                        "%s: Run _GTF error: status = 0x%x\n",
-                       __FUNCTION__, status);
+                       __func__, status);
                 goto out;
         }
 
@@ -335,7 +343,7 @@ static int do_drive_get_GTF(ide_drive_t *drive,
             out_obj->buffer.length % REGS_PER_GTF) {
                 printk(KERN_ERR
                        "%s: unexpected GTF length (%d) or addr (0x%p)\n",
-                       __FUNCTION__, out_obj->buffer.length,
+                       __func__, out_obj->buffer.length,
                        out_obj->buffer.pointer);
                 err = -ENOENT;
                 kfree(output.pointer);
@@ -376,7 +384,7 @@ static int taskfile_load_raw(ide_drive_t *drive,
         memcpy(&args.tf_array[7], &gtf->tfa, 7);
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-        if (ide_noacpitfs) {
+        if (!ide_acpigtf) {
                 DEBPRINT("_GTF execution disabled\n");
                 return err;
         }
@@ -384,7 +392,7 @@ static int taskfile_load_raw(ide_drive_t *drive,
         err = ide_no_data_taskfile(drive, &args);
         if (err)
                 printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
-                       __FUNCTION__, err);
+                       __func__, err);
 
         return err;
 }
@@ -422,7 +430,7 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
 
         if (gtf_length % REGS_PER_GTF) {
                 printk(KERN_ERR "%s: unexpected GTF length (%d)\n",
-                       __FUNCTION__, gtf_length);
+                       __func__, gtf_length);
                 goto out;
         }
 
@@ -547,7 +555,7 @@ void ide_acpi_get_timing(ide_hwif_t *hwif)
                 printk(KERN_ERR
                         "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
                         "addr (0x%p)\n",
-                        __FUNCTION__, out_obj->buffer.length,
+                        __func__, out_obj->buffer.length,
                         sizeof(struct GTM_buffer), out_obj->buffer.pointer);
                 return;
         }
@@ -721,7 +729,7 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
                                  drive->name, err);
         }
 
-        if (ide_noacpionboot) {
+        if (!ide_acpionboot) {
                 DEBPRINT("ACPI methods disabled on boot\n");
                 return;
         }
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index fe5aefbf8339..b34fd2bde96f 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -13,8 +13,8 @@
  *
  * Suggestions are welcome. Patches that work are more welcome though. ;-)
  * For those wishing to work on this driver, please be sure you download
- * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI 
- * (SFF-8020i rev 2.6) standards. These documents can be obtained by 
+ * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
+ * (SFF-8020i rev 2.6) standards. These documents can be obtained by
  * anonymous ftp from:
  * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
  * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
@@ -39,19 +39,20 @@
 #include <linux/mutex.h>
 #include <linux/bcd.h>
 
-#include <scsi/scsi.h>  /* For SCSI -> ATAPI command conversion */
+/* For SCSI -> ATAPI command conversion */
+#include <scsi/scsi.h>
 
-#include <asm/irq.h>
-#include <asm/io.h>
+#include <linux/irq.h>
+#include <linux/io.h>
 #include <asm/byteorder.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/unaligned.h>
 
 #include "ide-cd.h"
 
 static DEFINE_MUTEX(idecd_ref_mutex);
 
-#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 
+#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
 
 #define ide_cd_g(disk) \
         container_of((disk)->private_data, struct cdrom_info, driver)
@@ -77,19 +78,17 @@ static void ide_cd_put(struct cdrom_info *cd)
         mutex_unlock(&idecd_ref_mutex);
 }
 
-/****************************************************************************
+/*
  * Generic packet command support and error handling routines.
  */
 
-/* Mark that we've seen a media change, and invalidate our internal
-   buffers. */
-static void cdrom_saw_media_change (ide_drive_t *drive)
+/* Mark that we've seen a media change and invalidate our internal buffers. */
+static void cdrom_saw_media_change(ide_drive_t *drive)
 {
         struct cdrom_info *cd = drive->driver_data;
 
         cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
         cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
-        cd->nsectors_buffered = 0;
 }
 
 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
@@ -101,44 +100,43 @@ static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
                 return 0;
 
         switch (sense->sense_key) {
-                case NO_SENSE: case RECOVERED_ERROR:
-                        break;
-                case NOT_READY:
-                        /*
-                         * don't care about tray state messages for
-                         * e.g. capacity commands or in-progress or
-                         * becoming ready
-                         */
-                        if (sense->asc == 0x3a || sense->asc == 0x04)
-                                break;
-                        log = 1;
-                        break;
-                case ILLEGAL_REQUEST:
-                        /*
-                         * don't log START_STOP unit with LoEj set, since
-                         * we cannot reliably check if drive can auto-close
-                         */
-                        if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
-                                break;
-                        log = 1;
-                        break;
-                case UNIT_ATTENTION:
-                        /*
-                         * Make good and sure we've seen this potential media
-                         * change. Some drives (i.e. Creative) fail to present
-                         * the correct sense key in the error register.
-                         */
-                        cdrom_saw_media_change(drive);
+        case NO_SENSE:
+        case RECOVERED_ERROR:
+                break;
+        case NOT_READY:
+                /*
+                 * don't care about tray state messages for e.g. capacity
+                 * commands or in-progress or becoming ready
+                 */
+                if (sense->asc == 0x3a || sense->asc == 0x04)
                         break;
-                default:
-                        log = 1;
+                log = 1;
+                break;
+        case ILLEGAL_REQUEST:
+                /*
+                 * don't log START_STOP unit with LoEj set, since we cannot
+                 * reliably check if drive can auto-close
+                 */
+                if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
                         break;
+                log = 1;
+                break;
+        case UNIT_ATTENTION:
+                /*
+                 * Make good and sure we've seen this potential media change.
+                 * Some drives (i.e. Creative) fail to present the correct sense
+                 * key in the error register.
+                 */
+                cdrom_saw_media_change(drive);
+                break;
+        default:
+                log = 1;
+                break;
         }
         return log;
 }
 
-static
-void cdrom_analyze_sense_data(ide_drive_t *drive,
+static void cdrom_analyze_sense_data(ide_drive_t *drive,
                               struct request *failed_command,
                               struct request_sense *sense)
 {
@@ -151,16 +149,17 @@ void cdrom_analyze_sense_data(ide_drive_t *drive,
                 return;
 
         /*
-         * If a read toc is executed for a CD-R or CD-RW medium where
-         * the first toc has not been recorded yet, it will fail with
-         * 05/24/00 (which is a confusing error)
+         * If a read toc is executed for a CD-R or CD-RW medium where the first
+         * toc has not been recorded yet, it will fail with 05/24/00 (which is a
+         * confusing error)
          */
         if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
                         return;
 
-        if (sense->error_code == 0x70) {        /* Current Error */
-                switch(sense->sense_key) {
+        /* current error */
+        if (sense->error_code == 0x70) {
+                switch (sense->sense_key) {
                 case MEDIUM_ERROR:
                 case VOLUME_OVERFLOW:
                 case ILLEGAL_REQUEST:
@@ -178,25 +177,23 @@ void cdrom_analyze_sense_data(ide_drive_t *drive,
                         if (bio_sectors < 4)
                                 bio_sectors = 4;
                         if (drive->queue->hardsect_size == 2048)
-                                sector <<= 2;   /* Device sector size is 2K */
-                        sector &= ~(bio_sectors -1);
+                                /* device sector size is 2K */
+                                sector <<= 2;
+                        sector &= ~(bio_sectors - 1);
                         valid = (sector - failed_command->sector) << 9;
 
                         if (valid < 0)
                                 valid = 0;
                         if (sector < get_capacity(info->disk) &&
-                                drive->probed_capacity - sector < 4 * 75) {
+                            drive->probed_capacity - sector < 4 * 75)
                                 set_capacity(info->disk, sector);
-                        }
-                }
-        }
+                }
+        }
 
         ide_cd_log_error(drive->name, failed_command, sense);
 }
 
-/*
- * Initialize a ide-cd packet command request
- */
+/* Initialize a ide-cd packet command request */
 void ide_cd_init_rq(ide_drive_t *drive, struct request *rq)
 {
         struct cdrom_info *cd = drive->driver_data;
@@ -220,7 +217,8 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
 
         rq->data = sense;
         rq->cmd[0] = GPCMD_REQUEST_SENSE;
-        rq->cmd[4] = rq->data_len = 18;
+        rq->cmd[4] = 18;
+        rq->data_len = 18;
 
         rq->cmd_type = REQ_TYPE_SENSE;
 
@@ -230,7 +228,7 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
 }
 
-static void cdrom_end_request (ide_drive_t *drive, int uptodate)
+static void cdrom_end_request(ide_drive_t *drive, int uptodate)
 {
         struct request *rq = HWGROUP(drive)->rq;
         int nsectors = rq->hard_cur_sectors;
@@ -252,7 +250,7 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
                         }
                         cdrom_analyze_sense_data(drive, failed, sense);
                         /*
-                         * now end failed request
+                         * now end the failed request
                          */
                         if (blk_fs_request(failed)) {
                                 if (ide_end_dequeued_request(drive, failed, 0,
@@ -280,21 +278,24 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
         ide_end_request(drive, uptodate, nsectors);
 }
 
-static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
+static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
 {
-        if (stat & 0x80)
+        if (st & 0x80)
                 return;
-        ide_dump_status(drive, msg, stat);
+        ide_dump_status(drive, msg, st);
 }
 
-/* Returns 0 if the request should be continued.
-   Returns 1 if the request was ended. */
+/*
+ * Returns:
+ * 0: if the request should be continued.
+ * 1: if the request was ended.
+ */
 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
 {
         struct request *rq = HWGROUP(drive)->rq;
         int stat, err, sense_key;
-        
-        /* Check for errors. */
+
+        /* check for errors */
         stat = ide_read_status(drive);
 
         if (stat_ret)
@@ -303,20 +304,22 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
         if (OK_STAT(stat, good_stat, BAD_R_STAT))
                 return 0;
 
-        /* Get the IDE error register. */
+        /* get the IDE error register */
         err = ide_read_error(drive);
         sense_key = err >> 4;
 
         if (rq == NULL) {
-                printk("%s: missing rq in cdrom_decode_status\n", drive->name);
+                printk(KERN_ERR "%s: missing rq in %s\n",
+                                drive->name, __func__);
                 return 1;
         }
 
         if (blk_sense_request(rq)) {
-                /* We got an error trying to get sense info
-                   from the drive (probably while trying
-                   to recover from a former error).  Just give up. */
-
+                /*
+                 * We got an error trying to get sense info from the drive
+                 * (probably while trying to recover from a former error).
+                 * Just give up.
+                 */
                 rq->cmd_flags |= REQ_FAILED;
                 cdrom_end_request(drive, 0);
                 ide_error(drive, "request sense failure", stat);
@@ -332,28 +335,27 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                 if (blk_pc_request(rq) && !rq->errors)
                         rq->errors = SAM_STAT_CHECK_CONDITION;
 
-                /* Check for tray open. */
+                /* check for tray open */
                 if (sense_key == NOT_READY) {
-                        cdrom_saw_media_change (drive);
+                        cdrom_saw_media_change(drive);
                 } else if (sense_key == UNIT_ATTENTION) {
-                        /* Check for media change. */
-                        cdrom_saw_media_change (drive);
-                        /*printk("%s: media changed\n",drive->name);*/
+                        /* check for media change */
+                        cdrom_saw_media_change(drive);
                         return 0;
-                } else if ((sense_key == ILLEGAL_REQUEST) &&
-                           (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
-                        /*
-                         * Don't print error message for this condition--
-                         * SFF8090i indicates that 5/24/00 is the correct
-                         * response to a request to close the tray if the
-                         * drive doesn't have that capability.
-                         * cdrom_log_sense() knows this!
-                         */
+                } else if (sense_key == ILLEGAL_REQUEST &&
+                           rq->cmd[0] == GPCMD_START_STOP_UNIT) {
+                        /*
+                         * Don't print error message for this condition--
+                         * SFF8090i indicates that 5/24/00 is the correct
+                         * response to a request to close the tray if the
+                         * drive doesn't have that capability.
+                         * cdrom_log_sense() knows this!
+                         */
                 } else if (!(rq->cmd_flags & REQ_QUIET)) {
-                        /* Otherwise, print an error. */
+                        /* otherwise, print an error */
                         ide_dump_status(drive, "packet command error", stat);
                 }
-                
+
                 rq->cmd_flags |= REQ_FAILED;
 
                 /*
@@ -366,27 +368,30 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
         } else if (blk_fs_request(rq)) {
                 int do_end_request = 0;
 
-                /* Handle errors from READ and WRITE requests. */
+                /* handle errors from READ and WRITE requests */
 
                 if (blk_noretry_request(rq))
                         do_end_request = 1;
 
                 if (sense_key == NOT_READY) {
-                        /* Tray open. */
+                        /* tray open */
                         if (rq_data_dir(rq) == READ) {
-                                cdrom_saw_media_change (drive);
+                                cdrom_saw_media_change(drive);
 
-                                /* Fail the request. */
-                                printk ("%s: tray open\n", drive->name);
+                                /* fail the request */
+                                printk(KERN_ERR "%s: tray open\n", drive->name);
                                 do_end_request = 1;
                         } else {
                                 struct cdrom_info *info = drive->driver_data;
 
-                                /* allow the drive 5 seconds to recover, some
+                                /*
+                                 * Allow the drive 5 seconds to recover, some
                                  * devices will return this error while flushing
-                                 * data from cache */
+                                 * data from cache.
+                                 */
                                 if (!rq->errors)
-                                        info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
+                                        info->write_timeout = jiffies +
+                                                        ATAPI_WAIT_WRITE_BUSY;
                                 rq->errors = 1;
                                 if (time_after(jiffies, info->write_timeout))
                                         do_end_request = 1;
@@ -394,59 +399,68 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                                         unsigned long flags;
 
                                         /*
-                                         * take a breather relying on the
-                                         * unplug timer to kick us again
+                                         * take a breather relying on the unplug
+                                         * timer to kick us again
                                          */
                                         spin_lock_irqsave(&ide_lock, flags);
                                         blk_plug_device(drive->queue);
-                                        spin_unlock_irqrestore(&ide_lock,flags);
+                                        spin_unlock_irqrestore(&ide_lock,
+                                                                flags);
                                         return 1;
                                 }
                         }
                 } else if (sense_key == UNIT_ATTENTION) {
-                        /* Media change. */
-                        cdrom_saw_media_change (drive);
+                        /* media change */
+                        cdrom_saw_media_change(drive);
 
-                        /* Arrange to retry the request.
-                           But be sure to give up if we've retried
-                           too many times. */
+                        /*
+                         * Arrange to retry the request but be sure to give up
+                         * if we've retried too many times.
+                         */
                         if (++rq->errors > ERROR_MAX)
                                 do_end_request = 1;
                 } else if (sense_key == ILLEGAL_REQUEST ||
                            sense_key == DATA_PROTECT) {
-                        /* No point in retrying after an illegal
-                           request or data protect error.*/
-                        ide_dump_status_no_sense (drive, "command error", stat);
+                        /*
+                         * No point in retrying after an illegal request or data
+                         * protect error.
+                         */
+                        ide_dump_status_no_sense(drive, "command error", stat);
                         do_end_request = 1;
                 } else if (sense_key == MEDIUM_ERROR) {
-                        /* No point in re-trying a zillion times on a bad 
-                         * sector...  If we got here the error is not correctable */
-                        ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
+                        /*
+                         * No point in re-trying a zillion times on a bad
+                         * sector. If we got here the error is not correctable.
+                         */
+                        ide_dump_status_no_sense(drive,
+                                                 "media error (bad sector)",
+                                                 stat);
                         do_end_request = 1;
                 } else if (sense_key == BLANK_CHECK) {
-                        /* Disk appears blank ?? */
-                        ide_dump_status_no_sense (drive, "media error (blank)", stat);
+                        /* disk appears blank ?? */
+                        ide_dump_status_no_sense(drive, "media error (blank)",
+                                                 stat);
                         do_end_request = 1;
                 } else if ((err & ~ABRT_ERR) != 0) {
-                        /* Go to the default handler
-                           for other errors. */
+                        /* go to the default handler for other errors */
                         ide_error(drive, "cdrom_decode_status", stat);
                         return 1;
                 } else if ((++rq->errors > ERROR_MAX)) {
-                        /* We've racked up too many retries.  Abort. */
+                        /* we've racked up too many retries, abort */
                         do_end_request = 1;
                 }
 
-                /* End a request through request sense analysis when we have
-                   sense data. We need this in order to perform end of media
-                   processing */
-
+                /*
+                 * End a request through request sense analysis when we have
+                 * sense data. We need this in order to perform end of media
+                 * processing.
+                 */
                 if (do_end_request)
                         goto end_request;
 
                 /*
-                 * If we got a CHECK_CONDITION status,
-                 * queue a request sense command.
+                 * If we got a CHECK_CONDITION status, queue
+                 * a request sense command.
                  */
                 if (stat & ERR_STAT)
                         cdrom_queue_request_sense(drive, NULL, NULL);
@@ -455,7 +469,7 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                 cdrom_end_request(drive, 0);
         }
 
-        /* Retry, or handle the next request. */
+        /* retry, or handle the next request */
         return 1;
 
 end_request:
@@ -480,35 +494,37 @@ static int cdrom_timer_expiry(ide_drive_t *drive)
         unsigned long wait = 0;
 
         /*
-         * Some commands are *slow* and normally take a long time to
-         * complete. Usually we can use the ATAPI "disconnect" to bypass
-         * this, but not all commands/drives support that. Let
-         * ide_timer_expiry keep polling us for these.
+         * Some commands are *slow* and normally take a long time to complete.
+         * Usually we can use the ATAPI "disconnect" to bypass this, but not all
+         * commands/drives support that. Let ide_timer_expiry keep polling us
+         * for these.
          */
         switch (rq->cmd[0]) {
-                case GPCMD_BLANK:
-                case GPCMD_FORMAT_UNIT:
-                case GPCMD_RESERVE_RZONE_TRACK:
-                case GPCMD_CLOSE_TRACK:
-                case GPCMD_FLUSH_CACHE:
-                        wait = ATAPI_WAIT_PC;
-                        break;
-                default:
-                        if (!(rq->cmd_flags & REQ_QUIET))
-                                printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
-                        wait = 0;
-                        break;
+        case GPCMD_BLANK:
+        case GPCMD_FORMAT_UNIT:
+        case GPCMD_RESERVE_RZONE_TRACK:
+        case GPCMD_CLOSE_TRACK:
+        case GPCMD_FLUSH_CACHE:
+                wait = ATAPI_WAIT_PC;
+                break;
+        default:
+                if (!(rq->cmd_flags & REQ_QUIET))
+                        printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n",
+                                         rq->cmd[0]);
+                wait = 0;
+                break;
         }
         return wait;
 }
 
-/* Set up the device registers for transferring a packet command on DEV,
-   expecting to later transfer XFERLEN bytes.  HANDLER is the routine
-   which actually transfers the command to the drive.  If this is a
-   drq_interrupt device, this routine will arrange for HANDLER to be
-   called when the interrupt from the drive arrives.  Otherwise, HANDLER
-   will be called immediately after the drive is prepared for the transfer. */
-
+/*
+ * Set up the device registers for transferring a packet command on DEV,
+ * expecting to later transfer XFERLEN bytes.  HANDLER is the routine
+ * which actually transfers the command to the drive.  If this is a
+ * drq_interrupt device, this routine will arrange for HANDLER to be
+ * called when the interrupt from the drive arrives.  Otherwise, HANDLER
+ * will be called immediately after the drive is prepared for the transfer.
+ */
 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
                                                   int xferlen,
                                                   ide_handler_t *handler)
@@ -517,15 +533,15 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
         struct cdrom_info *info = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
 
-        /* Wait for the controller to be idle. */
+        /* wait for the controller to be idle */
         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
                 return startstop;
 
         /* FIXME: for Virtual DMA we must check harder */
         if (info->dma)
-                info->dma = !hwif->dma_setup(drive);
+                info->dma = !hwif->dma_ops->dma_setup(drive);
 
-        /* Set up the controller registers. */
+        /* set up the controller registers */
         ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
                            IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
 
@@ -535,7 +551,8 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
                         drive->waiting_for_dma = 0;
 
                 /* packet command */
-                ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
+                ide_execute_command(drive, WIN_PACKETCMD, handler,
+                                    ATAPI_WAIT_PC, cdrom_timer_expiry);
                 return ide_started;
         } else {
                 unsigned long flags;
@@ -543,7 +560,7 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
                 /* packet command */
                 spin_lock_irqsave(&ide_lock, flags);
                 hwif->OUTBSYNC(drive, WIN_PACKETCMD,
-                               hwif->io_ports[IDE_COMMAND_OFFSET]);
+                               hwif->io_ports.command_addr);
                 ndelay(400);
                 spin_unlock_irqrestore(&ide_lock, flags);
 
@@ -551,13 +568,14 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
         }
 }
 
-/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
-   The device registers must have already been prepared
-   by cdrom_start_packet_command.
-   HANDLER is the interrupt handler to call when the command completes
-   or there's data ready. */
+/*
+ * Send a packet command to DRIVE described by CMD_BUF and CMD_LEN. The device
+ * registers must have already been prepared by cdrom_start_packet_command.
+ * HANDLER is the interrupt handler to call when the command completes or
+ * there's data ready.
+ */
 #define ATAPI_MIN_CDB_BYTES 12
-static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
+static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
                                           struct request *rq,
                                           ide_handler_t *handler)
 {
@@ -567,24 +585,26 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
         ide_startstop_t startstop;
 
         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
-                /* Here we should have been called after receiving an interrupt
-                   from the device.  DRQ should how be set. */
+                /*
+                 * Here we should have been called after receiving an interrupt
+                 * from the device.  DRQ should how be set.
+                 */
 
-                /* Check for errors. */
+                /* check for errors */
                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
                         return ide_stopped;
 
-                /* Ok, next interrupt will be DMA interrupt. */
+                /* ok, next interrupt will be DMA interrupt */
                 if (info->dma)
                         drive->waiting_for_dma = 1;
         } else {
-                /* Otherwise, we must wait for DRQ to get set. */
+                /* otherwise, we must wait for DRQ to get set */
                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
                                 BUSY_STAT, WAIT_READY))
                         return startstop;
         }
 
-        /* Arm the interrupt handler. */
+        /* arm the interrupt handler */
         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
 
         /* ATAPI commands get padded out to 12 bytes minimum */
@@ -592,20 +612,19 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
         if (cmd_len < ATAPI_MIN_CDB_BYTES)
                 cmd_len = ATAPI_MIN_CDB_BYTES;
 
-        /* Send the command to the device. */
+        /* send the command to the device */
         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
 
-        /* Start the DMA if need be */
+        /* start the DMA if need be */
         if (info->dma)
-                hwif->dma_start(drive);
+                hwif->dma_ops->dma_start(drive);
 
         return ide_started;
 }
 
-/****************************************************************************
+/*
  * Block read functions.
  */
-
 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
 {
         while (len > 0) {
@@ -626,47 +645,6 @@ static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
 }
 
 /*
- * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
- * buffer.  Once the first sector is added, any subsequent sectors are
- * assumed to be continuous (until the buffer is cleared).  For the first
- * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
- * the buffer is cleared.)
- */
-static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
-                                  int sectors_to_transfer)
-{
-        struct cdrom_info *info = drive->driver_data;
-
-        /* Number of sectors to read into the buffer. */
-        int sectors_to_buffer = min_t(int, sectors_to_transfer,
-                                     (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
-                                       info->nsectors_buffered);
-
-        char *dest;
-
-        /* If we couldn't get a buffer, don't try to buffer anything... */
-        if (info->buffer == NULL)
-                sectors_to_buffer = 0;
-
-        /* If this is the first sector in the buffer, remember its number. */
-        if (info->nsectors_buffered == 0)
-                info->sector_buffered = sector;
-
-        /* Read the data into the buffer. */
-        dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
-        while (sectors_to_buffer > 0) {
-                HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
-                --sectors_to_buffer;
-                --sectors_to_transfer;
-                ++info->nsectors_buffered;
-                dest += SECTOR_SIZE;
-        }
-
-        /* Throw away any remaining data. */
-        ide_cd_drain_data(drive, sectors_to_transfer);
-}
-
-/*
  * Check the contents of the interrupt reason register from the cdrom
  * and attempt to recover if there are problems.  Returns  0 if everything's
  * ok; nonzero if the request has been terminated.
@@ -684,22 +662,23 @@ static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
                 ide_hwif_t *hwif = drive->hwif;
                 xfer_func_t *xf;
 
-                /* Whoops... */
+                /* whoops... */
                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
-                                drive->name, __FUNCTION__);
+                                drive->name, __func__);
 
                 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
                 ide_cd_pad_transfer(drive, xf, len);
         } else  if (rw == 0 && ireason == 1) {
-                /* Some drives (ASUS) seem to tell us that status
-                 * info is available. just get it and ignore.
+                /*
+                 * Some drives (ASUS) seem to tell us that status info is
+                 * available.  Just get it and ignore.
                  */
                 (void)ide_read_status(drive);
                 return 0;
         } else {
-                /* Drive wants a command packet, or invalid ireason... */
+                /* drive wants a command packet, or invalid ireason... */
                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
-                                drive->name, __FUNCTION__, ireason);
+                                drive->name, __func__, ireason);
         }
 
         if (rq->cmd_type == REQ_TYPE_ATA_PC)
@@ -721,7 +700,7 @@ static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
                 return 0;
 
         printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
-                        drive->name, __FUNCTION__, len);
+                        drive->name, __func__, len);
 
         if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
                 printk(KERN_ERR "  This drive is not supported by "
@@ -734,72 +713,13 @@ static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
         return 1;
 }
 
-/*
- * Try to satisfy some of the current read request from our cached data.
- * Returns nonzero if the request has been completed, zero otherwise.
- */
-static int cdrom_read_from_buffer (ide_drive_t *drive)
-{
-        struct cdrom_info *info = drive->driver_data;
-        struct request *rq = HWGROUP(drive)->rq;
-        unsigned short sectors_per_frame;
-
-        sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
-
-        /* Can't do anything if there's no buffer. */
-        if (info->buffer == NULL) return 0;
-
-        /* Loop while this request needs data and the next block is present
-           in our cache. */
-        while (rq->nr_sectors > 0 &&
-               rq->sector >= info->sector_buffered &&
-               rq->sector < info->sector_buffered + info->nsectors_buffered) {
-                if (rq->current_nr_sectors == 0)
-                        cdrom_end_request(drive, 1);
-
-                memcpy (rq->buffer,
-                        info->buffer +
-                        (rq->sector - info->sector_buffered) * SECTOR_SIZE,
-                        SECTOR_SIZE);
-                rq->buffer += SECTOR_SIZE;
-                --rq->current_nr_sectors;
-                --rq->nr_sectors;
-                ++rq->sector;
-        }
-
-        /* If we've satisfied the current request,
-           terminate it successfully. */
-        if (rq->nr_sectors == 0) {
-                cdrom_end_request(drive, 1);
-                return -1;
-        }
-
-        /* Move on to the next buffer if needed. */
-        if (rq->current_nr_sectors == 0)
-                cdrom_end_request(drive, 1);
-
-        /* If this condition does not hold, then the kluge i use to
-           represent the number of sectors to skip at the start of a transfer
-           will fail.  I think that this will never happen, but let's be
-           paranoid and check. */
-        if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
-            (rq->sector & (sectors_per_frame - 1))) {
-                printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
-                        drive->name, (long)rq->sector);
-                cdrom_end_request(drive, 0);
-                return -1;
-        }
-
-        return 0;
-}
-
 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
 
 /*
- * Routine to send a read/write packet command to the drive.
- * This is usually called directly from cdrom_start_{read,write}().
- * However, for drq_interrupt devices, it is called from an interrupt
- * when the drive is ready to accept the command.
+ * Routine to send a read/write packet command to the drive. This is usually
+ * called directly from cdrom_start_{read,write}(). However, for drq_interrupt
+ * devices, it is called from an interrupt when the drive is ready to accept
+ * the command.
  */
 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
 {
@@ -821,11 +741,11 @@ static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
                  * is larger than the buffer size.
                  */
                 if (nskip > 0) {
-                        /* Sanity check... */
+                        /* sanity check... */
                         if (rq->current_nr_sectors !=
                             bio_cur_sectors(rq->bio)) {
                                 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
-                                                drive->name, __FUNCTION__,
+                                                drive->name, __func__,
                                                 rq->current_nr_sectors);
                                 cdrom_end_request(drive, 0);
                                 return ide_stopped;
@@ -838,10 +758,10 @@ static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
                 /* the immediate bit */
                 rq->cmd[1] = 1 << 3;
 #endif
-        /* Set up the command */
+        /* set up the command */
         rq->timeout = ATAPI_WAIT_PC;
 
-        /* Send the command to the drive and return. */
+        /* send the command to the drive and return */
         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
 }
 
@@ -849,7 +769,7 @@ static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
 
-static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
+static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
 {
         struct cdrom_info *info = drive->driver_data;
         int stat;
@@ -861,19 +781,13 @@ static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
         info->cd_flags |= IDE_CD_FLAG_SEEKING;
 
         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
-                if (--retry == 0) {
-                        /*
-                         * this condition is far too common, to bother
-                         * users about it
-                         */
-                        /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 
+                if (--retry == 0)
                         drive->dsc_overlap = 0;
-                }
         }
         return ide_stopped;
 }
 
-static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
+static ide_startstop_t cdrom_start_seek_continuation(ide_drive_t *drive)
 {
         struct request *rq = HWGROUP(drive)->rq;
         sector_t frame = rq->sector;
@@ -888,36 +802,40 @@ static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
 }
 
-static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
+static ide_startstop_t cdrom_start_seek(ide_drive_t *drive, unsigned int block)
 {
         struct cdrom_info *info = drive->driver_data;
 
         info->dma = 0;
         info->start_seek = jiffies;
-        return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
+        return cdrom_start_packet_command(drive, 0,
+                                          cdrom_start_seek_continuation);
 }
 
-/* Fix up a possibly partially-processed request so that we can
-   start it over entirely, or even put it back on the request queue. */
-static void restore_request (struct request *rq)
+/*
+ * Fix up a possibly partially-processed request so that we can start it over
+ * entirely, or even put it back on the request queue.
+ */
+static void restore_request(struct request *rq)
 {
         if (rq->buffer != bio_data(rq->bio)) {
-                sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
+                sector_t n =
+                        (rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
 
                 rq->buffer = bio_data(rq->bio);
                 rq->nr_sectors += n;
                 rq->sector -= n;
         }
-        rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
+        rq->current_nr_sectors = bio_cur_sectors(rq->bio);
+        rq->hard_cur_sectors = rq->current_nr_sectors;
         rq->hard_nr_sectors = rq->nr_sectors;
         rq->hard_sector = rq->sector;
         rq->q->prep_rq_fn(rq->q, rq);
 }
 
-/****************************************************************************
- * Execute all other packet commands.
+/*
+ * All other packet commands.
  */
-
 static void ide_cd_request_sense_fixup(struct request *rq)
 {
         /*
@@ -941,7 +859,7 @@ int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
         if (rq->sense == NULL)
                 rq->sense = &sense;
 
-        /* Start of retry loop. */
+        /* start of retry loop */
         do {
                 int error;
                 unsigned long time = jiffies;
@@ -950,41 +868,45 @@ int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
                 error = ide_do_drive_cmd(drive, rq, ide_wait);
                 time = jiffies - time;
 
-                /* FIXME: we should probably abort/retry or something 
-                 * in case of failure */
+                /*
+                 * FIXME: we should probably abort/retry or something in case of
+                 * failure.
+                 */
                 if (rq->cmd_flags & REQ_FAILED) {
-                        /* The request failed.  Retry if it was due to a unit
-                           attention status
-                           (usually means media was changed). */
+                        /*
+                         * The request failed.  Retry if it was due to a unit
+                         * attention status (usually means media was changed).
+                         */
                         struct request_sense *reqbuf = rq->sense;
 
                         if (reqbuf->sense_key == UNIT_ATTENTION)
                                 cdrom_saw_media_change(drive);
                         else if (reqbuf->sense_key == NOT_READY &&
                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
-                                /* The drive is in the process of loading
-                                   a disk.  Retry, but wait a little to give
-                                   the drive time to complete the load. */
+                                /*
+                                 * The drive is in the process of loading
+                                 * a disk.  Retry, but wait a little to give
+                                 * the drive time to complete the load.
+                                 */
                                 ssleep(2);
                         } else {
-                                /* Otherwise, don't retry. */
+                                /* otherwise, don't retry */
                                 retries = 0;
                         }
                         --retries;
                 }
 
-                /* End of retry loop. */
+                /* end of retry loop */
         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
 
-        /* Return an error if the command failed. */
+        /* return an error if the command failed */
         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
 }
 
 /*
- * Called from blk_end_request_callback() after the data of the request
- * is completed and before the request is completed.
- * By returning value '1', blk_end_request_callback() returns immediately
- * without completing the request.
+ * Called from blk_end_request_callback() after the data of the request is
+ * completed and before the request itself is completed. By returning value '1',
+ * blk_end_request_callback() returns immediately without completing it.
  */
 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
 {
@@ -1003,11 +925,11 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         unsigned int timeout;
         u8 lowcyl, highcyl;
 
-        /* Check for errors. */
+        /* check for errors */
         dma = info->dma;
         if (dma) {
                 info->dma = 0;
-                dma_error = HWIF(drive)->ide_dma_end(drive);
+                dma_error = hwif->dma_ops->dma_end(drive);
                 if (dma_error) {
                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
                                         write ? "write" : "read");
@@ -1018,9 +940,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         if (cdrom_decode_status(drive, 0, &stat))
                 return ide_stopped;
 
-        /*
-         * using dma, transfer is complete now
-         */
+        /* using dma, transfer is complete now */
         if (dma) {
                 if (dma_error)
                         return ide_error(drive, "dma error", stat);
@@ -1031,12 +951,10 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                 goto end_request;
         }
 
-        /*
-         * ok we fall to pio :/
-         */
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]) & 0x3;
-        lowcyl  = hwif->INB(hwif->io_ports[IDE_BCOUNTL_OFFSET]);
-        highcyl = hwif->INB(hwif->io_ports[IDE_BCOUNTH_OFFSET]);
+        /* ok we fall to pio :/ */
+        ireason = hwif->INB(hwif->io_ports.nsect_addr) & 0x3;
+        lowcyl  = hwif->INB(hwif->io_ports.lbam_addr);
+        highcyl = hwif->INB(hwif->io_ports.lbah_addr);
 
         len = lowcyl + (256 * highcyl);
 
@@ -1044,9 +962,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         if (thislen > len)
                 thislen = len;
 
-        /*
-         * If DRQ is clear, the command has completed.
-         */
+        /* If DRQ is clear, the command has completed. */
         if ((stat & DRQ_STAT) == 0) {
                 if (blk_fs_request(rq)) {
                         /*
@@ -1057,7 +973,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                         if (rq->current_nr_sectors > 0) {
                                 printk(KERN_ERR "%s: %s: data underrun "
                                                 "(%d blocks)\n",
-                                                drive->name, __FUNCTION__,
+                                                drive->name, __func__,
                                                 rq->current_nr_sectors);
                                 if (!write)
                                         rq->cmd_flags |= REQ_FAILED;
@@ -1067,15 +983,13 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                         return ide_stopped;
                 } else if (!blk_pc_request(rq)) {
                         ide_cd_request_sense_fixup(rq);
-                        /* Complain if we still have data left to transfer. */
+                        /* complain if we still have data left to transfer */
                         uptodate = rq->data_len ? 0 : 1;
                 }
                 goto end_request;
         }
 
-        /*
-         * check which way to transfer data
-         */
+        /* check which way to transfer data */
         if (ide_cd_check_ireason(drive, rq, len, ireason, write))
                 return ide_stopped;
 
@@ -1111,16 +1025,12 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                 xferfunc = HWIF(drive)->atapi_input_bytes;
         }
 
-        /*
-         * transfer data
-         */
+        /* transfer data */
         while (thislen > 0) {
                 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
                 int blen = rq->data_len;
 
-                /*
-                 * bio backed?
-                 */
+                /* bio backed? */
                 if (rq->bio) {
                         if (blk_fs_request(rq)) {
                                 ptr = rq->buffer;
@@ -1134,11 +1044,10 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                 if (!ptr) {
                         if (blk_fs_request(rq) && !write)
                                 /*
-                                 * If the buffers are full, cache the rest
-                                 * of the data in our internal buffer.
+                                 * If the buffers are full, pipe the rest into
+                                 * oblivion.
                                  */
-                                cdrom_buffer_sectors(drive, rq->sector,
-                                                     thislen >> 9);
+                                ide_cd_drain_data(drive, thislen >> 9);
                         else {
                                 printk(KERN_ERR "%s: confused, missing data\n",
                                                 drive->name);
@@ -1184,9 +1093,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                         rq->sense_len += blen;
         }
 
-        /*
-         * pad, if necessary
-         */
+        /* pad, if necessary */
         if (!blk_fs_request(rq) && len > 0)
                 ide_cd_pad_transfer(drive, xferfunc, len);
 
@@ -1230,9 +1137,7 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 
         if (write) {
-                /*
-                 * disk has become write protected
-                 */
+                /* disk has become write protected */
                 if (cd->disk->policy) {
                         cdrom_end_request(drive, 0);
                         return ide_stopped;
@@ -1243,15 +1148,9 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
                  * weirdness which might be present in the request packet.
                  */
                 restore_request(rq);
-
-                /* Satisfy whatever we can of this request from our cache. */
-                if (cdrom_read_from_buffer(drive))
-                        return ide_stopped;
         }
 
-        /*
-         * use DMA, if possible / writes *must* be hardware frame aligned
-         */
+        /* use DMA, if possible / writes *must* be hardware frame aligned */
         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
             (rq->sector & (sectors_per_frame - 1))) {
                 if (write) {
@@ -1262,13 +1161,10 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         } else
                 cd->dma = drive->using_dma;
 
-        /* Clear the local sector buffer. */
-        cd->nsectors_buffered = 0;
-
         if (write)
                 cd->devinfo.media_written = 1;
 
-        /* Start sending the read/write request to the drive. */
+        /* start sending the read/write request to the drive */
         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
 }
 
@@ -1293,12 +1189,11 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 
         info->dma = 0;
 
-        /*
-         * sg request
-         */
+        /* sg request */
         if (rq->bio) {
                 int mask = drive->queue->dma_alignment;
-                unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
+                unsigned long addr =
+                        (unsigned long)page_address(bio_page(rq->bio));
 
                 info->dma = drive->using_dma;
 
@@ -1312,15 +1207,16 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
                         info->dma = 0;
         }
 
-        /* Start sending the command to the drive. */
-        return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
+        /* start sending the command to the drive */
+        return cdrom_start_packet_command(drive, rq->data_len,
+                                          cdrom_do_newpc_cont);
 }
 
-/****************************************************************************
+/*
  * cdrom driver request routine.
  */
-static ide_startstop_t
-ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
+static ide_startstop_t ide_do_rw_cdrom(ide_drive_t *drive, struct request *rq,
+                                        sector_t block)
 {
         ide_startstop_t action;
         struct cdrom_info *info = drive->driver_data;
@@ -1332,16 +1228,21 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
 
                         if ((stat & SEEK_STAT) != SEEK_STAT) {
                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
-                                        ide_stall_queue(drive, IDECD_SEEK_TIMER);
+                                        ide_stall_queue(drive,
+                                                        IDECD_SEEK_TIMER);
                                         return ide_stopped;
                                 }
-                                printk (KERN_ERR "%s: DSC timeout\n", drive->name);
+                                printk(KERN_ERR "%s: DSC timeout\n",
+                                                drive->name);
                         }
                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
                 }
-                if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
+                if (rq_data_dir(rq) == READ &&
+                    IDE_LARGE_SEEK(info->last_block, block,
+                                   IDECD_SEEK_THRESHOLD) &&
+                    drive->dsc_overlap)
                         action = cdrom_start_seek(drive, block);
-                } else
+                else
                         action = cdrom_start_rw(drive, rq);
                 info->last_block = block;
                 return action;
@@ -1349,9 +1250,7 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
                    rq->cmd_type == REQ_TYPE_ATA_PC) {
                 return cdrom_do_block_pc(drive, rq);
         } else if (blk_special_request(rq)) {
-                /*
-                 * right now this can only be a reset...
-                 */
+                /* right now this can only be a reset... */
                 cdrom_end_request(drive, 1);
                 return ide_stopped;
         }
@@ -1363,18 +1262,16 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
 
 
 
-/****************************************************************************
+/*
  * Ioctl handling.
  *
- * Routines which queue packet commands take as a final argument a pointer
- * to a request_sense struct.  If execution of the command results
- * in an error with a CHECK CONDITION status, this structure will be filled
- * with the results of the subsequent request sense command.  The pointer
- * can also be NULL, in which case no sense information is returned.
+ * Routines which queue packet commands take as a final argument a pointer to a
+ * request_sense struct. If execution of the command results in an error with a
+ * CHECK CONDITION status, this structure will be filled with the results of the
+ * subsequent request sense command. The pointer can also be NULL, in which case
+ * no sense information is returned.
  */
-
-static
-void msf_from_bcd (struct atapi_msf *msf)
+static void msf_from_bcd(struct atapi_msf *msf)
 {
         msf->minute = BCD2BIN(msf->minute);
         msf->second = BCD2BIN(msf->second);
@@ -1394,8 +1291,8 @@ int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
         req.cmd_flags |= REQ_QUIET;
 
         /*
-         * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
-         * switch CDs instead of supporting the LOAD_UNLOAD opcode.
+         * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
+         * instead of supporting the LOAD_UNLOAD opcode.
          */
         req.cmd[7] = cdi->sanyo_slot % 3;
 
@@ -1471,36 +1368,39 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
 
         if (toc == NULL) {
-                /* Try to allocate space. */
+                /* try to allocate space */
                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
                 if (toc == NULL) {
-                        printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
+                        printk(KERN_ERR "%s: No cdrom TOC buffer!\n",
+                                        drive->name);
                         return -ENOMEM;
                 }
                 info->toc = toc;
         }
 
-        /* Check to see if the existing data is still valid.
-           If it is, just return. */
+        /*
+         * Check to see if the existing data is still valid. If it is,
+         * just return.
+         */
         (void) cdrom_check_status(drive, sense);
 
         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
                 return 0;
 
-        /* Try to get the total cdrom capacity and sector size. */
+        /* try to get the total cdrom capacity and sector size */
         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
                                    sense);
         if (stat)
                 toc->capacity = 0x1fffff;
 
         set_capacity(info->disk, toc->capacity * sectors_per_frame);
-        /* Save a private copy of te TOC capacity for error handling */
+        /* save a private copy of the TOC capacity for error handling */
         drive->probed_capacity = toc->capacity * sectors_per_frame;
 
         blk_queue_hardsect_size(drive->queue,
                                 sectors_per_frame << SECTOR_BITS);
 
-        /* First read just the header, so we know how long the TOC is. */
+        /* first read just the header, so we know how long the TOC is */
         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
                                     sizeof(struct atapi_toc_header), sense);
         if (stat)
@@ -1517,7 +1417,7 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
         if (ntracks > MAX_TRACKS)
                 ntracks = MAX_TRACKS;
 
-        /* Now read the whole schmeer. */
+        /* now read the whole schmeer */
         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
                                   (char *)&toc->hdr,
                                    sizeof(struct atapi_toc_header) +
@@ -1525,15 +1425,18 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
                                    sizeof(struct atapi_toc_entry), sense);
 
         if (stat && toc->hdr.first_track > 1) {
-                /* Cds with CDI tracks only don't have any TOC entries,
-                   despite of this the returned values are
-                   first_track == last_track = number of CDI tracks + 1,
-                   so that this case is indistinguishable from the same
-                   layout plus an additional audio track.
-                   If we get an error for the regular case, we assume
-                   a CDI without additional audio tracks. In this case
-                   the readable TOC is empty (CDI tracks are not included)
-                   and only holds the Leadout entry. Heiko Eißfeldt */
+                /*
+                 * Cds with CDI tracks only don't have any TOC entries, despite
+                 * of this the returned values are
+                 * first_track == last_track = number of CDI tracks + 1,
+                 * so that this case is indistinguishable from the same layout
+                 * plus an additional audio track. If we get an error for the
+                 * regular case, we assume a CDI without additional audio
+                 * tracks. In this case the readable TOC is empty (CDI tracks
+                 * are not included) and only holds the Leadout entry.
+                 *
+                 * Heiko Eißfeldt.
+                 */
                 ntracks = 0;
                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
                                            (char *)&toc->hdr,
@@ -1569,14 +1472,13 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
                         msf_from_bcd(&toc->ent[i].addr.msf);
                 }
-                toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
-                                                   toc->ent[i].addr.msf.second,
-                                                   toc->ent[i].addr.msf.frame);
+                toc->ent[i].addr.lba = msf_to_lba(toc->ent[i].addr.msf.minute,
+                                                  toc->ent[i].addr.msf.second,
+                                                  toc->ent[i].addr.msf.frame);
         }
 
-        /* Read the multisession information. */
         if (toc->hdr.first_track != CDROM_LEADOUT) {
-                /* Read the multisession information. */
+                /* read the multisession information */
                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
                                            sizeof(ms_tmp), sense);
                 if (stat)
@@ -1584,26 +1486,27 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
 
                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
         } else {
-                ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
+                ms_tmp.hdr.last_track = CDROM_LEADOUT;
+                ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
         }
 
         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
-                /* Re-read multisession information using MSF format */
+                /* re-read multisession information using MSF format */
                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
                                            sizeof(ms_tmp), sense);
                 if (stat)
                         return stat;
 
-                msf_from_bcd (&ms_tmp.ent.addr.msf);
+                msf_from_bcd(&ms_tmp.ent.addr.msf);
                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
-                                                   ms_tmp.ent.addr.msf.second,
+                                                   ms_tmp.ent.addr.msf.second,
                                                    ms_tmp.ent.addr.msf.frame);
         }
 
         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
 
-        /* Now try to get the total cdrom capacity. */
+        /* now try to get the total cdrom capacity */
         stat = cdrom_get_last_written(cdi, &last_written);
         if (!stat && (last_written > toc->capacity)) {
                 toc->capacity = last_written;
@@ -1628,7 +1531,8 @@ int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
 
         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
-        do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
+        do {
+                /* we seem to get stat=0x01,err=0x00 the first time (??) */
                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
                 if (!stat)
                         break;
@@ -1679,7 +1583,7 @@ static struct cdrom_device_ops ide_cdrom_dops = {
         .generic_packet         = ide_cdrom_packet,
 };
 
-static int ide_cdrom_register (ide_drive_t *drive, int nslots)
+static int ide_cdrom_register(ide_drive_t *drive, int nslots)
 {
         struct cdrom_info *info = drive->driver_data;
         struct cdrom_device_info *devinfo = &info->devinfo;
@@ -1697,8 +1601,7 @@ static int ide_cdrom_register (ide_drive_t *drive, int nslots)
         return register_cdrom(devinfo);
 }
 
-static
-int ide_cdrom_probe_capabilities (ide_drive_t *drive)
+static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
 {
         struct cdrom_info *cd = drive->driver_data;
         struct cdrom_device_info *cdi = &cd->devinfo;
@@ -1712,7 +1615,8 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
 
         if (drive->media == ide_optical) {
                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
-                printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
+                printk(KERN_ERR "%s: ATAPI magneto-optical drive\n",
+                                drive->name);
                 return nslots;
         }
 
@@ -1723,11 +1627,10 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
         }
 
         /*
-         * we have to cheat a little here. the packet will eventually
-         * be queued with ide_cdrom_packet(), which extracts the
-         * drive from cdi->handle. Since this device hasn't been
-         * registered with the Uniform layer yet, it can't do this.
-         * Same goes for cdi->ops.
+         * We have to cheat a little here. the packet will eventually be queued
+         * with ide_cdrom_packet(), which extracts the drive from cdi->handle.
+         * Since this device hasn't been registered with the Uniform layer yet,
+         * it can't do this. Same goes for cdi->ops.
          */
         cdi->handle = drive;
         cdi->ops = &ide_cdrom_dops;
@@ -1796,18 +1699,7 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
         return nslots;
 }
 
-#ifdef CONFIG_IDE_PROC_FS
-static void ide_cdrom_add_settings(ide_drive_t *drive)
-{
-        ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
-}
-#else
-static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
-#endif
-
-/*
- * standard prep_rq_fn that builds 10 byte cmds
- */
+/* standard prep_rq_fn that builds 10 byte cmds */
 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
 {
         int hard_sect = queue_hardsect_size(q);
@@ -1846,9 +1738,7 @@ static int ide_cdrom_prep_pc(struct request *rq)
 {
         u8 *c = rq->cmd;
 
-        /*
-         * Transform 6-byte read/write commands to the 10-byte version
-         */
+        /* transform 6-byte read/write commands to the 10-byte version */
         if (c[0] == READ_6 || c[0] == WRITE_6) {
                 c[8] = c[4];
                 c[5] = c[3];
@@ -1870,7 +1760,7 @@ static int ide_cdrom_prep_pc(struct request *rq)
                 rq->errors = ILLEGAL_REQUEST;
                 return BLKPREP_KILL;
         }
-        
+
         return BLKPREP_OK;
 }
 
@@ -1890,6 +1780,41 @@ struct cd_list_entry {
         unsigned int    cd_flags;
 };
 
+#ifdef CONFIG_IDE_PROC_FS
+static sector_t ide_cdrom_capacity(ide_drive_t *drive)
+{
+        unsigned long capacity, sectors_per_frame;
+
+        if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
+                return 0;
+
+        return capacity * sectors_per_frame;
+}
+
+static int proc_idecd_read_capacity(char *page, char **start, off_t off,
+                                        int count, int *eof, void *data)
+{
+        ide_drive_t *drive = data;
+        int len;
+
+        len = sprintf(page, "%llu\n", (long long)ide_cdrom_capacity(drive));
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
+}
+
+static ide_proc_entry_t idecd_proc[] = {
+        { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
+        { NULL, 0, NULL, NULL }
+};
+
+static void ide_cdrom_add_settings(ide_drive_t *drive)
+{
+        ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
+                        &drive->dsc_overlap, NULL);
+}
+#else
+static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
+#endif
+
 static const struct cd_list_entry ide_cd_quirks_list[] = {
         /* Limit transfer size per interrupt. */
         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
@@ -1947,8 +1872,7 @@ static unsigned int ide_cd_flags(struct hd_driveid *id)
         return 0;
 }
 
-static
-int ide_cdrom_setup (ide_drive_t *drive)
+static int ide_cdrom_setup(ide_drive_t *drive)
 {
         struct cdrom_info *cd = drive->driver_data;
         struct cdrom_device_info *cdi = &cd->devinfo;
@@ -1977,21 +1901,19 @@ int ide_cdrom_setup (ide_drive_t *drive)
                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
-                cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
+                /* 3 => use CD in slot 0 */
+                cdi->sanyo_slot = 3;
 
-        nslots = ide_cdrom_probe_capabilities (drive);
+        nslots = ide_cdrom_probe_capabilities(drive);
 
-        /*
-         * set correct block size
-         */
+        /* set correct block size */
         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
 
-        if (drive->autotune == IDE_TUNE_DEFAULT ||
-            drive->autotune == IDE_TUNE_AUTO)
-                drive->dsc_overlap = (drive->next != drive);
+        drive->dsc_overlap = (drive->next != drive);
 
         if (ide_cdrom_register(drive, nslots)) {
-                printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
+                printk(KERN_ERR "%s: %s failed to register device with the"
+                                " cdrom driver.\n", drive->name, __func__);
                 cd->devinfo.handle = NULL;
                 return 1;
         }
@@ -1999,19 +1921,6 @@ int ide_cdrom_setup (ide_drive_t *drive)
         return 0;
 }
 
-#ifdef CONFIG_IDE_PROC_FS
-static
-sector_t ide_cdrom_capacity (ide_drive_t *drive)
-{
-        unsigned long capacity, sectors_per_frame;
-
-        if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
-                return 0;
-
-        return capacity * sectors_per_frame;
-}
-#endif
-
 static void ide_cd_remove(ide_drive_t *drive)
 {
         struct cdrom_info *info = drive->driver_data;
@@ -2030,7 +1939,6 @@ static void ide_cd_release(struct kref *kref)
         ide_drive_t *drive = info->drive;
         struct gendisk *g = info->disk;
 
-        kfree(info->buffer);
         kfree(info->toc);
         if (devinfo->handle == drive)
                 unregister_cdrom(devinfo);
@@ -2044,23 +1952,6 @@ static void ide_cd_release(struct kref *kref)
 
 static int ide_cd_probe(ide_drive_t *);
 
-#ifdef CONFIG_IDE_PROC_FS
-static int proc_idecd_read_capacity
-        (char *page, char **start, off_t off, int count, int *eof, void *data)
-{
-        ide_drive_t *drive = data;
-        int len;
-
-        len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
-}
-
-static ide_proc_entry_t idecd_proc[] = {
-        { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
-        { NULL, 0, NULL, NULL }
-};
-#endif
-
 static ide_driver_t ide_cdrom_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
@@ -2081,20 +1972,17 @@ static ide_driver_t ide_cdrom_driver = {
 #endif
 };
 
-static int idecd_open(struct inode * inode, struct file * file)
+static int idecd_open(struct inode *inode, struct file *file)
 {
         struct gendisk *disk = inode->i_bdev->bd_disk;
         struct cdrom_info *info;
         int rc = -ENOMEM;
 
-        if (!(info = ide_cd_get(disk)))
+        info = ide_cd_get(disk);
+        if (!info)
                 return -ENXIO;
 
-        if (!info->buffer)
-                info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
-
-        if (info->buffer)
-                rc = cdrom_open(&info->devinfo, inode, file);
+        rc = cdrom_open(&info->devinfo, inode, file);
 
         if (rc < 0)
                 ide_cd_put(info);
@@ -2102,12 +1990,12 @@ static int idecd_open(struct inode * inode, struct file * file)
         return rc;
 }
 
-static int idecd_release(struct inode * inode, struct file * file)
+static int idecd_release(struct inode *inode, struct file *file)
 {
         struct gendisk *disk = inode->i_bdev->bd_disk;
         struct cdrom_info *info = ide_cd_g(disk);
 
-        cdrom_release (&info->devinfo, file);
+        cdrom_release(&info->devinfo, file);
 
         ide_cd_put(info);
 
@@ -2139,7 +2027,7 @@ static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
         struct packet_command cgc;
         char buffer[16];
         int stat;
-        char spindown;
+        char spindown;
 
         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
 
@@ -2148,12 +2036,12 @@ static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
                 return stat;
 
         spindown = buffer[11] & 0x0f;
-        if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
+        if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
                 return -EFAULT;
         return 0;
 }
 
-static int idecd_ioctl (struct inode *inode, struct file *file,
+static int idecd_ioctl(struct inode *inode, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
@@ -2161,13 +2049,13 @@ static int idecd_ioctl (struct inode *inode, struct file *file,
         int err;
 
         switch (cmd) {
-        case CDROMSETSPINDOWN:
+        case CDROMSETSPINDOWN:
                 return idecd_set_spindown(&info->devinfo, arg);
-        case CDROMGETSPINDOWN:
+        case CDROMGETSPINDOWN:
                 return idecd_get_spindown(&info->devinfo, arg);
         default:
                 break;
-        }
+        }
 
         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
         if (err == -EINVAL)
@@ -2193,16 +2081,16 @@ static int idecd_revalidate_disk(struct gendisk *disk)
 }
 
 static struct block_device_operations idecd_ops = {
-        .owner          = THIS_MODULE,
-        .open           = idecd_open,
-        .release        = idecd_release,
-        .ioctl          = idecd_ioctl,
-        .media_changed  = idecd_media_changed,
-        .revalidate_disk= idecd_revalidate_disk
+        .owner                  = THIS_MODULE,
+        .open                   = idecd_open,
+        .release                = idecd_release,
+        .ioctl                  = idecd_ioctl,
+        .media_changed          = idecd_media_changed,
+        .revalidate_disk        = idecd_revalidate_disk
 };
 
-/* options */
-static char *ignore = NULL;
+/* module options */
+static char *ignore;
 
 module_param(ignore, charp, 0400);
 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
@@ -2222,17 +2110,20 @@ static int ide_cd_probe(ide_drive_t *drive)
         /* skip drives that we were told to ignore */
         if (ignore != NULL) {
                 if (strstr(ignore, drive->name)) {
-                        printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
+                        printk(KERN_INFO "ide-cd: ignoring drive %s\n",
+                                         drive->name);
                         goto failed;
                 }
         }
         if (drive->scsi) {
-                printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
+                printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi "
+                                 "emulation.\n", drive->name);
                 goto failed;
         }
         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
         if (info == NULL) {
-                printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
+                printk(KERN_ERR "%s: Can't allocate a cdrom structure\n",
+                                drive->name);
                 goto failed;
         }
 
diff --git a/drivers/ide/ide-cd.h b/drivers/ide/ide-cd.h
index 22e3751a681e..a58801c4484d 100644
--- a/drivers/ide/ide-cd.h
+++ b/drivers/ide/ide-cd.h
@@ -119,10 +119,6 @@ struct cdrom_info {
 
         struct atapi_toc *toc;
 
-        unsigned long   sector_buffered;
-        unsigned long   nsectors_buffered;
-        unsigned char   *buffer;
-
         /* The result of the last successful request sense command
            on this device. */
         struct request_sense sense_data;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 39501d130256..8e08d083fce9 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -16,8 +16,6 @@
 
 #define IDEDISK_VERSION "1.18"
 
-//#define DEBUG
-
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
@@ -88,7 +86,7 @@ static void ide_disk_put(struct ide_disk_obj *idkp)
  *
  * It is called only once for each drive.
  */
-static int lba_capacity_is_ok (struct hd_driveid *id)
+static int lba_capacity_is_ok(struct hd_driveid *id)
 {
         unsigned long lba_sects, chs_sects, head, tail;
 
@@ -176,7 +174,8 @@ static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
  * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
  * using LBA if supported, or CHS otherwise, to address sectors.
  */
-static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
+static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
+                                        sector_t block)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned int dma        = drive->using_dma;
@@ -228,7 +227,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                         tf->device = (block >> 8) & 0xf;
                 }
         } else {
-                unsigned int sect,head,cyl,track;
+                unsigned int sect, head, cyl, track;
+
                 track = (int)block / drive->sect;
                 sect  = (int)block % drive->sect + 1;
                 head  = track % drive->head;
@@ -271,7 +271,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
  * 1073741822 == 549756 MB or 48bit addressing fake drive
  */
 
-static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
+static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
+                                      sector_t block)
 {
         ide_hwif_t *hwif = HWIF(drive);
 
@@ -452,7 +453,7 @@ static void idedisk_check_hpa(ide_drive_t *drive)
  * in above order (i.e., if value of higher priority is available,
  * reset will be ignored).
  */
-static void init_idedisk_capacity (ide_drive_t  *drive)
+static void init_idedisk_capacity(ide_drive_t *drive)
 {
         struct hd_driveid *id = drive->id;
         /*
@@ -479,7 +480,7 @@ static void init_idedisk_capacity (ide_drive_t  *drive)
         }
 }
 
-static sector_t idedisk_capacity (ide_drive_t *drive)
+static sector_t idedisk_capacity(ide_drive_t *drive)
 {
         return drive->capacity64 - drive->sect0;
 }
@@ -524,10 +525,11 @@ static int proc_idedisk_read_cache
         int             len;
 
         if (drive->id_read)
-                len = sprintf(out,"%i\n", drive->id->buf_size / 2);
+                len = sprintf(out, "%i\n", drive->id->buf_size / 2);
         else
-                len = sprintf(out,"(none)\n");
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+                len = sprintf(out, "(none)\n");
+
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int proc_idedisk_read_capacity
@@ -536,54 +538,52 @@ static int proc_idedisk_read_capacity
         ide_drive_t*drive = (ide_drive_t *)data;
         int len;
 
-        len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
+
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
-static int proc_idedisk_read_smart_thresholds
-        (char *page, char **start, off_t off, int count, int *eof, void *data)
+static int proc_idedisk_read_smart(char *page, char **start, off_t off,
+                                   int count, int *eof, void *data, u8 sub_cmd)
 {
         ide_drive_t     *drive = (ide_drive_t *)data;
         int             len = 0, i = 0;
 
-        if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
+        if (get_smart_data(drive, page, sub_cmd) == 0) {
                 unsigned short *val = (unsigned short *) page;
                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
                 page = out;
                 do {
-                        out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
+                        out += sprintf(out, "%04x%c", le16_to_cpu(*val),
+                                       (++i & 7) ? ' ' : '\n');
                         val += 1;
                 } while (i < (SECTOR_WORDS * 2));
                 len = out - page;
         }
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
-static int proc_idedisk_read_smart_values
+static int proc_idedisk_read_sv
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        ide_drive_t     *drive = (ide_drive_t *)data;
-        int             len = 0, i = 0;
+        return proc_idedisk_read_smart(page, start, off, count, eof, data,
+                                       SMART_READ_VALUES);
+}
 
-        if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
-                unsigned short *val = (unsigned short *) page;
-                char *out = ((char *)val) + (SECTOR_WORDS * 4);
-                page = out;
-                do {
-                        out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
-                        val += 1;
-                } while (i < (SECTOR_WORDS * 2));
-                len = out - page;
-        }
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+static int proc_idedisk_read_st
+        (char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+        return proc_idedisk_read_smart(page, start, off, count, eof, data,
+                                       SMART_READ_THRESHOLDS);
 }
 
 static ide_proc_entry_t idedisk_proc[] = {
-        { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
-        { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
-        { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
-        { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
-        { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
+        { "cache",        S_IFREG|S_IRUGO, proc_idedisk_read_cache,    NULL },
+        { "capacity",     S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
+        { "geometry",     S_IFREG|S_IRUGO, proc_ide_read_geometry,     NULL },
+        { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv,       NULL },
+        { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st,   NULL },
         { NULL, 0, NULL, NULL }
 };
 #endif  /* CONFIG_IDE_PROC_FS */
@@ -625,12 +625,13 @@ static int set_multcount(ide_drive_t *drive, int arg)
         if (drive->special.b.set_multmode)
                 return -EBUSY;
 
-        ide_init_drive_cmd (&rq);
+        ide_init_drive_cmd(&rq);
         rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
 
         drive->mult_req = arg;
         drive->special.b.set_multmode = 1;
-        (void) ide_do_drive_cmd (drive, &rq, ide_wait);
+        (void)ide_do_drive_cmd(drive, &rq, ide_wait);
+
         return (drive->mult_count == arg) ? 0 : -EIO;
 }
 
@@ -706,7 +707,7 @@ static int write_cache(ide_drive_t *drive, int arg)
         return err;
 }
 
-static int do_idedisk_flushcache (ide_drive_t *drive)
+static int do_idedisk_flushcache(ide_drive_t *drive)
 {
         ide_task_t args;
 
@@ -719,7 +720,7 @@ static int do_idedisk_flushcache (ide_drive_t *drive)
         return ide_no_data_taskfile(drive, &args);
 }
 
-static int set_acoustic (ide_drive_t *drive, int arg)
+static int set_acoustic(ide_drive_t *drive, int arg)
 {
         ide_task_t args;
 
@@ -753,7 +754,7 @@ static int set_lba_addressing(ide_drive_t *drive, int arg)
                 return 0;
 
         if (!idedisk_supports_lba48(drive->id))
-                return -EIO;
+                return -EIO;
         drive->addressing = arg;
         return 0;
 }
@@ -763,23 +764,35 @@ static void idedisk_add_settings(ide_drive_t *drive)
 {
         struct hd_driveid *id = drive->id;
 
-        ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
-        ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
-        ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
-        ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
-        ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
-        ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
-        ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
-        ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
-        ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
-        ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
-        ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
+        ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
+                        &drive->bios_cyl, NULL);
+        ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
+                        &drive->bios_head, NULL);
+        ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
+                        &drive->bios_sect, NULL);
+        ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
+                        &drive->addressing, set_lba_addressing);
+        ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
+                        id->max_multsect, 1, 1, &drive->mult_count,
+                        set_multcount);
+        ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
+                        &drive->nowerr, set_nowerr);
+        ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
+                        &drive->lun, NULL);
+        ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
+                        &drive->wcache, write_cache);
+        ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
+                        &drive->acoustic, set_acoustic);
+        ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
+                        &drive->failures, NULL);
+        ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
+                        1, 1, &drive->max_failures, NULL);
 }
 #else
 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
 #endif
 
-static void idedisk_setup (ide_drive_t *drive)
+static void idedisk_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
         struct hd_driveid *id = drive->id;
@@ -792,11 +805,10 @@ static void idedisk_setup (ide_drive_t *drive)
 
         if (drive->removable) {
                 /*
-                 * Removable disks (eg. SYQUEST); ignore 'WD' drives 
+                 * Removable disks (eg. SYQUEST); ignore 'WD' drives
                  */
-                if (id->model[0] != 'W' || id->model[1] != 'D') {
+                if (id->model[0] != 'W' || id->model[1] != 'D')
                         drive->doorlocking = 1;
-                }
         }
 
         (void)set_lba_addressing(drive, 1);
@@ -810,10 +822,11 @@ static void idedisk_setup (ide_drive_t *drive)
                 blk_queue_max_sectors(drive->queue, max_s);
         }
 
-        printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
+        printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
+                         drive->queue->max_sectors / 2);
 
         /* calculate drive capacity, and select LBA if possible */
-        init_idedisk_capacity (drive);
+        init_idedisk_capacity(drive);
 
         /* limit drive capacity to 137GB if LBA48 cannot be used */
         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
@@ -826,9 +839,9 @@ static void idedisk_setup (ide_drive_t *drive)
 
         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
                 if (drive->capacity64 > 1ULL << 28) {
-                        printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
-                                         " be used for accessing sectors > %u\n",
-                                         drive->name, 1 << 28);
+                        printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
+                                         " will be used for accessing sectors "
+                                         "> %u\n", drive->name, 1 << 28);
                 } else
                         drive->addressing = 0;
         }
@@ -837,7 +850,8 @@ static void idedisk_setup (ide_drive_t *drive)
          * if possible, give fdisk access to more of the drive,
          * by correcting bios_cyls:
          */
-        capacity = idedisk_capacity (drive);
+        capacity = idedisk_capacity(drive);
+
         if (!drive->forced_geom) {
 
                 if (idedisk_supports_lba48(drive->id)) {
@@ -993,7 +1007,8 @@ static int idedisk_open(struct inode *inode, struct file *filp)
         struct ide_disk_obj *idkp;
         ide_drive_t *drive;
 
-        if (!(idkp = ide_disk_get(disk)))
+        idkp = ide_disk_get(disk);
+        if (idkp == NULL)
                 return -ENXIO;
 
         drive = idkp->drive;
@@ -1115,13 +1130,13 @@ static int idedisk_revalidate_disk(struct gendisk *disk)
 }
 
 static struct block_device_operations idedisk_ops = {
-        .owner          = THIS_MODULE,
-        .open           = idedisk_open,
-        .release        = idedisk_release,
-        .ioctl          = idedisk_ioctl,
-        .getgeo         = idedisk_getgeo,
-        .media_changed  = idedisk_media_changed,
-        .revalidate_disk= idedisk_revalidate_disk
+        .owner                  = THIS_MODULE,
+        .open                   = idedisk_open,
+        .release                = idedisk_release,
+        .ioctl                  = idedisk_ioctl,
+        .getgeo                 = idedisk_getgeo,
+        .media_changed          = idedisk_media_changed,
+        .revalidate_disk        = idedisk_revalidate_disk
 };
 
 MODULE_DESCRIPTION("ATA DISK Driver");
@@ -1184,7 +1199,7 @@ failed:
         return -ENODEV;
 }
 
-static void __exit idedisk_exit (void)
+static void __exit idedisk_exit(void)
 {
         driver_unregister(&idedisk_driver.gen_driver);
 }
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index d61e5788d310..c352cf27b6e7 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -102,7 +102,7 @@ ide_startstop_t ide_dma_intr (ide_drive_t *drive)
 {
         u8 stat = 0, dma_stat = 0;
 
-        dma_stat = HWIF(drive)->ide_dma_end(drive);
+        dma_stat = drive->hwif->dma_ops->dma_end(drive);
         stat = ide_read_status(drive);
 
         if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
@@ -394,7 +394,7 @@ void ide_dma_off_quietly(ide_drive_t *drive)
         drive->using_dma = 0;
         ide_toggle_bounce(drive, 0);
 
-        drive->hwif->dma_host_set(drive, 0);
+        drive->hwif->dma_ops->dma_host_set(drive, 0);
 }
 
 EXPORT_SYMBOL(ide_dma_off_quietly);
@@ -427,7 +427,7 @@ void ide_dma_on(ide_drive_t *drive)
         drive->using_dma = 1;
         ide_toggle_bounce(drive, 1);
 
-        drive->hwif->dma_host_set(drive, 1);
+        drive->hwif->dma_ops->dma_host_set(drive, 1);
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
@@ -482,11 +482,12 @@ int ide_dma_setup(ide_drive_t *drive)
 
 EXPORT_SYMBOL_GPL(ide_dma_setup);
 
-static void ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
+void ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
 {
         /* issue cmd to drive */
         ide_execute_command(drive, command, &ide_dma_intr, 2*WAIT_CMD, dma_timer_expiry);
 }
+EXPORT_SYMBOL_GPL(ide_dma_exec_cmd);
 
 void ide_dma_start(ide_drive_t *drive)
 {
@@ -532,7 +533,7 @@ int __ide_dma_end (ide_drive_t *drive)
 EXPORT_SYMBOL(__ide_dma_end);
 
 /* returns 1 if dma irq issued, 0 otherwise */
-static int __ide_dma_test_irq(ide_drive_t *drive)
+int ide_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         u8 dma_stat             = hwif->INB(hwif->dma_status);
@@ -542,9 +543,10 @@ static int __ide_dma_test_irq(ide_drive_t *drive)
                 return 1;
         if (!drive->waiting_for_dma)
                 printk(KERN_WARNING "%s: (%s) called while not waiting\n",
-                        drive->name, __FUNCTION__);
+                        drive->name, __func__);
         return 0;
 }
+EXPORT_SYMBOL_GPL(ide_dma_test_irq);
 #else
 static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
@@ -574,6 +576,7 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
 {
         struct hd_driveid *id = drive->id;
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
         unsigned int mask = 0;
 
         switch(base) {
@@ -581,8 +584,8 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
                 if ((id->field_valid & 4) == 0)
                         break;
 
-                if (hwif->udma_filter)
-                        mask = hwif->udma_filter(drive);
+                if (port_ops && port_ops->udma_filter)
+                        mask = port_ops->udma_filter(drive);
                 else
                         mask = hwif->ultra_mask;
                 mask &= id->dma_ultra;
@@ -598,8 +601,8 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
         case XFER_MW_DMA_0:
                 if ((id->field_valid & 2) == 0)
                         break;
-                if (hwif->mdma_filter)
-                        mask = hwif->mdma_filter(drive);
+                if (port_ops && port_ops->mdma_filter)
+                        mask = port_ops->mdma_filter(drive);
                 else
                         mask = hwif->mwdma_mask;
                 mask &= id->dma_mword;
@@ -703,17 +706,8 @@ static int ide_tune_dma(ide_drive_t *drive)
 
         speed = ide_max_dma_mode(drive);
 
-        if (!speed) {
-                 /* is this really correct/needed? */
-                if ((hwif->host_flags & IDE_HFLAG_CY82C693) &&
-                    ide_dma_good_drive(drive))
-                        return 1;
-                else
-                        return 0;
-        }
-
-        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
-                return 1;
+        if (!speed)
+                return 0;
 
         if (ide_set_dma_mode(drive, speed))
                 return 0;
@@ -810,15 +804,15 @@ void ide_dma_timeout (ide_drive_t *drive)
 
         printk(KERN_ERR "%s: timeout waiting for DMA\n", drive->name);
 
-        if (hwif->ide_dma_test_irq(drive))
+        if (hwif->dma_ops->dma_test_irq(drive))
                 return;
 
-        hwif->ide_dma_end(drive);
+        hwif->dma_ops->dma_end(drive);
 }
 
 EXPORT_SYMBOL(ide_dma_timeout);
 
-static void ide_release_dma_engine(ide_hwif_t *hwif)
+void ide_release_dma_engine(ide_hwif_t *hwif)
 {
         if (hwif->dmatable_cpu) {
                 struct pci_dev *pdev = to_pci_dev(hwif->dev);
@@ -829,28 +823,7 @@ static void ide_release_dma_engine(ide_hwif_t *hwif)
         }
 }
 
-static int ide_release_iomio_dma(ide_hwif_t *hwif)
-{
-        release_region(hwif->dma_base, 8);
-        if (hwif->extra_ports)
-                release_region(hwif->extra_base, hwif->extra_ports);
-        return 1;
-}
-
-/*
- * Needed for allowing full modular support of ide-driver
- */
-int ide_release_dma(ide_hwif_t *hwif)
-{
-        ide_release_dma_engine(hwif);
-
-        if (hwif->mmio)
-                return 1;
-        else
-                return ide_release_iomio_dma(hwif);
-}
-
-static int ide_allocate_dma_engine(ide_hwif_t *hwif)
+int ide_allocate_dma_engine(ide_hwif_t *hwif)
 {
         struct pci_dev *pdev = to_pci_dev(hwif->dev);
 
@@ -862,65 +835,25 @@ static int ide_allocate_dma_engine(ide_hwif_t *hwif)
                 return 0;
 
         printk(KERN_ERR "%s: -- Error, unable to allocate DMA table.\n",
-               hwif->cds->name);
+                        hwif->name);
 
         return 1;
 }
-
-static int ide_mapped_mmio_dma(ide_hwif_t *hwif, unsigned long base)
-{
-        printk(KERN_INFO "    %s: MMIO-DMA ", hwif->name);
-
-        return 0;
-}
-
-static int ide_iomio_dma(ide_hwif_t *hwif, unsigned long base)
-{
-        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx",
-               hwif->name, base, base + 7);
-
-        if (!request_region(base, 8, hwif->name)) {
-                printk(" -- Error, ports in use.\n");
-                return 1;
-        }
-
-        if (hwif->cds->extra) {
-                hwif->extra_base = base + (hwif->channel ? 8 : 16);
-
-                if (!hwif->mate || !hwif->mate->extra_ports) {
-                        if (!request_region(hwif->extra_base,
-                                            hwif->cds->extra, hwif->cds->name)) {
-                                printk(" -- Error, extra ports in use.\n");
-                                release_region(base, 8);
-                                return 1;
-                        }
-                        hwif->extra_ports = hwif->cds->extra;
-                }
-        }
-
-        return 0;
-}
-
-static int ide_dma_iobase(ide_hwif_t *hwif, unsigned long base)
-{
-        if (hwif->mmio)
-                return ide_mapped_mmio_dma(hwif, base);
-
-        return ide_iomio_dma(hwif, base);
-}
+EXPORT_SYMBOL_GPL(ide_allocate_dma_engine);
+
+static const struct ide_dma_ops sff_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_timeout            = ide_dma_timeout,
+        .dma_lost_irq           = ide_dma_lost_irq,
+};
 
 void ide_setup_dma(ide_hwif_t *hwif, unsigned long base)
 {
-        u8 dma_stat;
-
-        if (ide_dma_iobase(hwif, base))
-                return;
-
-        if (ide_allocate_dma_engine(hwif)) {
-                ide_release_dma(hwif);
-                return;
-        }
-
         hwif->dma_base = base;
 
         if (!hwif->dma_command)
@@ -934,27 +867,7 @@ void ide_setup_dma(ide_hwif_t *hwif, unsigned long base)
         if (!hwif->dma_prdtable)
                 hwif->dma_prdtable      = hwif->dma_base + 4;
 
-        if (!hwif->dma_host_set)
-                hwif->dma_host_set = &ide_dma_host_set;
-        if (!hwif->dma_setup)
-                hwif->dma_setup = &ide_dma_setup;
-        if (!hwif->dma_exec_cmd)
-                hwif->dma_exec_cmd = &ide_dma_exec_cmd;
-        if (!hwif->dma_start)
-                hwif->dma_start = &ide_dma_start;
-        if (!hwif->ide_dma_end)
-                hwif->ide_dma_end = &__ide_dma_end;
-        if (!hwif->ide_dma_test_irq)
-                hwif->ide_dma_test_irq = &__ide_dma_test_irq;
-        if (!hwif->dma_timeout)
-                hwif->dma_timeout = &ide_dma_timeout;
-        if (!hwif->dma_lost_irq)
-                hwif->dma_lost_irq = &ide_dma_lost_irq;
-
-        dma_stat = hwif->INB(hwif->dma_status);
-        printk(KERN_CONT ", BIOS settings: %s:%s, %s:%s\n",
-               hwif->drives[0].name, (dma_stat & 0x20) ? "DMA" : "PIO",
-               hwif->drives[1].name, (dma_stat & 0x40) ? "DMA" : "PIO");
+        hwif->dma_ops = &sff_dma_ops;
 }
 
 EXPORT_SYMBOL_GPL(ide_setup_dma);
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 5f133dfb541c..489079b8ed03 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -396,7 +396,7 @@ static void idefloppy_retry_pc(ide_drive_t *drive)
 }
 
 /* The usual interrupt handler called during a packet command. */
-static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
+static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
 {
         idefloppy_floppy_t *floppy = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
@@ -411,7 +411,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
         debug_log("Reached %s interrupt handler\n", __func__);
 
         if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
-                dma_error = hwif->ide_dma_end(drive);
+                dma_error = hwif->dma_ops->dma_end(drive);
                 if (dma_error) {
                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
                                         rq_data_dir(rq) ? "write" : "read");
@@ -465,10 +465,10 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
         }
 
         /* Get the number of bytes to transfer */
-        bcount = (hwif->INB(hwif->io_ports[IDE_BCOUNTH_OFFSET]) << 8) |
-                  hwif->INB(hwif->io_ports[IDE_BCOUNTL_OFFSET]);
+        bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) |
+                  hwif->INB(hwif->io_ports.lbam_addr);
         /* on this interrupt */
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
 
         if (ireason & CD) {
                 printk(KERN_ERR "ide-floppy: CoD != 0 in %s\n", __func__);
@@ -539,7 +539,7 @@ static ide_startstop_t idefloppy_transfer_pc(ide_drive_t *drive)
                                 "initiated yet DRQ isn't asserted\n");
                 return startstop;
         }
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
         if ((ireason & CD) == 0 || (ireason & IO)) {
                 printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) while "
                                 "issuing a packet command\n");
@@ -586,7 +586,7 @@ static ide_startstop_t idefloppy_transfer_pc1(ide_drive_t *drive)
                                 "initiated yet DRQ isn't asserted\n");
                 return startstop;
         }
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
         if ((ireason & CD) == 0 || (ireason & IO)) {
                 printk(KERN_ERR "ide-floppy: (IO,CoD) != (0,1) "
                                 "while issuing a packet command\n");
@@ -663,7 +663,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
         dma = 0;
 
         if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
-                dma = !hwif->dma_setup(drive);
+                dma = !hwif->dma_ops->dma_setup(drive);
 
         ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
                            IDE_TFLAG_OUT_DEVICE, bcount, dma);
@@ -671,7 +671,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
         if (dma) {
                 /* Begin DMA, if necessary */
                 pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
-                hwif->dma_start(drive);
+                hwif->dma_ops->dma_start(drive);
         }
 
         /* Can we transfer the packet when we get the interrupt or wait? */
@@ -692,7 +692,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
                 return ide_started;
         } else {
                 /* Issue the packet command */
-                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports.command_addr);
                 return (*pkt_xfer_routine) (drive);
         }
 }
@@ -1596,13 +1596,13 @@ static int idefloppy_revalidate_disk(struct gendisk *disk)
 }
 
 static struct block_device_operations idefloppy_ops = {
-        .owner          = THIS_MODULE,
-        .open           = idefloppy_open,
-        .release        = idefloppy_release,
-        .ioctl          = idefloppy_ioctl,
-        .getgeo         = idefloppy_getgeo,
-        .media_changed  = idefloppy_media_changed,
-        .revalidate_disk= idefloppy_revalidate_disk
+        .owner                  = THIS_MODULE,
+        .open                   = idefloppy_open,
+        .release                = idefloppy_release,
+        .ioctl                  = idefloppy_ioctl,
+        .getgeo                 = idefloppy_getgeo,
+        .media_changed          = idefloppy_media_changed,
+        .revalidate_disk        = idefloppy_revalidate_disk
 };
 
 static int ide_floppy_probe(ide_drive_t *drive)
diff --git a/drivers/ide/ide-generic.c b/drivers/ide/ide-generic.c
index 25fda0a3263f..a6073e248f45 100644
--- a/drivers/ide/ide-generic.c
+++ b/drivers/ide/ide-generic.c
@@ -33,7 +33,7 @@ static ssize_t store_add(struct class *cls, const char *buf, size_t n)
         if (sscanf(buf, "%x:%x:%d", &base, &ctl, &irq) != 3)
                 return -EINVAL;
 
-        hwif = ide_find_port(base);
+        hwif = ide_find_port();
         if (hwif == NULL)
                 return -ENOENT;
 
@@ -90,19 +90,45 @@ static int __init ide_generic_init(void)
         int i;
 
         for (i = 0; i < MAX_HWIFS; i++) {
-                ide_hwif_t *hwif = &ide_hwifs[i];
+                ide_hwif_t *hwif;
                 unsigned long io_addr = ide_default_io_base(i);
                 hw_regs_t hw;
 
-                if (hwif->chipset == ide_unknown && io_addr) {
+                idx[i] = 0xff;
+
+                if (io_addr) {
+                        if (!request_region(io_addr, 8, DRV_NAME)) {
+                                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX "
+                                                "not free.\n",
+                                                DRV_NAME, io_addr, io_addr + 7);
+                                continue;
+                        }
+
+                        if (!request_region(io_addr + 0x206, 1, DRV_NAME)) {
+                                printk(KERN_ERR "%s: I/O resource 0x%lX "
+                                                "not free.\n",
+                                                DRV_NAME, io_addr + 0x206);
+                                release_region(io_addr, 8);
+                                continue;
+                        }
+
+                        /*
+                         * Skip probing if the corresponding
+                         * slot is already occupied.
+                         */
+                        hwif = ide_find_port();
+                        if (hwif == NULL || hwif->index != i) {
+                                idx[i] = 0xff;
+                                continue;
+                        }
+
                         memset(&hw, 0, sizeof(hw));
                         ide_std_init_ports(&hw, io_addr, io_addr + 0x206);
                         hw.irq = ide_default_irq(io_addr);
                         ide_init_port_hw(hwif, &hw);
 
                         idx[i] = i;
-                } else
-                        idx[i] = 0xff;
+                }
         }
 
         ide_device_add_all(idx, NULL);
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 31e5afadb7e9..3a2d8930d17f 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -218,7 +218,7 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
                  * we could be smarter and check for current xfer_speed
                  * in struct drive etc...
                  */
-                if (drive->hwif->dma_host_set == NULL)
+                if (drive->hwif->dma_ops == NULL)
                         break;
                 /*
                  * TODO: respect ->using_dma setting
@@ -298,48 +298,43 @@ static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq)
 void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
 {
         ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         struct ide_taskfile *tf = &task->tf;
 
         if (task->tf_flags & IDE_TFLAG_IN_DATA) {
-                u16 data = hwif->INW(hwif->io_ports[IDE_DATA_OFFSET]);
+                u16 data = hwif->INW(io_ports->data_addr);
 
                 tf->data = data & 0xff;
                 tf->hob_data = (data >> 8) & 0xff;
         }
 
         /* be sure we're looking at the low order bits */
-        hwif->OUTB(drive->ctl & ~0x80, hwif->io_ports[IDE_CONTROL_OFFSET]);
+        hwif->OUTB(drive->ctl & ~0x80, io_ports->ctl_addr);
 
         if (task->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = hwif->INB(hwif->io_ports[IDE_NSECTOR_OFFSET]);
+                tf->nsect  = hwif->INB(io_ports->nsect_addr);
         if (task->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = hwif->INB(hwif->io_ports[IDE_SECTOR_OFFSET]);
+                tf->lbal   = hwif->INB(io_ports->lbal_addr);
         if (task->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = hwif->INB(hwif->io_ports[IDE_LCYL_OFFSET]);
+                tf->lbam   = hwif->INB(io_ports->lbam_addr);
         if (task->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = hwif->INB(hwif->io_ports[IDE_HCYL_OFFSET]);
+                tf->lbah   = hwif->INB(io_ports->lbah_addr);
         if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = hwif->INB(hwif->io_ports[IDE_SELECT_OFFSET]);
+                tf->device = hwif->INB(io_ports->device_addr);
 
         if (task->tf_flags & IDE_TFLAG_LBA48) {
-                hwif->OUTB(drive->ctl | 0x80,
-                           hwif->io_ports[IDE_CONTROL_OFFSET]);
+                hwif->OUTB(drive->ctl | 0x80, io_ports->ctl_addr);
 
                 if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
-                        tf->hob_feature =
-                                hwif->INB(hwif->io_ports[IDE_FEATURE_OFFSET]);
+                        tf->hob_feature = hwif->INB(io_ports->feature_addr);
                 if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect   =
-                                hwif->INB(hwif->io_ports[IDE_NSECTOR_OFFSET]);
+                        tf->hob_nsect   = hwif->INB(io_ports->nsect_addr);
                 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal    =
-                                hwif->INB(hwif->io_ports[IDE_SECTOR_OFFSET]);
+                        tf->hob_lbal    = hwif->INB(io_ports->lbal_addr);
                 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam    =
-                                hwif->INB(hwif->io_ports[IDE_LCYL_OFFSET]);
+                        tf->hob_lbam    = hwif->INB(io_ports->lbam_addr);
                 if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah    =
-                                hwif->INB(hwif->io_ports[IDE_HCYL_OFFSET]);
+                        tf->hob_lbah    = hwif->INB(io_ports->lbah_addr);
         }
 }
 
@@ -454,7 +449,7 @@ static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8
                 if (err == ABRT_ERR) {
                         if (drive->select.b.lba &&
                             /* some newer drives don't support WIN_SPECIFY */
-                            hwif->INB(hwif->io_ports[IDE_COMMAND_OFFSET]) ==
+                            hwif->INB(hwif->io_ports.command_addr) ==
                                 WIN_SPECIFY)
                                 return ide_stopped;
                 } else if ((err & BAD_CRC) == BAD_CRC) {
@@ -507,8 +502,7 @@ static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u
 
         if (ide_read_status(drive) & (BUSY_STAT | DRQ_STAT))
                 /* force an abort */
-                hwif->OUTB(WIN_IDLEIMMEDIATE,
-                           hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTB(WIN_IDLEIMMEDIATE, hwif->io_ports.command_addr);
 
         if (rq->errors >= ERROR_MAX) {
                 ide_kill_rq(drive, rq);
@@ -721,15 +715,12 @@ static ide_startstop_t do_special (ide_drive_t *drive)
 #endif
         if (s->b.set_tune) {
                 ide_hwif_t *hwif = drive->hwif;
+                const struct ide_port_ops *port_ops = hwif->port_ops;
                 u8 req_pio = drive->tune_req;
 
                 s->b.set_tune = 0;
 
                 if (set_pio_mode_abuse(drive->hwif, req_pio)) {
-
-                        if (hwif->set_pio_mode == NULL)
-                                return ide_stopped;
-
                         /*
                          * take ide_lock for drive->[no_]unmask/[no_]io_32bit
                          */
@@ -737,10 +728,10 @@ static ide_startstop_t do_special (ide_drive_t *drive)
                                 unsigned long flags;
 
                                 spin_lock_irqsave(&ide_lock, flags);
-                                hwif->set_pio_mode(drive, req_pio);
+                                port_ops->set_pio_mode(drive, req_pio);
                                 spin_unlock_irqrestore(&ide_lock, flags);
                         } else
-                                hwif->set_pio_mode(drive, req_pio);
+                                port_ops->set_pio_mode(drive, req_pio);
                 } else {
                         int keep_dma = drive->using_dma;
 
@@ -1241,12 +1232,12 @@ static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
 
         if (error < 0) {
                 printk(KERN_WARNING "%s: DMA timeout error\n", drive->name);
-                (void)HWIF(drive)->ide_dma_end(drive);
+                (void)hwif->dma_ops->dma_end(drive);
                 ret = ide_error(drive, "dma timeout error",
                                 ide_read_status(drive));
         } else {
                 printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name);
-                hwif->dma_timeout(drive);
+                hwif->dma_ops->dma_timeout(drive);
         }
 
         /*
@@ -1358,7 +1349,7 @@ void ide_timer_expiry (unsigned long data)
                                 startstop = handler(drive);
                         } else if (drive_is_ready(drive)) {
                                 if (drive->waiting_for_dma)
-                                        hwgroup->hwif->dma_lost_irq(drive);
+                                        hwif->dma_ops->dma_lost_irq(drive);
                                 (void)ide_ack_intr(hwif);
                                 printk(KERN_WARNING "%s: lost interrupt\n", drive->name);
                                 startstop = handler(drive);
@@ -1424,7 +1415,7 @@ static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
          */
         do {
                 if (hwif->irq == irq) {
-                        stat = hwif->INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                        stat = hwif->INB(hwif->io_ports.status_addr);
                         if (!OK_STAT(stat, READY_STAT, BAD_STAT)) {
                                 /* Try to not flood the console with msgs */
                                 static unsigned long last_msgtime, count;
@@ -1514,7 +1505,7 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                          * Whack the status register, just in case
                          * we have a leftover pending IRQ.
                          */
-                        (void) hwif->INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                        (void) hwif->INB(hwif->io_ports.status_addr);
 #endif /* CONFIG_BLK_DEV_IDEPCI */
                 }
                 spin_unlock_irqrestore(&ide_lock, flags);
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 45944219eea0..5425d3038ec2 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -159,17 +159,20 @@ EXPORT_SYMBOL(default_hwif_mmiops);
 void SELECT_DRIVE (ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
 
-        if (hwif->selectproc)
-                hwif->selectproc(drive);
+        if (port_ops && port_ops->selectproc)
+                port_ops->selectproc(drive);
 
-        hwif->OUTB(drive->select.all, hwif->io_ports[IDE_SELECT_OFFSET]);
+        hwif->OUTB(drive->select.all, hwif->io_ports.device_addr);
 }
 
 void SELECT_MASK (ide_drive_t *drive, int mask)
 {
-        if (HWIF(drive)->maskproc)
-                HWIF(drive)->maskproc(drive, mask);
+        const struct ide_port_ops *port_ops = drive->hwif->port_ops;
+
+        if (port_ops && port_ops->maskproc)
+                port_ops->maskproc(drive, mask);
 }
 
 /*
@@ -191,24 +194,22 @@ static void ata_vlb_sync(ide_drive_t *drive, unsigned long port)
  */
 static void ata_input_data(ide_drive_t *drive, void *buffer, u32 wcount)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
-        u8 io_32bit             = drive->io_32bit;
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        u8 io_32bit = drive->io_32bit;
 
         if (io_32bit) {
                 if (io_32bit & 2) {
                         unsigned long flags;
 
                         local_irq_save(flags);
-                        ata_vlb_sync(drive, hwif->io_ports[IDE_NSECTOR_OFFSET]);
-                        hwif->INSL(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                                   wcount);
+                        ata_vlb_sync(drive, io_ports->nsect_addr);
+                        hwif->INSL(io_ports->data_addr, buffer, wcount);
                         local_irq_restore(flags);
                 } else
-                        hwif->INSL(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                                   wcount);
+                        hwif->INSL(io_ports->data_addr, buffer, wcount);
         } else
-                hwif->INSW(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                           wcount << 1);
+                hwif->INSW(io_ports->data_addr, buffer, wcount << 1);
 }
 
 /*
@@ -216,24 +217,22 @@ static void ata_input_data(ide_drive_t *drive, void *buffer, u32 wcount)
  */
 static void ata_output_data(ide_drive_t *drive, void *buffer, u32 wcount)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
-        u8 io_32bit             = drive->io_32bit;
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        u8 io_32bit = drive->io_32bit;
 
         if (io_32bit) {
                 if (io_32bit & 2) {
                         unsigned long flags;
 
                         local_irq_save(flags);
-                        ata_vlb_sync(drive, hwif->io_ports[IDE_NSECTOR_OFFSET]);
-                        hwif->OUTSL(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                                    wcount);
+                        ata_vlb_sync(drive, io_ports->nsect_addr);
+                        hwif->OUTSL(io_ports->data_addr, buffer, wcount);
                         local_irq_restore(flags);
                 } else
-                        hwif->OUTSL(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                                    wcount);
+                        hwif->OUTSL(io_ports->data_addr, buffer, wcount);
         } else
-                hwif->OUTSW(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                            wcount << 1);
+                hwif->OUTSW(io_ports->data_addr, buffer, wcount << 1);
 }
 
 /*
@@ -252,14 +251,13 @@ static void atapi_input_bytes(ide_drive_t *drive, void *buffer, u32 bytecount)
 #if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
         if (MACH_IS_ATARI || MACH_IS_Q40) {
                 /* Atari has a byte-swapped IDE interface */
-                insw_swapw(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                           bytecount / 2);
+                insw_swapw(hwif->io_ports.data_addr, buffer, bytecount / 2);
                 return;
         }
 #endif /* CONFIG_ATARI || CONFIG_Q40 */
         hwif->ata_input_data(drive, buffer, bytecount / 4);
         if ((bytecount & 0x03) >= 2)
-                hwif->INSW(hwif->io_ports[IDE_DATA_OFFSET],
+                hwif->INSW(hwif->io_ports.data_addr,
                            (u8 *)buffer + (bytecount & ~0x03), 1);
 }
 
@@ -271,14 +269,13 @@ static void atapi_output_bytes(ide_drive_t *drive, void *buffer, u32 bytecount)
 #if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
         if (MACH_IS_ATARI || MACH_IS_Q40) {
                 /* Atari has a byte-swapped IDE interface */
-                outsw_swapw(hwif->io_ports[IDE_DATA_OFFSET], buffer,
-                            bytecount / 2);
+                outsw_swapw(hwif->io_ports.data_addr, buffer, bytecount / 2);
                 return;
         }
 #endif /* CONFIG_ATARI || CONFIG_Q40 */
         hwif->ata_output_data(drive, buffer, bytecount / 4);
         if ((bytecount & 0x03) >= 2)
-                hwif->OUTSW(hwif->io_ports[IDE_DATA_OFFSET],
+                hwif->OUTSW(hwif->io_ports.data_addr,
                             (u8 *)buffer + (bytecount & ~0x03), 1);
 }
 
@@ -429,7 +426,7 @@ int drive_is_ready (ide_drive_t *drive)
         u8 stat                 = 0;
 
         if (drive->waiting_for_dma)
-                return hwif->ide_dma_test_irq(drive);
+                return hwif->dma_ops->dma_test_irq(drive);
 
 #if 0
         /* need to guarantee 400ns since last command was issued */
@@ -442,7 +439,7 @@ int drive_is_ready (ide_drive_t *drive)
          * an interrupt with another pci card/device.  We make no assumptions
          * about possible isa-pnp and pci-pnp issues yet.
          */
-        if (hwif->io_ports[IDE_CONTROL_OFFSET])
+        if (hwif->io_ports.ctl_addr)
                 stat = ide_read_altstatus(drive);
         else
                 /* Note: this may clear a pending IRQ!! */
@@ -644,7 +641,7 @@ int ide_driveid_update(ide_drive_t *drive)
         SELECT_MASK(drive, 1);
         ide_set_irq(drive, 1);
         msleep(50);
-        hwif->OUTB(WIN_IDENTIFY, hwif->io_ports[IDE_COMMAND_OFFSET]);
+        hwif->OUTB(WIN_IDENTIFY, hwif->io_ports.command_addr);
         timeout = jiffies + WAIT_WORSTCASE;
         do {
                 if (time_after(jiffies, timeout)) {
@@ -693,6 +690,7 @@ int ide_driveid_update(ide_drive_t *drive)
 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 {
         ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         int error = 0;
         u8 stat;
 
@@ -700,8 +698,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 //              msleep(50);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-        if (hwif->dma_host_set) /* check if host supports DMA */
-                hwif->dma_host_set(drive, 0);
+        if (hwif->dma_ops)      /* check if host supports DMA */
+                hwif->dma_ops->dma_host_set(drive, 0);
 #endif
 
         /* Skip setting PIO flow-control modes on pre-EIDE drives */
@@ -731,10 +729,9 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
         SELECT_MASK(drive, 0);
         udelay(1);
         ide_set_irq(drive, 0);
-        hwif->OUTB(speed, hwif->io_ports[IDE_NSECTOR_OFFSET]);
-        hwif->OUTB(SETFEATURES_XFER, hwif->io_ports[IDE_FEATURE_OFFSET]);
-        hwif->OUTBSYNC(drive, WIN_SETFEATURES,
-                       hwif->io_ports[IDE_COMMAND_OFFSET]);
+        hwif->OUTB(speed, io_ports->nsect_addr);
+        hwif->OUTB(SETFEATURES_XFER, io_ports->feature_addr);
+        hwif->OUTBSYNC(drive, WIN_SETFEATURES, io_ports->command_addr);
         if (drive->quirk_list == 2)
                 ide_set_irq(drive, 1);
 
@@ -759,8 +756,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 #ifdef CONFIG_BLK_DEV_IDEDMA
         if ((speed >= XFER_SW_DMA_0 || (hwif->host_flags & IDE_HFLAG_VDMA)) &&
             drive->using_dma)
-                hwif->dma_host_set(drive, 1);
-        else if (hwif->dma_host_set)    /* check if host supports DMA */
+                hwif->dma_ops->dma_host_set(drive, 1);
+        else if (hwif->dma_ops) /* check if host supports DMA */
                 ide_dma_off_quietly(drive);
 #endif
 
@@ -842,7 +839,7 @@ void ide_execute_command(ide_drive_t *drive, u8 cmd, ide_handler_t *handler,
 
         spin_lock_irqsave(&ide_lock, flags);
         __ide_set_handler(drive, handler, timeout, expiry);
-        hwif->OUTBSYNC(drive, cmd, hwif->io_ports[IDE_COMMAND_OFFSET]);
+        hwif->OUTBSYNC(drive, cmd, hwif->io_ports.command_addr);
         /*
          * Drive takes 400nS to respond, we must avoid the IRQ being
          * serviced before that.
@@ -905,10 +902,11 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
 {
         ide_hwgroup_t *hwgroup  = HWGROUP(drive);
         ide_hwif_t *hwif        = HWIF(drive);
+        const struct ide_port_ops *port_ops = hwif->port_ops;
         u8 tmp;
 
-        if (hwif->reset_poll != NULL) {
-                if (hwif->reset_poll(drive)) {
+        if (port_ops && port_ops->reset_poll) {
+                if (port_ops->reset_poll(drive)) {
                         printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
                                 hwif->name, drive->name);
                         return ide_stopped;
@@ -974,6 +972,8 @@ static void ide_disk_pre_reset(ide_drive_t *drive)
 
 static void pre_reset(ide_drive_t *drive)
 {
+        const struct ide_port_ops *port_ops = drive->hwif->port_ops;
+
         if (drive->media == ide_disk)
                 ide_disk_pre_reset(drive);
         else
@@ -994,8 +994,8 @@ static void pre_reset(ide_drive_t *drive)
                 return;
         }
 
-        if (HWIF(drive)->pre_reset != NULL)
-                HWIF(drive)->pre_reset(drive);
+        if (port_ops && port_ops->pre_reset)
+                port_ops->pre_reset(drive);
 
         if (drive->current_speed != 0xff)
                 drive->desired_speed = drive->current_speed;
@@ -1023,12 +1023,16 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
         unsigned long flags;
         ide_hwif_t *hwif;
         ide_hwgroup_t *hwgroup;
+        struct ide_io_ports *io_ports;
+        const struct ide_port_ops *port_ops;
         u8 ctl;
 
         spin_lock_irqsave(&ide_lock, flags);
         hwif = HWIF(drive);
         hwgroup = HWGROUP(drive);
 
+        io_ports = &hwif->io_ports;
+
         /* We must not reset with running handlers */
         BUG_ON(hwgroup->handler != NULL);
 
@@ -1038,8 +1042,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
                 pre_reset(drive);
                 SELECT_DRIVE(drive);
                 udelay (20);
-                hwif->OUTBSYNC(drive, WIN_SRST,
-                               hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTBSYNC(drive, WIN_SRST, io_ports->command_addr);
                 ndelay(400);
                 hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
                 hwgroup->polling = 1;
@@ -1055,7 +1058,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
         for (unit = 0; unit < MAX_DRIVES; ++unit)
                 pre_reset(&hwif->drives[unit]);
 
-        if (hwif->io_ports[IDE_CONTROL_OFFSET] == 0) {
+        if (io_ports->ctl_addr == 0) {
                 spin_unlock_irqrestore(&ide_lock, flags);
                 return ide_stopped;
         }
@@ -1070,14 +1073,14 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
          * recover from reset very quickly, saving us the first 50ms wait time.
          */
         /* set SRST and nIEN */
-        hwif->OUTBSYNC(drive, drive->ctl|6, hwif->io_ports[IDE_CONTROL_OFFSET]);
+        hwif->OUTBSYNC(drive, drive->ctl|6, io_ports->ctl_addr);
         /* more than enough time */
         udelay(10);
         if (drive->quirk_list == 2)
                 ctl = drive->ctl;       /* clear SRST and nIEN */
         else
                 ctl = drive->ctl | 2;   /* clear SRST, leave nIEN */
-        hwif->OUTBSYNC(drive, ctl, hwif->io_ports[IDE_CONTROL_OFFSET]);
+        hwif->OUTBSYNC(drive, ctl, io_ports->ctl_addr);
         /* more than enough time */
         udelay(10);
         hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
@@ -1089,8 +1092,9 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
          * state when the disks are reset this way. At least, the Winbond
          * 553 documentation says that
          */
-        if (hwif->resetproc)
-                hwif->resetproc(drive);
+        port_ops = hwif->port_ops;
+        if (port_ops && port_ops->resetproc)
+                port_ops->resetproc(drive);
 
         spin_unlock_irqrestore(&ide_lock, flags);
         return ide_started;
@@ -1121,7 +1125,7 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
                  * about locking issues (2.5 work ?).
                  */
                 mdelay(1);
-                stat = hwif->INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                stat = hwif->INB(hwif->io_ports.status_addr);
                 if ((stat & BUSY_STAT) == 0)
                         return 0;
                 /*
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 7031a8dcf692..6f04ea3e93a8 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -85,7 +85,7 @@ static u8 ide_rate_filter(ide_drive_t *drive, u8 speed)
                         mode = XFER_PIO_4;
         }
 
-//      printk("%s: mode 0x%02x, speed 0x%02x\n", __FUNCTION__, mode, speed);
+/*      printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */
 
         return min(speed, mode);
 }
@@ -274,16 +274,6 @@ u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
                 if (overridden)
                         printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n",
                                          drive->name);
-
-                /*
-                 * Conservative "downgrade" for all pre-ATA2 drives
-                 */
-                if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_DOWNGRADE) == 0 &&
-                    pio_mode && pio_mode < 4) {
-                        pio_mode--;
-                        printk(KERN_INFO "%s: applying conservative "
-                                         "PIO \"downgrade\"\n", drive->name);
-                }
         }
 
         if (pio_mode > max_mode)
@@ -298,9 +288,11 @@ EXPORT_SYMBOL_GPL(ide_get_best_pio_mode);
 void ide_set_pio(ide_drive_t *drive, u8 req_pio)
 {
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
         u8 host_pio, pio;
 
-        if (hwif->set_pio_mode == NULL)
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
                 return;
 
         BUG_ON(hwif->pio_mask == 0x00);
@@ -352,26 +344,30 @@ void ide_toggle_bounce(ide_drive_t *drive, int on)
 int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
 {
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+
+        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
+                return 0;
 
-        if (hwif->set_pio_mode == NULL)
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL)
                 return -1;
 
         /*
          * TODO: temporary hack for some legacy host drivers that didn't
          * set transfer mode on the device in ->set_pio_mode method...
          */
-        if (hwif->set_dma_mode == NULL) {
-                hwif->set_pio_mode(drive, mode - XFER_PIO_0);
+        if (port_ops->set_dma_mode == NULL) {
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
                 return 0;
         }
 
         if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
                 if (ide_config_drive_speed(drive, mode))
                         return -1;
-                hwif->set_pio_mode(drive, mode - XFER_PIO_0);
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
                 return 0;
         } else {
-                hwif->set_pio_mode(drive, mode - XFER_PIO_0);
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
                 return ide_config_drive_speed(drive, mode);
         }
 }
@@ -379,17 +375,21 @@ int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
 int ide_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+
+        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
+                return 0;
 
-        if (hwif->set_dma_mode == NULL)
+        if (port_ops == NULL || port_ops->set_dma_mode == NULL)
                 return -1;
 
         if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
                 if (ide_config_drive_speed(drive, mode))
                         return -1;
-                hwif->set_dma_mode(drive, mode);
+                port_ops->set_dma_mode(drive, mode);
                 return 0;
         } else {
-                hwif->set_dma_mode(drive, mode);
+                port_ops->set_dma_mode(drive, mode);
                 return ide_config_drive_speed(drive, mode);
         }
 }
@@ -409,8 +409,10 @@ EXPORT_SYMBOL_GPL(ide_set_dma_mode);
 int ide_set_xfer_rate(ide_drive_t *drive, u8 rate)
 {
         ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
 
-        if (hwif->set_dma_mode == NULL)
+        if (port_ops == NULL || port_ops->set_dma_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
                 return -1;
 
         rate = ide_rate_filter(drive, rate);
diff --git a/drivers/ide/ide-pnp.c b/drivers/ide/ide-pnp.c
index 34c2ad36ce54..6a8953f68e9f 100644
--- a/drivers/ide/ide-pnp.c
+++ b/drivers/ide/ide-pnp.c
@@ -11,34 +11,52 @@
  *
  * You should have received a copy of the GNU General Public License
  * (for example /usr/src/linux/COPYING); if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/init.h>
 #include <linux/pnp.h>
 #include <linux/ide.h>
 
+#define DRV_NAME "ide-pnp"
+
 /* Add your devices here :)) */
 static struct pnp_device_id idepnp_devices[] = {
-        /* Generic ESDI/IDE/ATA compatible hard disk controller */
+        /* Generic ESDI/IDE/ATA compatible hard disk controller */
         {.id = "PNP0600", .driver_data = 0},
         {.id = ""}
 };
 
-static int idepnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
+static int idepnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
 {
         hw_regs_t hw;
         ide_hwif_t *hwif;
+        unsigned long base, ctl;
 
         if (!(pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) && pnp_irq_valid(dev, 0)))
                 return -1;
 
+        base = pnp_port_start(dev, 0);
+        ctl = pnp_port_start(dev, 1);
+
+        if (!request_region(base, 8, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                DRV_NAME, base, base + 7);
+                return -EBUSY;
+        }
+
+        if (!request_region(ctl, 1, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                DRV_NAME, ctl);
+                release_region(base, 8);
+                return -EBUSY;
+        }
+
         memset(&hw, 0, sizeof(hw));
-        ide_std_init_ports(&hw, pnp_port_start(dev, 0),
-                                pnp_port_start(dev, 1));
+        ide_std_init_ports(&hw, base, ctl);
         hw.irq = pnp_irq(dev, 0);
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif) {
                 u8 index = hwif->index;
                 u8 idx[4] = { index, 0xff, 0xff, 0xff };
@@ -47,24 +65,27 @@ static int idepnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id
                 ide_init_port_hw(hwif, &hw);
 
                 printk(KERN_INFO "ide%d: generic PnP IDE interface\n", index);
-                pnp_set_drvdata(dev,hwif);
+                pnp_set_drvdata(dev, hwif);
 
                 ide_device_add(idx, NULL);
 
                 return 0;
         }
 
+        release_region(ctl, 1);
+        release_region(base, 8);
+
         return -1;
 }
 
-static void idepnp_remove(struct pnp_dev * dev)
+static void idepnp_remove(struct pnp_dev *dev)
 {
         ide_hwif_t *hwif = pnp_get_drvdata(dev);
 
-        if (hwif)
-                ide_unregister(hwif->index);
-        else
-                printk(KERN_ERR "idepnp: Unable to remove device, please report.\n");
+        ide_unregister(hwif);
+
+        release_region(pnp_port_start(dev, 1), 1);
+        release_region(pnp_port_start(dev, 0), 8);
 }
 
 static struct pnp_driver idepnp_driver = {
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 6a196c27b0aa..862f02603f9b 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -264,6 +264,7 @@ err_misc:
 static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
 {
         ide_hwif_t *hwif = HWIF(drive);
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         int use_altstatus = 0, rc;
         unsigned long timeout;
         u8 s = 0, a = 0;
@@ -271,7 +272,7 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
         /* take a deep breath */
         msleep(50);
 
-        if (hwif->io_ports[IDE_CONTROL_OFFSET]) {
+        if (io_ports->ctl_addr) {
                 a = ide_read_altstatus(drive);
                 s = ide_read_status(drive);
                 if ((a ^ s) & ~INDEX_STAT)
@@ -289,10 +290,10 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
          */
         if ((cmd == WIN_PIDENTIFY))
                 /* disable dma & overlap */
-                hwif->OUTB(0, hwif->io_ports[IDE_FEATURE_OFFSET]);
+                hwif->OUTB(0, io_ports->feature_addr);
 
         /* ask drive for ID */
-        hwif->OUTB(cmd, hwif->io_ports[IDE_COMMAND_OFFSET]);
+        hwif->OUTB(cmd, io_ports->command_addr);
 
         timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
         timeout += jiffies;
@@ -353,7 +354,7 @@ static int try_to_identify (ide_drive_t *drive, u8 cmd)
          * interrupts during the identify-phase that
          * the irq handler isn't expecting.
          */
-        if (hwif->io_ports[IDE_CONTROL_OFFSET]) {
+        if (hwif->io_ports.ctl_addr) {
                 if (!hwif->irq) {
                         autoprobe = 1;
                         cookie = probe_irq_on();
@@ -393,7 +394,7 @@ static int ide_busy_sleep(ide_hwif_t *hwif)
 
         do {
                 msleep(50);
-                stat = hwif->INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                stat = hwif->INB(hwif->io_ports.status_addr);
                 if ((stat & BUSY_STAT) == 0)
                         return 0;
         } while (time_before(jiffies, timeout));
@@ -425,6 +426,7 @@ static int ide_busy_sleep(ide_hwif_t *hwif)
 static int do_probe (ide_drive_t *drive, u8 cmd)
 {
         ide_hwif_t *hwif = HWIF(drive);
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         int rc;
         u8 stat;
 
@@ -445,7 +447,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
         msleep(50);
         SELECT_DRIVE(drive);
         msleep(50);
-        if (hwif->INB(hwif->io_ports[IDE_SELECT_OFFSET]) != drive->select.all &&
+        if (hwif->INB(io_ports->device_addr) != drive->select.all &&
             !drive->present) {
                 if (drive->select.b.unit != 0) {
                         /* exit with drive0 selected */
@@ -472,17 +474,13 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
                 if (stat == (BUSY_STAT | READY_STAT))
                         return 4;
 
-                if ((rc == 1 && cmd == WIN_PIDENTIFY) &&
-                        ((drive->autotune == IDE_TUNE_DEFAULT) ||
-                        (drive->autotune == IDE_TUNE_AUTO))) {
+                if (rc == 1 && cmd == WIN_PIDENTIFY) {
                         printk(KERN_ERR "%s: no response (status = 0x%02x), "
                                         "resetting drive\n", drive->name, stat);
                         msleep(50);
-                        hwif->OUTB(drive->select.all,
-                                   hwif->io_ports[IDE_SELECT_OFFSET]);
+                        hwif->OUTB(drive->select.all, io_ports->device_addr);
                         msleep(50);
-                        hwif->OUTB(WIN_SRST,
-                                   hwif->io_ports[IDE_COMMAND_OFFSET]);
+                        hwif->OUTB(WIN_SRST, io_ports->command_addr);
                         (void)ide_busy_sleep(hwif);
                         rc = try_to_identify(drive, cmd);
                 }
@@ -518,7 +516,7 @@ static void enable_nest (ide_drive_t *drive)
         printk("%s: enabling %s -- ", hwif->name, drive->id->model);
         SELECT_DRIVE(drive);
         msleep(50);
-        hwif->OUTB(EXABYTE_ENABLE_NEST, hwif->io_ports[IDE_COMMAND_OFFSET]);
+        hwif->OUTB(EXABYTE_ENABLE_NEST, hwif->io_ports.command_addr);
 
         if (ide_busy_sleep(hwif)) {
                 printk(KERN_CONT "failed (timeout)\n");
@@ -644,7 +642,7 @@ static int ide_register_port(ide_hwif_t *hwif)
         ret = device_register(&hwif->gendev);
         if (ret < 0) {
                 printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
-                        __FUNCTION__, ret);
+                        __func__, ret);
                 goto out;
         }
 
@@ -773,8 +771,7 @@ static int ide_probe_port(ide_hwif_t *hwif)
 
         BUG_ON(hwif->present);
 
-        if (hwif->noprobe ||
-            (hwif->drives[0].noprobe && hwif->drives[1].noprobe))
+        if (hwif->drives[0].noprobe && hwif->drives[1].noprobe)
                 return -EACCES;
 
         /*
@@ -801,14 +798,9 @@ static int ide_probe_port(ide_hwif_t *hwif)
                 if (drive->present)
                         rc = 0;
         }
-        if (hwif->io_ports[IDE_CONTROL_OFFSET] && hwif->reset) {
-                printk(KERN_WARNING "%s: reset\n", hwif->name);
-                hwif->OUTB(12, hwif->io_ports[IDE_CONTROL_OFFSET]);
-                udelay(10);
-                hwif->OUTB(8, hwif->io_ports[IDE_CONTROL_OFFSET]);
-                (void)ide_busy_sleep(hwif);
-        }
+
         local_irq_restore(flags);
+
         /*
          * Use cached IRQ number. It might be (and is...) changed by probe
          * code above
@@ -821,29 +813,25 @@ static int ide_probe_port(ide_hwif_t *hwif)
 
 static void ide_port_tune_devices(ide_hwif_t *hwif)
 {
+        const struct ide_port_ops *port_ops = hwif->port_ops;
         int unit;
 
         for (unit = 0; unit < MAX_DRIVES; unit++) {
                 ide_drive_t *drive = &hwif->drives[unit];
 
-                if (drive->present && hwif->quirkproc)
-                        hwif->quirkproc(drive);
+                if (drive->present && port_ops && port_ops->quirkproc)
+                        port_ops->quirkproc(drive);
         }
 
         for (unit = 0; unit < MAX_DRIVES; ++unit) {
                 ide_drive_t *drive = &hwif->drives[unit];
 
                 if (drive->present) {
-                        if (drive->autotune == IDE_TUNE_AUTO)
-                                ide_set_max_pio(drive);
-
-                        if (drive->autotune != IDE_TUNE_DEFAULT &&
-                            drive->autotune != IDE_TUNE_AUTO)
-                                continue;
+                        ide_set_max_pio(drive);
 
                         drive->nice1 = 1;
 
-                        if (hwif->dma_host_set)
+                        if (hwif->dma_ops)
                                 ide_set_dma(drive);
                 }
         }
@@ -994,6 +982,7 @@ static void ide_port_setup_devices(ide_hwif_t *hwif)
  */
 static int init_irq (ide_hwif_t *hwif)
 {
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         unsigned int index;
         ide_hwgroup_t *hwgroup;
         ide_hwif_t *match = NULL;
@@ -1077,9 +1066,9 @@ static int init_irq (ide_hwif_t *hwif)
                 if (IDE_CHIPSET_IS_PCI(hwif->chipset))
                         sa = IRQF_SHARED;
 
-                if (hwif->io_ports[IDE_CONTROL_OFFSET])
+                if (io_ports->ctl_addr)
                         /* clear nIEN */
-                        hwif->OUTB(0x08, hwif->io_ports[IDE_CONTROL_OFFSET]);
+                        hwif->OUTB(0x08, io_ports->ctl_addr);
 
                 if (request_irq(hwif->irq,&ide_intr,sa,hwif->name,hwgroup))
                         goto out_unlink;
@@ -1095,12 +1084,11 @@ static int init_irq (ide_hwif_t *hwif)
 
 #if !defined(__mc68000__)
         printk("%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
-                hwif->io_ports[IDE_DATA_OFFSET],
-                hwif->io_ports[IDE_DATA_OFFSET]+7,
-                hwif->io_ports[IDE_CONTROL_OFFSET], hwif->irq);
+                io_ports->data_addr, io_ports->status_addr,
+                io_ports->ctl_addr, hwif->irq);
 #else
         printk("%s at 0x%08lx on irq %d", hwif->name,
-                hwif->io_ports[IDE_DATA_OFFSET], hwif->irq);
+                io_ports->data_addr, hwif->irq);
 #endif /* __mc68000__ */
         if (match)
                 printk(" (%sed with %s)",
@@ -1242,8 +1230,8 @@ static int hwif_init(ide_hwif_t *hwif)
         int old_irq;
 
         if (!hwif->irq) {
-                if (!(hwif->irq = ide_default_irq(hwif->io_ports[IDE_DATA_OFFSET])))
-                {
+                hwif->irq = ide_default_irq(hwif->io_ports.data_addr);
+                if (!hwif->irq) {
                         printk("%s: DISABLED, NO IRQ\n", hwif->name);
                         return 0;
                 }
@@ -1272,7 +1260,8 @@ static int hwif_init(ide_hwif_t *hwif)
          *      It failed to initialise. Find the default IRQ for 
          *      this port and try that.
          */
-        if (!(hwif->irq = ide_default_irq(hwif->io_ports[IDE_DATA_OFFSET]))) {
+        hwif->irq = ide_default_irq(hwif->io_ports.data_addr);
+        if (!hwif->irq) {
                 printk("%s: Disabled unable to get IRQ %d.\n",
                         hwif->name, old_irq);
                 goto out;
@@ -1324,6 +1313,7 @@ static void hwif_register_devices(ide_hwif_t *hwif)
 
 static void ide_port_init_devices(ide_hwif_t *hwif)
 {
+        const struct ide_port_ops *port_ops = hwif->port_ops;
         int i;
 
         for (i = 0; i < MAX_DRIVES; i++) {
@@ -1335,12 +1325,10 @@ static void ide_port_init_devices(ide_hwif_t *hwif)
                         drive->unmask = 1;
                 if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
                         drive->no_unmask = 1;
-                if ((hwif->host_flags & IDE_HFLAG_NO_AUTOTUNE) == 0)
-                        drive->autotune = 1;
         }
 
-        if (hwif->port_init_devs)
-                hwif->port_init_devs(hwif);
+        if (port_ops && port_ops->port_init_devs)
+                port_ops->port_init_devs(hwif);
 }
 
 static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
@@ -1355,9 +1343,6 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
         if (d->init_iops)
                 d->init_iops(hwif);
 
-        if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0)
-                ide_hwif_setup_dma(hwif, d);
-
         if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) ||
             (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
                 hwif->irq = port ? 15 : 14;
@@ -1365,16 +1350,36 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
         hwif->host_flags = d->host_flags;
         hwif->pio_mask = d->pio_mask;
 
-        if ((d->host_flags & IDE_HFLAG_SERIALIZE) && hwif->mate)
-                hwif->mate->serialized = hwif->serialized = 1;
+        /* ->set_pio_mode for DTC2278 is currently limited to port 0 */
+        if (hwif->chipset != ide_dtc2278 || hwif->channel == 0)
+                hwif->port_ops = d->port_ops;
+
+        if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
+            ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
+                if (hwif->mate)
+                        hwif->mate->serialized = hwif->serialized = 1;
+        }
 
         hwif->swdma_mask = d->swdma_mask;
         hwif->mwdma_mask = d->mwdma_mask;
         hwif->ultra_mask = d->udma_mask;
 
-        /* reset DMA masks only for SFF-style DMA controllers */
-        if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0 && hwif->dma_base == 0)
-                hwif->swdma_mask = hwif->mwdma_mask = hwif->ultra_mask = 0;
+        if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
+                int rc;
+
+                if (d->init_dma)
+                        rc = d->init_dma(hwif, d);
+                else
+                        rc = ide_hwif_setup_dma(hwif, d);
+
+                if (rc < 0) {
+                        printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
+                        hwif->swdma_mask = 0;
+                        hwif->mwdma_mask = 0;
+                        hwif->ultra_mask = 0;
+                } else if (d->dma_ops)
+                        hwif->dma_ops = d->dma_ops;
+        }
 
         if (d->host_flags & IDE_HFLAG_RQSIZE_256)
                 hwif->rqsize = 256;
@@ -1386,9 +1391,11 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
 
 static void ide_port_cable_detect(ide_hwif_t *hwif)
 {
-        if (hwif->cable_detect && (hwif->ultra_mask & 0x78)) {
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+
+        if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
                 if (hwif->cbl != ATA_CBL_PATA40_SHORT)
-                        hwif->cbl = hwif->cable_detect(hwif);
+                        hwif->cbl = port_ops->cable_detect(hwif);
         }
 }
 
@@ -1444,19 +1451,74 @@ static int ide_sysfs_register_port(ide_hwif_t *hwif)
         return rc;
 }
 
+/**
+ *      ide_find_port_slot      -       find free ide_hwifs[] slot
+ *      @d: IDE port info
+ *
+ *      Return the new hwif.  If we are out of free slots return NULL.
+ */
+
+ide_hwif_t *ide_find_port_slot(const struct ide_port_info *d)
+{
+        ide_hwif_t *hwif;
+        int i;
+        u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
+
+        /*
+         * Claim an unassigned slot.
+         *
+         * Give preference to claiming other slots before claiming ide0/ide1,
+         * just in case there's another interface yet-to-be-scanned
+         * which uses ports 0x1f0/0x170 (the ide0/ide1 defaults).
+         *
+         * Unless there is a bootable card that does not use the standard
+         * ports 0x1f0/0x170 (the ide0/ide1 defaults).
+         */
+        if (bootable) {
+                i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;
+
+                for (; i < MAX_HWIFS; i++) {
+                        hwif = &ide_hwifs[i];
+                        if (hwif->chipset == ide_unknown)
+                                return hwif;
+                }
+        } else {
+                for (i = 2; i < MAX_HWIFS; i++) {
+                        hwif = &ide_hwifs[i];
+                        if (hwif->chipset == ide_unknown)
+                                return hwif;
+                }
+                for (i = 0; i < 2 && i < MAX_HWIFS; i++) {
+                        hwif = &ide_hwifs[i];
+                        if (hwif->chipset == ide_unknown)
+                                return hwif;
+                }
+        }
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(ide_find_port_slot);
+
 int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
 {
         ide_hwif_t *hwif, *mate = NULL;
         int i, rc = 0;
 
         for (i = 0; i < MAX_HWIFS; i++) {
-                if (d == NULL || idx[i] == 0xff) {
+                if (idx[i] == 0xff) {
                         mate = NULL;
                         continue;
                 }
 
                 hwif = &ide_hwifs[idx[i]];
 
+                ide_port_apply_params(hwif);
+
+                if (d == NULL) {
+                        mate = NULL;
+                        continue;
+                }
+
                 if (d->chipset != ide_etrax100 && (i & 1) && mate) {
                         hwif->mate = mate;
                         mate->mate = hwif;
@@ -1475,25 +1537,15 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
 
                 hwif = &ide_hwifs[idx[i]];
 
-                if ((hwif->chipset != ide_4drives || !hwif->mate ||
-                     !hwif->mate->present) && ide_hwif_request_regions(hwif)) {
-                        printk(KERN_ERR "%s: ports already in use, "
-                                        "skipping probe\n", hwif->name);
-                        continue;
-                }
-
-                if (ide_probe_port(hwif) < 0) {
-                        ide_hwif_release_regions(hwif);
-                        continue;
-                }
-
-                hwif->present = 1;
+                if (ide_probe_port(hwif) == 0)
+                        hwif->present = 1;
 
                 if (hwif->chipset != ide_4drives || !hwif->mate ||
                     !hwif->mate->present)
                         ide_register_port(hwif);
 
-                ide_port_tune_devices(hwif);
+                if (hwif->present)
+                        ide_port_tune_devices(hwif);
         }
 
         for (i = 0; i < MAX_HWIFS; i++) {
@@ -1502,9 +1554,6 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
 
                 hwif = &ide_hwifs[idx[i]];
 
-                if (!hwif->present)
-                        continue;
-
                 if (hwif_init(hwif) == 0) {
                         printk(KERN_INFO "%s: failed to initialize IDE "
                                          "interface\n", hwif->name);
@@ -1513,10 +1562,13 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
                         continue;
                 }
 
-                ide_port_setup_devices(hwif);
+                if (hwif->present)
+                        ide_port_setup_devices(hwif);
 
                 ide_acpi_init(hwif);
-                ide_acpi_port_init_devices(hwif);
+
+                if (hwif->present)
+                        ide_acpi_port_init_devices(hwif);
         }
 
         for (i = 0; i < MAX_HWIFS; i++) {
@@ -1525,11 +1577,11 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
 
                 hwif = &ide_hwifs[idx[i]];
 
-                if (hwif->present) {
-                        if (hwif->chipset == ide_unknown)
-                                hwif->chipset = ide_generic;
+                if (hwif->chipset == ide_unknown)
+                        hwif->chipset = ide_generic;
+
+                if (hwif->present)
                         hwif_register_devices(hwif);
-                }
         }
 
         for (i = 0; i < MAX_HWIFS; i++) {
@@ -1538,11 +1590,11 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
 
                 hwif = &ide_hwifs[idx[i]];
 
-                if (hwif->present) {
-                        ide_sysfs_register_port(hwif);
-                        ide_proc_register_port(hwif);
+                ide_sysfs_register_port(hwif);
+                ide_proc_register_port(hwif);
+
+                if (hwif->present)
                         ide_proc_port_register_devices(hwif);
-                }
         }
 
         return rc;
@@ -1563,6 +1615,7 @@ EXPORT_SYMBOL_GPL(ide_device_add);
 
 void ide_port_scan(ide_hwif_t *hwif)
 {
+        ide_port_apply_params(hwif);
         ide_port_cable_detect(hwif);
         ide_port_init_devices(hwif);
 
@@ -1578,3 +1631,67 @@ void ide_port_scan(ide_hwif_t *hwif)
         ide_proc_port_register_devices(hwif);
 }
 EXPORT_SYMBOL_GPL(ide_port_scan);
+
+static void ide_legacy_init_one(u8 *idx, hw_regs_t *hw, u8 port_no,
+                                const struct ide_port_info *d,
+                                unsigned long config)
+{
+        ide_hwif_t *hwif;
+        unsigned long base, ctl;
+        int irq;
+
+        if (port_no == 0) {
+                base = 0x1f0;
+                ctl  = 0x3f6;
+                irq  = 14;
+        } else {
+                base = 0x170;
+                ctl  = 0x376;
+                irq  = 15;
+        }
+
+        if (!request_region(base, 8, d->name)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                d->name, base, base + 7);
+                return;
+        }
+
+        if (!request_region(ctl, 1, d->name)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                d->name, ctl);
+                release_region(base, 8);
+                return;
+        }
+
+        ide_std_init_ports(hw, base, ctl);
+        hw->irq = irq;
+
+        hwif = ide_find_port_slot(d);
+        if (hwif) {
+                ide_init_port_hw(hwif, hw);
+                if (config)
+                        hwif->config_data = config;
+                idx[port_no] = hwif->index;
+        }
+}
+
+int ide_legacy_device_add(const struct ide_port_info *d, unsigned long config)
+{
+        u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
+        hw_regs_t hw[2];
+
+        memset(&hw, 0, sizeof(hw));
+
+        if ((d->host_flags & IDE_HFLAG_QD_2ND_PORT) == 0)
+                ide_legacy_init_one(idx, &hw[0], 0, d, config);
+        ide_legacy_init_one(idx, &hw[1], 1, d, config);
+
+        if (idx[0] == 0xff && idx[1] == 0xff &&
+            (d->host_flags & IDE_HFLAG_SINGLE))
+                return -ENOENT;
+
+        ide_device_add(idx, d);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ide_legacy_device_add);
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index edd7f186dc4d..7b2f3815a838 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -47,28 +47,28 @@ static int proc_ide_read_imodel
         const char      *name;
 
         switch (hwif->chipset) {
-                case ide_generic:       name = "generic";       break;
-                case ide_pci:           name = "pci";           break;
-                case ide_cmd640:        name = "cmd640";        break;
-                case ide_dtc2278:       name = "dtc2278";       break;
-                case ide_ali14xx:       name = "ali14xx";       break;
-                case ide_qd65xx:        name = "qd65xx";        break;
-                case ide_umc8672:       name = "umc8672";       break;
-                case ide_ht6560b:       name = "ht6560b";       break;
-                case ide_rz1000:        name = "rz1000";        break;
-                case ide_trm290:        name = "trm290";        break;
-                case ide_cmd646:        name = "cmd646";        break;
-                case ide_cy82c693:      name = "cy82c693";      break;
-                case ide_4drives:       name = "4drives";       break;
-                case ide_pmac:          name = "mac-io";        break;
-                case ide_au1xxx:        name = "au1xxx";        break;
-                case ide_palm3710:      name = "palm3710";      break;
-                case ide_etrax100:      name = "etrax100";      break;
-                case ide_acorn:         name = "acorn";         break;
-                default:                name = "(unknown)";     break;
+        case ide_generic:       name = "generic";       break;
+        case ide_pci:           name = "pci";           break;
+        case ide_cmd640:        name = "cmd640";        break;
+        case ide_dtc2278:       name = "dtc2278";       break;
+        case ide_ali14xx:       name = "ali14xx";       break;
+        case ide_qd65xx:        name = "qd65xx";        break;
+        case ide_umc8672:       name = "umc8672";       break;
+        case ide_ht6560b:       name = "ht6560b";       break;
+        case ide_rz1000:        name = "rz1000";        break;
+        case ide_trm290:        name = "trm290";        break;
+        case ide_cmd646:        name = "cmd646";        break;
+        case ide_cy82c693:      name = "cy82c693";      break;
+        case ide_4drives:       name = "4drives";       break;
+        case ide_pmac:          name = "mac-io";        break;
+        case ide_au1xxx:        name = "au1xxx";        break;
+        case ide_palm3710:      name = "palm3710";      break;
+        case ide_etrax100:      name = "etrax100";      break;
+        case ide_acorn:         name = "acorn";         break;
+        default:                name = "(unknown)";     break;
         }
         len = sprintf(page, "%s\n", name);
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int proc_ide_read_mate
@@ -81,7 +81,7 @@ static int proc_ide_read_mate
                 len = sprintf(page, "%s\n", hwif->mate->name);
         else
                 len = sprintf(page, "(none)\n");
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int proc_ide_read_channel
@@ -93,7 +93,7 @@ static int proc_ide_read_channel
         page[0] = hwif->channel ? '1' : '0';
         page[1] = '\n';
         len = 2;
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int proc_ide_read_identify
@@ -120,7 +120,7 @@ static int proc_ide_read_identify
                         len = out - page;
                 }
         }
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 /**
@@ -197,7 +197,7 @@ EXPORT_SYMBOL(ide_add_setting);
  *      The caller must hold the setting semaphore.
  */
 
-static void __ide_remove_setting (ide_drive_t *drive, char *name)
+static void __ide_remove_setting(ide_drive_t *drive, char *name)
 {
         ide_settings_t **p, *setting;
 
@@ -205,7 +205,8 @@ static void __ide_remove_setting (ide_drive_t *drive, char *name)
 
         while ((*p) && strcmp((*p)->name, name))
                 p = &((*p)->next);
-        if ((setting = (*p)) == NULL)
+        setting = (*p);
+        if (setting == NULL)
                 return;
 
         (*p) = setting->next;
@@ -223,7 +224,7 @@ static void __ide_remove_setting (ide_drive_t *drive, char *name)
  *      caller must hold ide_setting_mtx.
  */
 
-static void auto_remove_settings (ide_drive_t *drive)
+static void auto_remove_settings(ide_drive_t *drive)
 {
         ide_settings_t *setting;
 repeat:
@@ -279,16 +280,16 @@ static int ide_read_setting(ide_drive_t *drive, ide_settings_t *setting)
 
         if ((setting->rw & SETTING_READ)) {
                 spin_lock_irqsave(&ide_lock, flags);
-                switch(setting->data_type) {
-                        case TYPE_BYTE:
-                                val = *((u8 *) setting->data);
-                                break;
-                        case TYPE_SHORT:
-                                val = *((u16 *) setting->data);
-                                break;
-                        case TYPE_INT:
-                                val = *((u32 *) setting->data);
-                                break;
+                switch (setting->data_type) {
+                case TYPE_BYTE:
+                        val = *((u8 *) setting->data);
+                        break;
+                case TYPE_SHORT:
+                        val = *((u16 *) setting->data);
+                        break;
+                case TYPE_INT:
+                        val = *((u32 *) setting->data);
+                        break;
                 }
                 spin_unlock_irqrestore(&ide_lock, flags);
         }
@@ -326,15 +327,15 @@ static int ide_write_setting(ide_drive_t *drive, ide_settings_t *setting, int va
         if (ide_spin_wait_hwgroup(drive))
                 return -EBUSY;
         switch (setting->data_type) {
-                case TYPE_BYTE:
-                        *((u8 *) setting->data) = val;
-                        break;
-                case TYPE_SHORT:
-                        *((u16 *) setting->data) = val;
-                        break;
-                case TYPE_INT:
-                        *((u32 *) setting->data) = val;
-                        break;
+        case TYPE_BYTE:
+                *((u8 *) setting->data) = val;
+                break;
+        case TYPE_SHORT:
+                *((u16 *) setting->data) = val;
+                break;
+        case TYPE_INT:
+                *((u32 *) setting->data) = val;
+                break;
         }
         spin_unlock_irq(&ide_lock);
         return 0;
@@ -390,7 +391,7 @@ void ide_add_generic_settings (ide_drive_t *drive)
 
 static void proc_ide_settings_warn(void)
 {
-        static int warned = 0;
+        static int warned;
 
         if (warned)
                 return;
@@ -413,11 +414,12 @@ static int proc_ide_read_settings
         mutex_lock(&ide_setting_mtx);
         out += sprintf(out, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n");
         out += sprintf(out, "----\t\t\t-----\t\t---\t\t---\t\t----\n");
-        while(setting) {
+        while (setting) {
                 mul_factor = setting->mul_factor;
                 div_factor = setting->div_factor;
                 out += sprintf(out, "%-24s", setting->name);
-                if ((rc = ide_read_setting(drive, setting)) >= 0)
+                rc = ide_read_setting(drive, setting);
+                if (rc >= 0)
                         out += sprintf(out, "%-16d", rc * mul_factor / div_factor);
                 else
                         out += sprintf(out, "%-16s", "write-only");
@@ -431,7 +433,7 @@ static int proc_ide_read_settings
         }
         len = out - page;
         mutex_unlock(&ide_setting_mtx);
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 #define MAX_LEN 30
@@ -512,8 +514,7 @@ static int proc_ide_write_settings(struct file *file, const char __user *buffer,
 
                         mutex_lock(&ide_setting_mtx);
                         setting = ide_find_setting_by_name(drive, name);
-                        if (!setting)
-                        {
+                        if (!setting) {
                                 mutex_unlock(&ide_setting_mtx);
                                 goto parse_error;
                         }
@@ -533,8 +534,8 @@ parse_error:
 int proc_ide_read_capacity
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        int len = sprintf(page,"%llu\n", (long long)0x7fffffff);
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        int len = sprintf(page, "%llu\n", (long long)0x7fffffff);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 EXPORT_SYMBOL_GPL(proc_ide_read_capacity);
@@ -546,13 +547,13 @@ int proc_ide_read_geometry
         char            *out = page;
         int             len;
 
-        out += sprintf(out,"physical     %d/%d/%d\n",
+        out += sprintf(out, "physical     %d/%d/%d\n",
                         drive->cyl, drive->head, drive->sect);
-        out += sprintf(out,"logical      %d/%d/%d\n",
+        out += sprintf(out, "logical      %d/%d/%d\n",
                         drive->bios_cyl, drive->bios_head, drive->bios_sect);
 
         len = out - page;
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 EXPORT_SYMBOL(proc_ide_read_geometry);
@@ -566,7 +567,7 @@ static int proc_ide_read_dmodel
 
         len = sprintf(page, "%.40s\n",
                 (id && id->model[0]) ? (char *)id->model : "(none)");
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int proc_ide_read_driver
@@ -583,7 +584,7 @@ static int proc_ide_read_driver
                                 dev->driver->name, ide_drv->version);
         } else
                 len = sprintf(page, "ide-default version 0.9.newide\n");
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
@@ -598,14 +599,14 @@ static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
         err = device_attach(dev);
         if (err < 0)
                 printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         drive->driver_req[0] = 0;
         if (dev->driver == NULL) {
                 err = device_attach(dev);
                 if (err < 0)
                         printk(KERN_WARNING
                                 "IDE: %s: device_attach(2) error: %d\n",
-                                __FUNCTION__, err);
+                                __func__, err);
         }
         if (dev->driver && !strcmp(dev->driver->name, driver))
                 ret = 0;
@@ -639,30 +640,26 @@ static int proc_ide_read_media
         int             len;
 
         switch (drive->media) {
-                case ide_disk:  media = "disk\n";
-                                break;
-                case ide_cdrom: media = "cdrom\n";
-                                break;
-                case ide_tape:  media = "tape\n";
-                                break;
-                case ide_floppy:media = "floppy\n";
-                                break;
-                case ide_optical:media = "optical\n";
-                                break;
-                default:        media = "UNKNOWN\n";
-                                break;
+        case ide_disk:          media = "disk\n";       break;
+        case ide_cdrom:         media = "cdrom\n";      break;
+        case ide_tape:          media = "tape\n";       break;
+        case ide_floppy:        media = "floppy\n";     break;
+        case ide_optical:       media = "optical\n";    break;
+        default:                media = "UNKNOWN\n";    break;
         }
-        strcpy(page,media);
+        strcpy(page, media);
         len = strlen(media);
-        PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+        PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static ide_proc_entry_t generic_drive_entries[] = {
-        { "driver",     S_IFREG|S_IRUGO,        proc_ide_read_driver,   proc_ide_write_driver },
-        { "identify",   S_IFREG|S_IRUSR,        proc_ide_read_identify, NULL },
-        { "media",      S_IFREG|S_IRUGO,        proc_ide_read_media,    NULL },
-        { "model",      S_IFREG|S_IRUGO,        proc_ide_read_dmodel,   NULL },
-        { "settings",   S_IFREG|S_IRUSR|S_IWUSR,proc_ide_read_settings, proc_ide_write_settings },
+        { "driver",     S_IFREG|S_IRUGO,         proc_ide_read_driver,
+                                                 proc_ide_write_driver },
+        { "identify",   S_IFREG|S_IRUSR,         proc_ide_read_identify, NULL },
+        { "media",      S_IFREG|S_IRUGO,         proc_ide_read_media,    NULL },
+        { "model",      S_IFREG|S_IRUGO,         proc_ide_read_dmodel,   NULL },
+        { "settings",   S_IFREG|S_IRUSR|S_IWUSR, proc_ide_read_settings,
+                                                 proc_ide_write_settings },
         { NULL, 0, NULL, NULL }
 };
 
@@ -734,7 +731,6 @@ void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver)
         spin_unlock_irqrestore(&ide_lock, flags);
         mutex_unlock(&ide_setting_mtx);
 }
-
 EXPORT_SYMBOL(ide_proc_unregister_driver);
 
 void ide_proc_port_register_devices(ide_hwif_t *hwif)
@@ -755,7 +751,7 @@ void ide_proc_port_register_devices(ide_hwif_t *hwif)
                 drive->proc = proc_mkdir(drive->name, parent);
                 if (drive->proc)
                         ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
-                sprintf(name,"ide%d/%s", (drive->name[2]-'a')/2, drive->name);
+                sprintf(name, "ide%d/%s", (drive->name[2]-'a')/2, drive->name);
                 ent = proc_symlink(drive->name, proc_ide_root, name);
                 if (!ent) return;
         }
@@ -790,15 +786,6 @@ void ide_proc_register_port(ide_hwif_t *hwif)
         }
 }
 
-#ifdef CONFIG_BLK_DEV_IDEPCI
-void ide_pci_create_host_proc(const char *name, get_info_t *get_info)
-{
-        create_proc_info_entry(name, 0, proc_ide_root, get_info);
-}
-
-EXPORT_SYMBOL_GPL(ide_pci_create_host_proc);
-#endif
-
 void ide_proc_unregister_port(ide_hwif_t *hwif)
 {
         if (hwif->proc) {
@@ -825,7 +812,7 @@ static int ide_drivers_show(struct seq_file *s, void *p)
         err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
         if (err < 0)
                 printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n",
-                        __FUNCTION__, err);
+                        __func__, err);
         return 0;
 }
 
diff --git a/drivers/ide/ide-scan-pci.c b/drivers/ide/ide-scan-pci.c
index 98888da1b600..0e79efff1deb 100644
--- a/drivers/ide/ide-scan-pci.c
+++ b/drivers/ide/ide-scan-pci.c
@@ -102,7 +102,7 @@ static int __init ide_scan_pcibus(void)
                 if (__pci_register_driver(d, d->driver.owner,
                                           d->driver.mod_name))
                         printk(KERN_ERR "%s: failed to register %s driver\n",
-                                        __FUNCTION__, d->driver.mod_name);
+                                        __func__, d->driver.mod_name);
         }
 
         return 0;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index f43fd070f1b6..29870c415110 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -72,26 +72,6 @@ enum {
 #endif
 
 /**************************** Tunable parameters *****************************/
-
-
-/*
- * Pipelined mode parameters.
- *
- * We try to use the minimum number of stages which is enough to keep the tape
- * constantly streaming. To accomplish that, we implement a feedback loop around
- * the maximum number of stages:
- *
- * We start from MIN maximum stages (we will not even use MIN stages if we don't
- * need them), increment it by RATE*(MAX-MIN) whenever we sense that the
- * pipeline is empty, until we reach the optimum value or until we reach MAX.
- *
- * Setting the following parameter to 0 is illegal: the pipelined mode cannot be
- * disabled (idetape_calculate_speeds() divides by tape->max_stages.)
- */
-#define IDETAPE_MIN_PIPELINE_STAGES       1
-#define IDETAPE_MAX_PIPELINE_STAGES     400
-#define IDETAPE_INCREASE_STAGES_RATE     20
-
 /*
  * After each failed packet command we issue a request sense command and retry
  * the packet command IDETAPE_MAX_PC_RETRIES times.
@@ -224,28 +204,17 @@ enum {
         /* 0 When the tape position is unknown */
         IDETAPE_FLAG_ADDRESS_VALID      = (1 << 1),
         /* Device already opened */
-        IDETAPE_FLAG_BUSY                       = (1 << 2),
-        /* Error detected in a pipeline stage */
-        IDETAPE_FLAG_PIPELINE_ERR       = (1 << 3),
+        IDETAPE_FLAG_BUSY               = (1 << 2),
         /* Attempt to auto-detect the current user block size */
-        IDETAPE_FLAG_DETECT_BS          = (1 << 4),
+        IDETAPE_FLAG_DETECT_BS          = (1 << 3),
         /* Currently on a filemark */
-        IDETAPE_FLAG_FILEMARK           = (1 << 5),
+        IDETAPE_FLAG_FILEMARK           = (1 << 4),
         /* DRQ interrupt device */
-        IDETAPE_FLAG_DRQ_INTERRUPT      = (1 << 6),
-        /* pipeline active */
-        IDETAPE_FLAG_PIPELINE_ACTIVE    = (1 << 7),
+        IDETAPE_FLAG_DRQ_INTERRUPT      = (1 << 5),
         /* 0 = no tape is loaded, so we don't rewind after ejecting */
-        IDETAPE_FLAG_MEDIUM_PRESENT     = (1 << 8),
+        IDETAPE_FLAG_MEDIUM_PRESENT     = (1 << 6),
 };
 
-/* A pipeline stage. */
-typedef struct idetape_stage_s {
-        struct request rq;                      /* The corresponding request */
-        struct idetape_bh *bh;                  /* The data buffers */
-        struct idetape_stage_s *next;           /* Pointer to the next stage */
-} idetape_stage_t;
-
 /*
  * Most of our global data which we need to save even as we leave the driver due
  * to an interrupt or a timer event is stored in the struct defined below.
@@ -289,9 +258,7 @@ typedef struct ide_tape_obj {
          * While polling for DSC we use postponed_rq to postpone the current
          * request so that ide.c will be able to service pending requests on the
          * other device. Note that at most we will have only one DSC (usually
-         * data transfer) request in the device request queue. Additional
-         * requests can be queued in our internal pipeline, but they will be
-         * visible to ide.c only one at a time.
+         * data transfer) request in the device request queue.
          */
         struct request *postponed_rq;
         /* The time in which we started polling for DSC */
@@ -331,43 +298,20 @@ typedef struct ide_tape_obj {
          * At most, there is only one ide-tape originated data transfer request
          * in the device request queue. This allows ide.c to easily service
          * requests from the other device when we postpone our active request.
-         * In the pipelined operation mode, we use our internal pipeline
-         * structure to hold more data requests. The data buffer size is chosen
-         * based on the tape's recommendation.
          */
-        /* ptr to the request which is waiting in the device request queue */
-        struct request *active_data_rq;
+
         /* Data buffer size chosen based on the tape's recommendation */
-        int stage_size;
-        idetape_stage_t *merge_stage;
-        int merge_stage_size;
+        int buffer_size;
+        /* merge buffer */
+        struct idetape_bh *merge_bh;
+        /* size of the merge buffer */
+        int merge_bh_size;
+        /* pointer to current buffer head within the merge buffer */
         struct idetape_bh *bh;
         char *b_data;
         int b_count;
 
-        /*
-         * Pipeline parameters.
-         *
-         * To accomplish non-pipelined mode, we simply set the following
-         * variables to zero (or NULL, where appropriate).
-         */
-        /* Number of currently used stages */
-        int nr_stages;
-        /* Number of pending stages */
-        int nr_pending_stages;
-        /* We will not allocate more than this number of stages */
-        int max_stages, min_pipeline, max_pipeline;
-        /* The first stage which will be removed from the pipeline */
-        idetape_stage_t *first_stage;
-        /* The currently active stage */
-        idetape_stage_t *active_stage;
-        /* Will be serviced after the currently active request */
-        idetape_stage_t *next_stage;
-        /* New requests will be added to the pipeline here */
-        idetape_stage_t *last_stage;
-        /* Optional free stage which we can use */
-        idetape_stage_t *cache_stage;
-        int pages_per_stage;
+        int pages_per_buffer;
         /* Wasted space in each stage */
         int excess_bh_size;
 
@@ -388,45 +332,6 @@ typedef struct ide_tape_obj {
         /* the tape is write protected (hardware or opened as read-only) */
         char write_prot;
 
-        /*
-         * Limit the number of times a request can be postponed, to avoid an
-         * infinite postpone deadlock.
-         */
-        int postpone_cnt;
-
-        /*
-         * Measures number of frames:
-         *
-         * 1. written/read to/from the driver pipeline (pipeline_head).
-         * 2. written/read to/from the tape buffers (idetape_bh).
-         * 3. written/read by the tape to/from the media (tape_head).
-         */
-        int pipeline_head;
-        int buffer_head;
-        int tape_head;
-        int last_tape_head;
-
-        /* Speed control at the tape buffers input/output */
-        unsigned long insert_time;
-        int insert_size;
-        int insert_speed;
-        int max_insert_speed;
-        int measure_insert_time;
-
-        /* Speed regulation negative feedback loop */
-        int speed_control;
-        int pipeline_head_speed;
-        int controlled_pipeline_head_speed;
-        int uncontrolled_pipeline_head_speed;
-        int controlled_last_pipeline_head;
-        unsigned long uncontrolled_pipeline_head_time;
-        unsigned long controlled_pipeline_head_time;
-        int controlled_previous_pipeline_head;
-        int uncontrolled_previous_pipeline_head;
-        unsigned long controlled_previous_head_time;
-        unsigned long uncontrolled_previous_head_time;
-        int restart_speed_control_req;
-
         u32 debug_mask;
 } idetape_tape_t;
 
@@ -674,128 +579,36 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense)
         }
 }
 
-static void idetape_activate_next_stage(ide_drive_t *drive)
+/* Free data buffers completely. */
+static void ide_tape_kfree_buffer(idetape_tape_t *tape)
 {
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *stage = tape->next_stage;
-        struct request *rq = &stage->rq;
+        struct idetape_bh *prev_bh, *bh = tape->merge_bh;
 
-        debug_log(DBG_PROCS, "Enter %s\n", __func__);
+        while (bh) {
+                u32 size = bh->b_size;
 
-        if (stage == NULL) {
-                printk(KERN_ERR "ide-tape: bug: Trying to activate a non"
-                                " existing stage\n");
-                return;
-        }
+                while (size) {
+                        unsigned int order = fls(size >> PAGE_SHIFT)-1;
 
-        rq->rq_disk = tape->disk;
-        rq->buffer = NULL;
-        rq->special = (void *)stage->bh;
-        tape->active_data_rq = rq;
-        tape->active_stage = stage;
-        tape->next_stage = stage->next;
-}
-
-/* Free a stage along with its related buffers completely. */
-static void __idetape_kfree_stage(idetape_stage_t *stage)
-{
-        struct idetape_bh *prev_bh, *bh = stage->bh;
-        int size;
-
-        while (bh != NULL) {
-                if (bh->b_data != NULL) {
-                        size = (int) bh->b_size;
-                        while (size > 0) {
-                                free_page((unsigned long) bh->b_data);
-                                size -= PAGE_SIZE;
-                                bh->b_data += PAGE_SIZE;
-                        }
+                        if (bh->b_data)
+                                free_pages((unsigned long)bh->b_data, order);
+
+                        size &= (order-1);
+                        bh->b_data += (1 << order) * PAGE_SIZE;
                 }
                 prev_bh = bh;
                 bh = bh->b_reqnext;
                 kfree(prev_bh);
         }
-        kfree(stage);
-}
-
-static void idetape_kfree_stage(idetape_tape_t *tape, idetape_stage_t *stage)
-{
-        __idetape_kfree_stage(stage);
+        kfree(tape->merge_bh);
 }
 
-/*
- * Remove tape->first_stage from the pipeline. The caller should avoid race
- * conditions.
- */
-static void idetape_remove_stage_head(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *stage;
-
-        debug_log(DBG_PROCS, "Enter %s\n", __func__);
-
-        if (tape->first_stage == NULL) {
-                printk(KERN_ERR "ide-tape: bug: tape->first_stage is NULL\n");
-                return;
-        }
-        if (tape->active_stage == tape->first_stage) {
-                printk(KERN_ERR "ide-tape: bug: Trying to free our active "
-                                "pipeline stage\n");
-                return;
-        }
-        stage = tape->first_stage;
-        tape->first_stage = stage->next;
-        idetape_kfree_stage(tape, stage);
-        tape->nr_stages--;
-        if (tape->first_stage == NULL) {
-                tape->last_stage = NULL;
-                if (tape->next_stage != NULL)
-                        printk(KERN_ERR "ide-tape: bug: tape->next_stage !="
-                                        " NULL\n");
-                if (tape->nr_stages)
-                        printk(KERN_ERR "ide-tape: bug: nr_stages should be 0 "
-                                        "now\n");
-        }
-}
-
-/*
- * This will free all the pipeline stages starting from new_last_stage->next
- * to the end of the list, and point tape->last_stage to new_last_stage.
- */
-static void idetape_abort_pipeline(ide_drive_t *drive,
-                                   idetape_stage_t *new_last_stage)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *stage = new_last_stage->next;
-        idetape_stage_t *nstage;
-
-        debug_log(DBG_PROCS, "%s: Enter %s\n", tape->name, __func__);
-
-        while (stage) {
-                nstage = stage->next;
-                idetape_kfree_stage(tape, stage);
-                --tape->nr_stages;
-                --tape->nr_pending_stages;
-                stage = nstage;
-        }
-        if (new_last_stage)
-                new_last_stage->next = NULL;
-        tape->last_stage = new_last_stage;
-        tape->next_stage = NULL;
-}
-
-/*
- * Finish servicing a request and insert a pending pipeline request into the
- * main device queue.
- */
 static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
 {
         struct request *rq = HWGROUP(drive)->rq;
         idetape_tape_t *tape = drive->driver_data;
         unsigned long flags;
         int error;
-        int remove_stage = 0;
-        idetape_stage_t *active_stage;
 
         debug_log(DBG_PROCS, "Enter %s\n", __func__);
 
@@ -815,58 +628,8 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
 
         spin_lock_irqsave(&tape->lock, flags);
 
-        /* The request was a pipelined data transfer request */
-        if (tape->active_data_rq == rq) {
-                active_stage = tape->active_stage;
-                tape->active_stage = NULL;
-                tape->active_data_rq = NULL;
-                tape->nr_pending_stages--;
-                if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
-                        remove_stage = 1;
-                        if (error) {
-                                set_bit(IDETAPE_FLAG_PIPELINE_ERR,
-                                        &tape->flags);
-                                if (error == IDETAPE_ERROR_EOD)
-                                        idetape_abort_pipeline(drive,
-                                                                active_stage);
-                        }
-                } else if (rq->cmd[0] & REQ_IDETAPE_READ) {
-                        if (error == IDETAPE_ERROR_EOD) {
-                                set_bit(IDETAPE_FLAG_PIPELINE_ERR,
-                                        &tape->flags);
-                                idetape_abort_pipeline(drive, active_stage);
-                        }
-                }
-                if (tape->next_stage != NULL) {
-                        idetape_activate_next_stage(drive);
-
-                        /* Insert the next request into the request queue. */
-                        (void)ide_do_drive_cmd(drive, tape->active_data_rq,
-                                                ide_end);
-                } else if (!error) {
-                        /*
-                         * This is a part of the feedback loop which tries to
-                         * find the optimum number of stages. We are starting
-                         * from a minimum maximum number of stages, and if we
-                         * sense that the pipeline is empty, we try to increase
-                         * it, until we reach the user compile time memory
-                         * limit.
-                         */
-                        int i = (tape->max_pipeline - tape->min_pipeline) / 10;
-
-                        tape->max_stages += max(i, 1);
-                        tape->max_stages = max(tape->max_stages,
-                                                tape->min_pipeline);
-                        tape->max_stages = min(tape->max_stages,
-                                                tape->max_pipeline);
-                }
-        }
         ide_end_drive_cmd(drive, 0, 0);
 
-        if (remove_stage)
-                idetape_remove_stage_head(drive);
-        if (tape->active_data_rq == NULL)
-                clear_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
         spin_unlock_irqrestore(&tape->lock, flags);
         return 0;
 }
@@ -993,7 +756,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)
         stat = ide_read_status(drive);
 
         if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
-                if (hwif->ide_dma_end(drive) || (stat & ERR_STAT)) {
+                if (hwif->dma_ops->dma_end(drive) || (stat & ERR_STAT)) {
                         /*
                          * A DMA error is sometimes expected. For example,
                          * if the tape is crossing a filemark during a
@@ -1083,10 +846,10 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)
                 return ide_do_reset(drive);
         }
         /* Get the number of bytes to transfer on this interrupt. */
-        bcount = (hwif->INB(hwif->io_ports[IDE_BCOUNTH_OFFSET]) << 8) |
-                  hwif->INB(hwif->io_ports[IDE_BCOUNTL_OFFSET]);
+        bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) |
+                  hwif->INB(hwif->io_ports.lbam_addr);
 
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
 
         if (ireason & CD) {
                 printk(KERN_ERR "ide-tape: CoD != 0 in %s\n", __func__);
@@ -1190,12 +953,12 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
                                 "yet DRQ isn't asserted\n");
                 return startstop;
         }
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
         while (retries-- && ((ireason & CD) == 0 || (ireason & IO))) {
                 printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while issuing "
                                 "a packet command, retrying\n");
                 udelay(100);
-                ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+                ireason = hwif->INB(hwif->io_ports.nsect_addr);
                 if (retries == 0) {
                         printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while "
                                         "issuing a packet command, ignoring\n");
@@ -1213,7 +976,7 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
 #ifdef CONFIG_BLK_DEV_IDEDMA
         /* Begin DMA, if necessary */
         if (pc->flags & PC_FLAG_DMA_IN_PROGRESS)
-                hwif->dma_start(drive);
+                hwif->dma_ops->dma_start(drive);
 #endif
         /* Send the actual packet */
         HWIF(drive)->atapi_output_bytes(drive, pc->c, 12);
@@ -1279,7 +1042,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive,
                 ide_dma_off(drive);
         }
         if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
-                dma_ok = !hwif->dma_setup(drive);
+                dma_ok = !hwif->dma_ops->dma_setup(drive);
 
         ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
                            IDE_TFLAG_OUT_DEVICE, bcount, dma_ok);
@@ -1292,7 +1055,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive,
                                     IDETAPE_WAIT_CMD, NULL);
                 return ide_started;
         } else {
-                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports.command_addr);
                 return idetape_transfer_pc(drive);
         }
 }
@@ -1335,69 +1098,6 @@ static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
         pc->idetape_callback = &idetape_pc_callback;
 }
 
-static void idetape_calculate_speeds(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-
-        if (time_after(jiffies,
-                        tape->controlled_pipeline_head_time + 120 * HZ)) {
-                tape->controlled_previous_pipeline_head =
-                        tape->controlled_last_pipeline_head;
-                tape->controlled_previous_head_time =
-                        tape->controlled_pipeline_head_time;
-                tape->controlled_last_pipeline_head = tape->pipeline_head;
-                tape->controlled_pipeline_head_time = jiffies;
-        }
-        if (time_after(jiffies, tape->controlled_pipeline_head_time + 60 * HZ))
-                tape->controlled_pipeline_head_speed = (tape->pipeline_head -
-                                tape->controlled_last_pipeline_head) * 32 * HZ /
-                                (jiffies - tape->controlled_pipeline_head_time);
-        else if (time_after(jiffies, tape->controlled_previous_head_time))
-                tape->controlled_pipeline_head_speed = (tape->pipeline_head -
-                                tape->controlled_previous_pipeline_head) * 32 *
-                        HZ / (jiffies - tape->controlled_previous_head_time);
-
-        if (tape->nr_pending_stages < tape->max_stages/*- 1 */) {
-                /* -1 for read mode error recovery */
-                if (time_after(jiffies, tape->uncontrolled_previous_head_time +
-                                        10 * HZ)) {
-                        tape->uncontrolled_pipeline_head_time = jiffies;
-                        tape->uncontrolled_pipeline_head_speed =
-                                (tape->pipeline_head -
-                                 tape->uncontrolled_previous_pipeline_head) *
-                                32 * HZ / (jiffies -
-                                        tape->uncontrolled_previous_head_time);
-                }
-        } else {
-                tape->uncontrolled_previous_head_time = jiffies;
-                tape->uncontrolled_previous_pipeline_head = tape->pipeline_head;
-                if (time_after(jiffies, tape->uncontrolled_pipeline_head_time +
-                                        30 * HZ))
-                        tape->uncontrolled_pipeline_head_time = jiffies;
-
-        }
-        tape->pipeline_head_speed = max(tape->uncontrolled_pipeline_head_speed,
-                                        tape->controlled_pipeline_head_speed);
-
-        if (tape->speed_control == 1) {
-                if (tape->nr_pending_stages >= tape->max_stages / 2)
-                        tape->max_insert_speed = tape->pipeline_head_speed +
-                                (1100 - tape->pipeline_head_speed) * 2 *
-                                (tape->nr_pending_stages - tape->max_stages / 2)
-                                / tape->max_stages;
-                else
-                        tape->max_insert_speed = 500 +
-                                (tape->pipeline_head_speed - 500) * 2 *
-                                tape->nr_pending_stages / tape->max_stages;
-
-                if (tape->nr_pending_stages >= tape->max_stages * 99 / 100)
-                        tape->max_insert_speed = 5000;
-        } else
-                tape->max_insert_speed = tape->speed_control;
-
-        tape->max_insert_speed = max(tape->max_insert_speed, 500);
-}
-
 static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
@@ -1432,17 +1132,7 @@ static ide_startstop_t idetape_rw_callback(ide_drive_t *drive)
         int blocks = tape->pc->xferred / tape->blk_size;
 
         tape->avg_size += blocks * tape->blk_size;
-        tape->insert_size += blocks * tape->blk_size;
-        if (tape->insert_size > 1024 * 1024)
-                tape->measure_insert_time = 1;
-        if (tape->measure_insert_time) {
-                tape->measure_insert_time = 0;
-                tape->insert_time = jiffies;
-                tape->insert_size = 0;
-        }
-        if (time_after(jiffies, tape->insert_time))
-                tape->insert_speed = tape->insert_size / 1024 * HZ /
-                                        (jiffies - tape->insert_time);
+
         if (time_after_eq(jiffies, tape->avg_time + HZ)) {
                 tape->avg_speed = tape->avg_size * HZ /
                                 (jiffies - tape->avg_time) / 1024;
@@ -1475,7 +1165,7 @@ static void idetape_create_read_cmd(idetape_tape_t *tape,
         pc->buf = NULL;
         pc->buf_size = length * tape->blk_size;
         pc->req_xfer = pc->buf_size;
-        if (pc->req_xfer == tape->stage_size)
+        if (pc->req_xfer == tape->buffer_size)
                 pc->flags |= PC_FLAG_DMA_RECOMMENDED;
 }
 
@@ -1495,7 +1185,7 @@ static void idetape_create_write_cmd(idetape_tape_t *tape,
         pc->buf = NULL;
         pc->buf_size = length * tape->blk_size;
         pc->req_xfer = pc->buf_size;
-        if (pc->req_xfer == tape->stage_size)
+        if (pc->req_xfer == tape->buffer_size)
                 pc->flags |= PC_FLAG_DMA_RECOMMENDED;
 }
 
@@ -1547,10 +1237,6 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                 drive->post_reset = 0;
         }
 
-        if (time_after(jiffies, tape->insert_time))
-                tape->insert_speed = tape->insert_size / 1024 * HZ /
-                                        (jiffies - tape->insert_time);
-        idetape_calculate_speeds(drive);
         if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) &&
             (stat & SEEK_STAT) == 0) {
                 if (postponed_rq == NULL) {
@@ -1574,16 +1260,12 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                 return ide_stopped;
         }
         if (rq->cmd[0] & REQ_IDETAPE_READ) {
-                tape->buffer_head++;
-                tape->postpone_cnt = 0;
                 pc = idetape_next_pc_storage(drive);
                 idetape_create_read_cmd(tape, pc, rq->current_nr_sectors,
                                         (struct idetape_bh *)rq->special);
                 goto out;
         }
         if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
-                tape->buffer_head++;
-                tape->postpone_cnt = 0;
                 pc = idetape_next_pc_storage(drive);
                 idetape_create_write_cmd(tape, pc, rq->current_nr_sectors,
                                          (struct idetape_bh *)rq->special);
@@ -1604,111 +1286,91 @@ out:
         return idetape_issue_pc(drive, pc);
 }
 
-/* Pipeline related functions */
-static inline int idetape_pipeline_active(idetape_tape_t *tape)
-{
-        int rc1, rc2;
-
-        rc1 = test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
-        rc2 = (tape->active_data_rq != NULL);
-        return rc1;
-}
-
 /*
- * The function below uses __get_free_page to allocate a pipeline stage, along
- * with all the necessary small buffers which together make a buffer of size
- * tape->stage_size (or a bit more). We attempt to combine sequential pages as
+ * The function below uses __get_free_pages to allocate a data buffer of size
+ * tape->buffer_size (or a bit more). We attempt to combine sequential pages as
  * much as possible.
  *
- * It returns a pointer to the new allocated stage, or NULL if we can't (or
- * don't want to) allocate a stage.
- *
- * Pipeline stages are optional and are used to increase performance. If we
- * can't allocate them, we'll manage without them.
+ * It returns a pointer to the newly allocated buffer, or NULL in case of
+ * failure.
  */
-static idetape_stage_t *__idetape_kmalloc_stage(idetape_tape_t *tape, int full,
-                                                int clear)
+static struct idetape_bh *ide_tape_kmalloc_buffer(idetape_tape_t *tape,
+                                                  int full, int clear)
 {
-        idetape_stage_t *stage;
-        struct idetape_bh *prev_bh, *bh;
-        int pages = tape->pages_per_stage;
+        struct idetape_bh *prev_bh, *bh, *merge_bh;
+        int pages = tape->pages_per_buffer;
+        unsigned int order, b_allocd;
         char *b_data = NULL;
 
-        stage = kmalloc(sizeof(idetape_stage_t), GFP_KERNEL);
-        if (!stage)
-                return NULL;
-        stage->next = NULL;
-
-        stage->bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
-        bh = stage->bh;
+        merge_bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
+        bh = merge_bh;
         if (bh == NULL)
                 goto abort;
-        bh->b_reqnext = NULL;
-        bh->b_data = (char *) __get_free_page(GFP_KERNEL);
+
+        order = fls(pages) - 1;
+        bh->b_data = (char *) __get_free_pages(GFP_KERNEL, order);
         if (!bh->b_data)
                 goto abort;
+        b_allocd = (1 << order) * PAGE_SIZE;
+        pages &= (order-1);
+
         if (clear)
-                memset(bh->b_data, 0, PAGE_SIZE);
-        bh->b_size = PAGE_SIZE;
+                memset(bh->b_data, 0, b_allocd);
+        bh->b_reqnext = NULL;
+        bh->b_size = b_allocd;
         atomic_set(&bh->b_count, full ? bh->b_size : 0);
 
-        while (--pages) {
-                b_data = (char *) __get_free_page(GFP_KERNEL);
+        while (pages) {
+                order = fls(pages) - 1;
+                b_data = (char *) __get_free_pages(GFP_KERNEL, order);
                 if (!b_data)
                         goto abort;
+                b_allocd = (1 << order) * PAGE_SIZE;
+
                 if (clear)
-                        memset(b_data, 0, PAGE_SIZE);
-                if (bh->b_data == b_data + PAGE_SIZE) {
-                        bh->b_size += PAGE_SIZE;
-                        bh->b_data -= PAGE_SIZE;
+                        memset(b_data, 0, b_allocd);
+
+                /* newly allocated page frames below buffer header or ...*/
+                if (bh->b_data == b_data + b_allocd) {
+                        bh->b_size += b_allocd;
+                        bh->b_data -= b_allocd;
                         if (full)
-                                atomic_add(PAGE_SIZE, &bh->b_count);
+                                atomic_add(b_allocd, &bh->b_count);
                         continue;
                 }
+                /* they are above the header */
                 if (b_data == bh->b_data + bh->b_size) {
-                        bh->b_size += PAGE_SIZE;
+                        bh->b_size += b_allocd;
                         if (full)
-                                atomic_add(PAGE_SIZE, &bh->b_count);
+                                atomic_add(b_allocd, &bh->b_count);
                         continue;
                 }
                 prev_bh = bh;
                 bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
                 if (!bh) {
-                        free_page((unsigned long) b_data);
+                        free_pages((unsigned long) b_data, order);
                         goto abort;
                 }
                 bh->b_reqnext = NULL;
                 bh->b_data = b_data;
-                bh->b_size = PAGE_SIZE;
+                bh->b_size = b_allocd;
                 atomic_set(&bh->b_count, full ? bh->b_size : 0);
                 prev_bh->b_reqnext = bh;
+
+                pages &= (order-1);
         }
+
         bh->b_size -= tape->excess_bh_size;
         if (full)
                 atomic_sub(tape->excess_bh_size, &bh->b_count);
-        return stage;
+        return merge_bh;
 abort:
-        __idetape_kfree_stage(stage);
+        ide_tape_kfree_buffer(tape);
         return NULL;
 }
 
-static idetape_stage_t *idetape_kmalloc_stage(idetape_tape_t *tape)
-{
-        idetape_stage_t *cache_stage = tape->cache_stage;
-
-        debug_log(DBG_PROCS, "Enter %s\n", __func__);
-
-        if (tape->nr_stages >= tape->max_stages)
-                return NULL;
-        if (cache_stage != NULL) {
-                tape->cache_stage = NULL;
-                return cache_stage;
-        }
-        return __idetape_kmalloc_stage(tape, 0, 0);
-}
-
 static int idetape_copy_stage_from_user(idetape_tape_t *tape,
-                idetape_stage_t *stage, const char __user *buf, int n)
+                                        const char __user *buf, int n)
 {
         struct idetape_bh *bh = tape->bh;
         int count;
@@ -1740,7 +1402,7 @@ static int idetape_copy_stage_from_user(idetape_tape_t *tape,
 }
 
 static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf,
-                idetape_stage_t *stage, int n)
+                                      int n)
 {
         struct idetape_bh *bh = tape->bh;
         int count;
@@ -1771,11 +1433,11 @@ static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf,
         return ret;
 }
 
-static void idetape_init_merge_stage(idetape_tape_t *tape)
+static void idetape_init_merge_buffer(idetape_tape_t *tape)
 {
-        struct idetape_bh *bh = tape->merge_stage->bh;
+        struct idetape_bh *bh = tape->merge_bh;
+        tape->bh = tape->merge_bh;
 
-        tape->bh = bh;
         if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
                 atomic_set(&bh->b_count, 0);
         else {
@@ -1784,61 +1446,6 @@ static void idetape_init_merge_stage(idetape_tape_t *tape)
         }
 }
 
-static void idetape_switch_buffers(idetape_tape_t *tape, idetape_stage_t *stage)
-{
-        struct idetape_bh *tmp;
-
-        tmp = stage->bh;
-        stage->bh = tape->merge_stage->bh;
-        tape->merge_stage->bh = tmp;
-        idetape_init_merge_stage(tape);
-}
-
-/* Add a new stage at the end of the pipeline. */
-static void idetape_add_stage_tail(ide_drive_t *drive, idetape_stage_t *stage)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        unsigned long flags;
-
-        debug_log(DBG_PROCS, "Enter %s\n", __func__);
-
-        spin_lock_irqsave(&tape->lock, flags);
-        stage->next = NULL;
-        if (tape->last_stage != NULL)
-                tape->last_stage->next = stage;
-        else
-                tape->first_stage = stage;
-                tape->next_stage  = stage;
-        tape->last_stage = stage;
-        if (tape->next_stage == NULL)
-                tape->next_stage = tape->last_stage;
-        tape->nr_stages++;
-        tape->nr_pending_stages++;
-        spin_unlock_irqrestore(&tape->lock, flags);
-}
-
-/* Install a completion in a pending request and sleep until it is serviced. The
- * caller should ensure that the request will not be serviced before we install
- * the completion (usually by disabling interrupts).
- */
-static void idetape_wait_for_request(ide_drive_t *drive, struct request *rq)
-{
-        DECLARE_COMPLETION_ONSTACK(wait);
-        idetape_tape_t *tape = drive->driver_data;
-
-        if (rq == NULL || !blk_special_request(rq)) {
-                printk(KERN_ERR "ide-tape: bug: Trying to sleep on non-valid"
-                                 " request\n");
-                return;
-        }
-        rq->end_io_data = &wait;
-        rq->end_io = blk_end_sync_rq;
-        spin_unlock_irq(&tape->lock);
-        wait_for_completion(&wait);
-        /* The stage and its struct request have been deallocated */
-        spin_lock_irq(&tape->lock);
-}
-
 static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
@@ -1907,7 +1514,7 @@ static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc)
  * to the request list without waiting for it to be serviced! In that case, we
  * usually use idetape_queue_pc_head().
  */
-static int __idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
+static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
 {
         struct ide_tape_obj *tape = drive->driver_data;
         struct request rq;
@@ -1939,7 +1546,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
         timeout += jiffies;
         while (time_before(jiffies, timeout)) {
                 idetape_create_test_unit_ready_cmd(&pc);
-                if (!__idetape_queue_pc_tail(drive, &pc))
+                if (!idetape_queue_pc_tail(drive, &pc))
                         return 0;
                 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
                     || (tape->asc == 0x3A)) {
@@ -1948,7 +1555,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
                                 return -ENOMEDIUM;
                         idetape_create_load_unload_cmd(drive, &pc,
                                                         IDETAPE_LU_LOAD_MASK);
-                        __idetape_queue_pc_tail(drive, &pc);
+                        idetape_queue_pc_tail(drive, &pc);
                         load_attempted = 1;
                 /* not about to be ready */
                 } else if (!(tape->sense_key == 2 && tape->asc == 4 &&
@@ -1959,11 +1566,6 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
         return -EIO;
 }
 
-static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
-{
-        return __idetape_queue_pc_tail(drive, pc);
-}
-
 static int idetape_flush_tape_buffers(ide_drive_t *drive)
 {
         struct ide_atapi_pc pc;
@@ -2029,50 +1631,21 @@ static int idetape_create_prevent_cmd(ide_drive_t *drive,
         return 1;
 }
 
-static int __idetape_discard_read_pipeline(ide_drive_t *drive)
+static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
-        unsigned long flags;
-        int cnt;
 
         if (tape->chrdev_dir != IDETAPE_DIR_READ)
-                return 0;
+                return;
 
-        /* Remove merge stage. */
-        cnt = tape->merge_stage_size / tape->blk_size;
-        if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))
-                ++cnt;          /* Filemarks count as 1 sector */
-        tape->merge_stage_size = 0;
-        if (tape->merge_stage != NULL) {
-                __idetape_kfree_stage(tape->merge_stage);
-                tape->merge_stage = NULL;
+        clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags);
+        tape->merge_bh_size = 0;
+        if (tape->merge_bh != NULL) {
+                ide_tape_kfree_buffer(tape);
+                tape->merge_bh = NULL;
         }
 
-        /* Clear pipeline flags. */
-        clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);
         tape->chrdev_dir = IDETAPE_DIR_NONE;
-
-        /* Remove pipeline stages. */
-        if (tape->first_stage == NULL)
-                return 0;
-
-        spin_lock_irqsave(&tape->lock, flags);
-        tape->next_stage = NULL;
-        if (idetape_pipeline_active(tape))
-                idetape_wait_for_request(drive, tape->active_data_rq);
-        spin_unlock_irqrestore(&tape->lock, flags);
-
-        while (tape->first_stage != NULL) {
-                struct request *rq_ptr = &tape->first_stage->rq;
-
-                cnt += rq_ptr->nr_sectors - rq_ptr->current_nr_sectors;
-                if (rq_ptr->errors == IDETAPE_ERROR_FILEMARK)
-                        ++cnt;
-                idetape_remove_stage_head(drive);
-        }
-        tape->nr_pending_stages = 0;
-        tape->max_stages = tape->min_pipeline;
-        return cnt;
 }
 
 /*
@@ -2089,7 +1662,7 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
         struct ide_atapi_pc pc;
 
         if (tape->chrdev_dir == IDETAPE_DIR_READ)
-                __idetape_discard_read_pipeline(drive);
+                __ide_tape_discard_merge_buffer(drive);
         idetape_wait_ready(drive, 60 * 5 * HZ);
         idetape_create_locate_cmd(drive, &pc, block, partition, skip);
         retval = idetape_queue_pc_tail(drive, &pc);
@@ -2100,20 +1673,19 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
         return (idetape_queue_pc_tail(drive, &pc));
 }
 
-static void idetape_discard_read_pipeline(ide_drive_t *drive,
+static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
                                           int restore_position)
 {
         idetape_tape_t *tape = drive->driver_data;
-        int cnt;
         int seek, position;
 
-        cnt = __idetape_discard_read_pipeline(drive);
+        __ide_tape_discard_merge_buffer(drive);
         if (restore_position) {
                 position = idetape_read_position(drive);
-                seek = position > cnt ? position - cnt : 0;
+                seek = position > 0 ? position : 0;
                 if (idetape_position_tape(drive, seek, 0, 0)) {
                         printk(KERN_INFO "ide-tape: %s: position_tape failed in"
-                                         " discard_pipeline()\n", tape->name);
+                                         " %s\n", tape->name, __func__);
                         return;
                 }
         }
@@ -2131,12 +1703,6 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks,
 
         debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd);
 
-        if (idetape_pipeline_active(tape)) {
-                printk(KERN_ERR "ide-tape: bug: the pipeline is active in %s\n",
-                                __func__);
-                return (0);
-        }
-
         idetape_init_rq(&rq, cmd);
         rq.rq_disk = tape->disk;
         rq.special = (void *)bh;
@@ -2148,27 +1714,13 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks,
         if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0)
                 return 0;
 
-        if (tape->merge_stage)
-                idetape_init_merge_stage(tape);
+        if (tape->merge_bh)
+                idetape_init_merge_buffer(tape);
         if (rq.errors == IDETAPE_ERROR_GENERAL)
                 return -EIO;
         return (tape->blk_size * (blocks-rq.current_nr_sectors));
 }
 
-/* start servicing the pipeline stages, starting from tape->next_stage. */
-static void idetape_plug_pipeline(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-
-        if (tape->next_stage == NULL)
-                return;
-        if (!idetape_pipeline_active(tape)) {
-                set_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
-                idetape_activate_next_stage(drive);
-                (void) ide_do_drive_cmd(drive, tape->active_data_rq, ide_end);
-        }
-}
-
 static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc)
 {
         idetape_init_pc(pc);
@@ -2206,135 +1758,39 @@ static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
         pc->idetape_callback = &idetape_pc_callback;
 }
 
-static void idetape_wait_first_stage(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        unsigned long flags;
-
-        if (tape->first_stage == NULL)
-                return;
-        spin_lock_irqsave(&tape->lock, flags);
-        if (tape->active_stage == tape->first_stage)
-                idetape_wait_for_request(drive, tape->active_data_rq);
-        spin_unlock_irqrestore(&tape->lock, flags);
-}
-
-/*
- * Try to add a character device originated write request to our pipeline. In
- * case we don't succeed, we revert to non-pipelined operation mode for this
- * request. In order to accomplish that, we
- *
- * 1. Try to allocate a new pipeline stage.
- * 2. If we can't, wait for more and more requests to be serviced and try again
- * each time.
- * 3. If we still can't allocate a stage, fallback to non-pipelined operation
- * mode for this request.
- */
+/* Queue up a character device originated write request. */
 static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks)
 {
         idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *new_stage;
-        unsigned long flags;
-        struct request *rq;
 
         debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
 
-        /* Attempt to allocate a new stage. Beware possible race conditions. */
-        while ((new_stage = idetape_kmalloc_stage(tape)) == NULL) {
-                spin_lock_irqsave(&tape->lock, flags);
-                if (idetape_pipeline_active(tape)) {
-                        idetape_wait_for_request(drive, tape->active_data_rq);
-                        spin_unlock_irqrestore(&tape->lock, flags);
-                } else {
-                        spin_unlock_irqrestore(&tape->lock, flags);
-                        idetape_plug_pipeline(drive);
-                        if (idetape_pipeline_active(tape))
-                                continue;
-                        /*
-                         * The machine is short on memory. Fallback to non-
-                         * pipelined operation mode for this request.
-                         */
-                        return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
-                                                blocks, tape->merge_stage->bh);
-                }
-        }
-        rq = &new_stage->rq;
-        idetape_init_rq(rq, REQ_IDETAPE_WRITE);
-        /* Doesn't actually matter - We always assume sequential access */
-        rq->sector = tape->first_frame;
-        rq->current_nr_sectors = blocks;
-        rq->nr_sectors = blocks;
-
-        idetape_switch_buffers(tape, new_stage);
-        idetape_add_stage_tail(drive, new_stage);
-        tape->pipeline_head++;
-        idetape_calculate_speeds(drive);
-
-        /*
-         * Estimate whether the tape has stopped writing by checking if our
-         * write pipeline is currently empty. If we are not writing anymore,
-         * wait for the pipeline to be almost completely full (90%) before
-         * starting to service requests, so that we will be able to keep up with
-         * the higher speeds of the tape.
-         */
-        if (!idetape_pipeline_active(tape)) {
-                if (tape->nr_stages >= tape->max_stages * 9 / 10 ||
-                        tape->nr_stages >= tape->max_stages -
-                        tape->uncontrolled_pipeline_head_speed * 3 * 1024 /
-                        tape->blk_size) {
-                        tape->measure_insert_time = 1;
-                        tape->insert_time = jiffies;
-                        tape->insert_size = 0;
-                        tape->insert_speed = 0;
-                        idetape_plug_pipeline(drive);
-                }
-        }
-        if (test_and_clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags))
-                /* Return a deferred error */
-                return -EIO;
-        return blocks;
-}
-
-/*
- * Wait until all pending pipeline requests are serviced. Typically called on
- * device close.
- */
-static void idetape_wait_for_pipeline(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        unsigned long flags;
-
-        while (tape->next_stage || idetape_pipeline_active(tape)) {
-                idetape_plug_pipeline(drive);
-                spin_lock_irqsave(&tape->lock, flags);
-                if (idetape_pipeline_active(tape))
-                        idetape_wait_for_request(drive, tape->active_data_rq);
-                spin_unlock_irqrestore(&tape->lock, flags);
-        }
+        return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
+                                     blocks, tape->merge_bh);
 }
 
-static void idetape_empty_write_pipeline(ide_drive_t *drive)
+static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
         int blocks, min;
         struct idetape_bh *bh;
 
         if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
-                printk(KERN_ERR "ide-tape: bug: Trying to empty write pipeline,"
+                printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
                                 " but we are not writing.\n");
                 return;
         }
-        if (tape->merge_stage_size > tape->stage_size) {
+        if (tape->merge_bh_size > tape->buffer_size) {
                 printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n");
-                tape->merge_stage_size = tape->stage_size;
+                tape->merge_bh_size = tape->buffer_size;
         }
-        if (tape->merge_stage_size) {
-                blocks = tape->merge_stage_size / tape->blk_size;
-                if (tape->merge_stage_size % tape->blk_size) {
+        if (tape->merge_bh_size) {
+                blocks = tape->merge_bh_size / tape->blk_size;
+                if (tape->merge_bh_size % tape->blk_size) {
                         unsigned int i;
 
                         blocks++;
-                        i = tape->blk_size - tape->merge_stage_size %
+                        i = tape->blk_size - tape->merge_bh_size %
                                 tape->blk_size;
                         bh = tape->bh->b_reqnext;
                         while (bh) {
@@ -2358,74 +1814,33 @@ static void idetape_empty_write_pipeline(ide_drive_t *drive)
                         }
                 }
                 (void) idetape_add_chrdev_write_request(drive, blocks);
-                tape->merge_stage_size = 0;
+                tape->merge_bh_size = 0;
         }
-        idetape_wait_for_pipeline(drive);
-        if (tape->merge_stage != NULL) {
-                __idetape_kfree_stage(tape->merge_stage);
-                tape->merge_stage = NULL;
+        if (tape->merge_bh != NULL) {
+                ide_tape_kfree_buffer(tape);
+                tape->merge_bh = NULL;
         }
-        clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);
         tape->chrdev_dir = IDETAPE_DIR_NONE;
-
-        /*
-         * On the next backup, perform the feedback loop again. (I don't want to
-         * keep sense information between backups, as some systems are
-         * constantly on, and the system load can be totally different on the
-         * next backup).
-         */
-        tape->max_stages = tape->min_pipeline;
-        if (tape->first_stage != NULL ||
-            tape->next_stage != NULL ||
-            tape->last_stage != NULL ||
-            tape->nr_stages != 0) {
-                printk(KERN_ERR "ide-tape: ide-tape pipeline bug, "
-                        "first_stage %p, next_stage %p, "
-                        "last_stage %p, nr_stages %d\n",
-                        tape->first_stage, tape->next_stage,
-                        tape->last_stage, tape->nr_stages);
-        }
 }
 
-static void idetape_restart_speed_control(ide_drive_t *drive)
+static int idetape_init_read(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
-
-        tape->restart_speed_control_req = 0;
-        tape->pipeline_head = 0;
-        tape->controlled_last_pipeline_head = 0;
-        tape->controlled_previous_pipeline_head = 0;
-        tape->uncontrolled_previous_pipeline_head = 0;
-        tape->controlled_pipeline_head_speed = 5000;
-        tape->pipeline_head_speed = 5000;
-        tape->uncontrolled_pipeline_head_speed = 0;
-        tape->controlled_pipeline_head_time =
-                tape->uncontrolled_pipeline_head_time = jiffies;
-        tape->controlled_previous_head_time =
-                tape->uncontrolled_previous_head_time = jiffies;
-}
-
-static int idetape_init_read(ide_drive_t *drive, int max_stages)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *new_stage;
-        struct request rq;
         int bytes_read;
-        u16 blocks = *(u16 *)&tape->caps[12];
 
         /* Initialize read operation */
         if (tape->chrdev_dir != IDETAPE_DIR_READ) {
                 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
-                        idetape_empty_write_pipeline(drive);
+                        ide_tape_flush_merge_buffer(drive);
                         idetape_flush_tape_buffers(drive);
                 }
-                if (tape->merge_stage || tape->merge_stage_size) {
-                        printk(KERN_ERR "ide-tape: merge_stage_size should be"
+                if (tape->merge_bh || tape->merge_bh_size) {
+                        printk(KERN_ERR "ide-tape: merge_bh_size should be"
                                          " 0 now\n");
-                        tape->merge_stage_size = 0;
+                        tape->merge_bh_size = 0;
                 }
-                tape->merge_stage = __idetape_kmalloc_stage(tape, 0, 0);
-                if (!tape->merge_stage)
+                tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
+                if (!tape->merge_bh)
                         return -ENOMEM;
                 tape->chrdev_dir = IDETAPE_DIR_READ;
 
@@ -2438,54 +1853,23 @@ static int idetape_init_read(ide_drive_t *drive, int max_stages)
                 if (drive->dsc_overlap) {
                         bytes_read = idetape_queue_rw_tail(drive,
                                                         REQ_IDETAPE_READ, 0,
-                                                        tape->merge_stage->bh);
+                                                        tape->merge_bh);
                         if (bytes_read < 0) {
-                                __idetape_kfree_stage(tape->merge_stage);
-                                tape->merge_stage = NULL;
+                                ide_tape_kfree_buffer(tape);
+                                tape->merge_bh = NULL;
                                 tape->chrdev_dir = IDETAPE_DIR_NONE;
                                 return bytes_read;
                         }
                 }
         }
-        if (tape->restart_speed_control_req)
-                idetape_restart_speed_control(drive);
-        idetape_init_rq(&rq, REQ_IDETAPE_READ);
-        rq.sector = tape->first_frame;
-        rq.nr_sectors = blocks;
-        rq.current_nr_sectors = blocks;
-        if (!test_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags) &&
-            tape->nr_stages < max_stages) {
-                new_stage = idetape_kmalloc_stage(tape);
-                while (new_stage != NULL) {
-                        new_stage->rq = rq;
-                        idetape_add_stage_tail(drive, new_stage);
-                        if (tape->nr_stages >= max_stages)
-                                break;
-                        new_stage = idetape_kmalloc_stage(tape);
-                }
-        }
-        if (!idetape_pipeline_active(tape)) {
-                if (tape->nr_pending_stages >= 3 * max_stages / 4) {
-                        tape->measure_insert_time = 1;
-                        tape->insert_time = jiffies;
-                        tape->insert_size = 0;
-                        tape->insert_speed = 0;
-                        idetape_plug_pipeline(drive);
-                }
-        }
+
         return 0;
 }
 
-/*
- * Called from idetape_chrdev_read() to service a character device read request
- * and add read-ahead requests to our pipeline.
- */
+/* called from idetape_chrdev_read() to service a chrdev read request. */
 static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks)
 {
         idetape_tape_t *tape = drive->driver_data;
-        unsigned long flags;
-        struct request *rq_ptr;
-        int bytes_read;
 
         debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks);
 
@@ -2493,39 +1877,10 @@ static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks)
         if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))
                 return 0;
 
-        /* Wait for the next block to reach the head of the pipeline. */
-        idetape_init_read(drive, tape->max_stages);
-        if (tape->first_stage == NULL) {
-                if (test_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags))
-                        return 0;
-                return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks,
-                                        tape->merge_stage->bh);
-        }
-        idetape_wait_first_stage(drive);
-        rq_ptr = &tape->first_stage->rq;
-        bytes_read = tape->blk_size * (rq_ptr->nr_sectors -
-                                        rq_ptr->current_nr_sectors);
-        rq_ptr->nr_sectors = 0;
-        rq_ptr->current_nr_sectors = 0;
+        idetape_init_read(drive);
 
-        if (rq_ptr->errors == IDETAPE_ERROR_EOD)
-                return 0;
-        else {
-                idetape_switch_buffers(tape, tape->first_stage);
-                if (rq_ptr->errors == IDETAPE_ERROR_FILEMARK)
-                        set_bit(IDETAPE_FLAG_FILEMARK, &tape->flags);
-                spin_lock_irqsave(&tape->lock, flags);
-                idetape_remove_stage_head(drive);
-                spin_unlock_irqrestore(&tape->lock, flags);
-                tape->pipeline_head++;
-                idetape_calculate_speeds(drive);
-        }
-        if (bytes_read > blocks * tape->blk_size) {
-                printk(KERN_ERR "ide-tape: bug: trying to return more bytes"
-                                " than requested\n");
-                bytes_read = blocks * tape->blk_size;
-        }
-        return (bytes_read);
+        return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks,
+                                     tape->merge_bh);
 }
 
 static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
@@ -2537,8 +1892,8 @@ static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
         while (bcount) {
                 unsigned int count;
 
-                bh = tape->merge_stage->bh;
-                count = min(tape->stage_size, bcount);
+                bh = tape->merge_bh;
+                count = min(tape->buffer_size, bcount);
                 bcount -= count;
                 blocks = count / tape->blk_size;
                 while (count) {
@@ -2549,31 +1904,10 @@ static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
                         bh = bh->b_reqnext;
                 }
                 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks,
-                                      tape->merge_stage->bh);
+                                      tape->merge_bh);
         }
 }
 
-static int idetape_pipeline_size(ide_drive_t *drive)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *stage;
-        struct request *rq;
-        int size = 0;
-
-        idetape_wait_for_pipeline(drive);
-        stage = tape->first_stage;
-        while (stage != NULL) {
-                rq = &stage->rq;
-                size += tape->blk_size * (rq->nr_sectors -
-                                rq->current_nr_sectors);
-                if (rq->errors == IDETAPE_ERROR_FILEMARK)
-                        size += tape->blk_size;
-                stage = stage->next;
-        }
-        size += tape->merge_stage_size;
-        return size;
-}
-
 /*
  * Rewinds the tape to the Beginning Of the current Partition (BOP). We
  * currently support only one partition.
@@ -2619,11 +1953,10 @@ static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
                 if (copy_from_user(&config, argp, sizeof(config)))
                         return -EFAULT;
                 tape->best_dsc_rw_freq = config.dsc_rw_frequency;
-                tape->max_stages = config.nr_stages;
                 break;
         case 0x0350:
                 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq;
-                config.nr_stages = tape->max_stages;
+                config.nr_stages = 1;
                 if (copy_to_user(argp, &config, sizeof(config)))
                         return -EFAULT;
                 break;
@@ -2633,19 +1966,11 @@ static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
         return 0;
 }
 
-/*
- * The function below is now a bit more complicated than just passing the
- * command to the tape since we may have crossed some filemarks during our
- * pipelined read-ahead mode. As a minor side effect, the pipeline enables us to
- * support MTFSFM when the filemark is in our internal pipeline even if the tape
- * doesn't support spacing over filemarks in the reverse direction.
- */
 static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
                                         int mt_count)
 {
         idetape_tape_t *tape = drive->driver_data;
         struct ide_atapi_pc pc;
-        unsigned long flags;
         int retval, count = 0;
         int sprev = !!(tape->caps[4] & 0x20);
 
@@ -2658,48 +1983,12 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
         }
 
         if (tape->chrdev_dir == IDETAPE_DIR_READ) {
-                /* its a read-ahead buffer, scan it for crossed filemarks. */
-                tape->merge_stage_size = 0;
+                tape->merge_bh_size = 0;
                 if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))
                         ++count;
-                while (tape->first_stage != NULL) {
-                        if (count == mt_count) {
-                                if (mt_op == MTFSFM)
-                                        set_bit(IDETAPE_FLAG_FILEMARK,
-                                                &tape->flags);
-                                return 0;
-                        }
-                        spin_lock_irqsave(&tape->lock, flags);
-                        if (tape->first_stage == tape->active_stage) {
-                                /*
-                                 * We have reached the active stage in the read
-                                 * pipeline. There is no point in allowing the
-                                 * drive to continue reading any farther, so we
-                                 * stop the pipeline.
-                                 *
-                                 * This section should be moved to a separate
-                                 * subroutine because similar operations are
-                                 * done in __idetape_discard_read_pipeline(),
-                                 * for example.
-                                 */
-                                tape->next_stage = NULL;
-                                spin_unlock_irqrestore(&tape->lock, flags);
-                                idetape_wait_first_stage(drive);
-                                tape->next_stage = tape->first_stage->next;
-                        } else
-                                spin_unlock_irqrestore(&tape->lock, flags);
-                        if (tape->first_stage->rq.errors ==
-                                        IDETAPE_ERROR_FILEMARK)
-                                ++count;
-                        idetape_remove_stage_head(drive);
-                }
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
         }
 
-        /*
-         * The filemark was not found in our internal pipeline; now we can issue
-         * the space command.
-         */
         switch (mt_op) {
         case MTFSF:
         case MTBSF:
@@ -2755,27 +2044,25 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
                             (count % tape->blk_size) == 0)
                                 tape->user_bs_factor = count / tape->blk_size;
         }
-        rc = idetape_init_read(drive, tape->max_stages);
+        rc = idetape_init_read(drive);
         if (rc < 0)
                 return rc;
         if (count == 0)
                 return (0);
-        if (tape->merge_stage_size) {
-                actually_read = min((unsigned int)(tape->merge_stage_size),
+        if (tape->merge_bh_size) {
+                actually_read = min((unsigned int)(tape->merge_bh_size),
                                     (unsigned int)count);
-                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage,
-                                               actually_read))
+                if (idetape_copy_stage_to_user(tape, buf, actually_read))
                         ret = -EFAULT;
                 buf += actually_read;
-                tape->merge_stage_size -= actually_read;
+                tape->merge_bh_size -= actually_read;
                 count -= actually_read;
         }
-        while (count >= tape->stage_size) {
+        while (count >= tape->buffer_size) {
                 bytes_read = idetape_add_chrdev_read_request(drive, ctl);
                 if (bytes_read <= 0)
                         goto finish;
-                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage,
-                                               bytes_read))
+                if (idetape_copy_stage_to_user(tape, buf, bytes_read))
                         ret = -EFAULT;
                 buf += bytes_read;
                 count -= bytes_read;
@@ -2786,11 +2073,10 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
                 if (bytes_read <= 0)
                         goto finish;
                 temp = min((unsigned long)count, (unsigned long)bytes_read);
-                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage,
-                                               temp))
+                if (idetape_copy_stage_to_user(tape, buf, temp))
                         ret = -EFAULT;
                 actually_read += temp;
-                tape->merge_stage_size = bytes_read-temp;
+                tape->merge_bh_size = bytes_read-temp;
         }
 finish:
         if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) {
@@ -2821,17 +2107,17 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
         /* Initialize write operation */
         if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
                 if (tape->chrdev_dir == IDETAPE_DIR_READ)
-                        idetape_discard_read_pipeline(drive, 1);
-                if (tape->merge_stage || tape->merge_stage_size) {
-                        printk(KERN_ERR "ide-tape: merge_stage_size "
+                        ide_tape_discard_merge_buffer(drive, 1);
+                if (tape->merge_bh || tape->merge_bh_size) {
+                        printk(KERN_ERR "ide-tape: merge_bh_size "
                                 "should be 0 now\n");
-                        tape->merge_stage_size = 0;
+                        tape->merge_bh_size = 0;
                 }
-                tape->merge_stage = __idetape_kmalloc_stage(tape, 0, 0);
-                if (!tape->merge_stage)
+                tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
+                if (!tape->merge_bh)
                         return -ENOMEM;
                 tape->chrdev_dir = IDETAPE_DIR_WRITE;
-                idetape_init_merge_stage(tape);
+                idetape_init_merge_buffer(tape);
 
                 /*
                  * Issue a write 0 command to ensure that DSC handshake is
@@ -2842,10 +2128,10 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
                 if (drive->dsc_overlap) {
                         ssize_t retval = idetape_queue_rw_tail(drive,
                                                         REQ_IDETAPE_WRITE, 0,
-                                                        tape->merge_stage->bh);
+                                                        tape->merge_bh);
                         if (retval < 0) {
-                                __idetape_kfree_stage(tape->merge_stage);
-                                tape->merge_stage = NULL;
+                                ide_tape_kfree_buffer(tape);
+                                tape->merge_bh = NULL;
                                 tape->chrdev_dir = IDETAPE_DIR_NONE;
                                 return retval;
                         }
@@ -2853,49 +2139,44 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
         }
         if (count == 0)
                 return (0);
-        if (tape->restart_speed_control_req)
-                idetape_restart_speed_control(drive);
-        if (tape->merge_stage_size) {
-                if (tape->merge_stage_size >= tape->stage_size) {
+        if (tape->merge_bh_size) {
+                if (tape->merge_bh_size >= tape->buffer_size) {
                         printk(KERN_ERR "ide-tape: bug: merge buf too big\n");
-                        tape->merge_stage_size = 0;
+                        tape->merge_bh_size = 0;
                 }
                 actually_written = min((unsigned int)
-                                (tape->stage_size - tape->merge_stage_size),
+                                (tape->buffer_size - tape->merge_bh_size),
                                 (unsigned int)count);
-                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf,
-                                                 actually_written))
+                if (idetape_copy_stage_from_user(tape, buf, actually_written))
                                 ret = -EFAULT;
                 buf += actually_written;
-                tape->merge_stage_size += actually_written;
+                tape->merge_bh_size += actually_written;
                 count -= actually_written;
 
-                if (tape->merge_stage_size == tape->stage_size) {
+                if (tape->merge_bh_size == tape->buffer_size) {
                         ssize_t retval;
-                        tape->merge_stage_size = 0;
+                        tape->merge_bh_size = 0;
                         retval = idetape_add_chrdev_write_request(drive, ctl);
                         if (retval <= 0)
                                 return (retval);
                 }
         }
-        while (count >= tape->stage_size) {
+        while (count >= tape->buffer_size) {
                 ssize_t retval;
-                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf,
-                                                 tape->stage_size))
+                if (idetape_copy_stage_from_user(tape, buf, tape->buffer_size))
                         ret = -EFAULT;
-                buf += tape->stage_size;
-                count -= tape->stage_size;
+                buf += tape->buffer_size;
+                count -= tape->buffer_size;
                 retval = idetape_add_chrdev_write_request(drive, ctl);
-                actually_written += tape->stage_size;
+                actually_written += tape->buffer_size;
                 if (retval <= 0)
                         return (retval);
         }
         if (count) {
                 actually_written += count;
-                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf,
-                                                 count))
+                if (idetape_copy_stage_from_user(tape, buf, count))
                         ret = -EFAULT;
-                tape->merge_stage_size += count;
+                tape->merge_bh_size += count;
         }
         return ret ? ret : actually_written;
 }
@@ -2919,8 +2200,7 @@ static int idetape_write_filemark(ide_drive_t *drive)
  *
  * Note: MTBSF and MTBSFM are not supported when the tape doesn't support
  * spacing over filemarks in the reverse direction. In this case, MTFSFM is also
- * usually not supported (it is supported in the rare case in which we crossed
- * the filemark during our read-ahead pipelined operation mode).
+ * usually not supported.
  *
  * The following commands are currently not supported:
  *
@@ -2936,7 +2216,6 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
         debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n",
                         mt_op, mt_count);
 
-        /* Commands which need our pipelined read-ahead stages. */
         switch (mt_op) {
         case MTFSF:
         case MTFSFM:
@@ -2953,7 +2232,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
         case MTWEOF:
                 if (tape->write_prot)
                         return -EACCES;
-                idetape_discard_read_pipeline(drive, 1);
+                ide_tape_discard_merge_buffer(drive, 1);
                 for (i = 0; i < mt_count; i++) {
                         retval = idetape_write_filemark(drive);
                         if (retval)
@@ -2961,12 +2240,12 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
                 }
                 return 0;
         case MTREW:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 if (idetape_rewind_tape(drive))
                         return -EIO;
                 return 0;
         case MTLOAD:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 idetape_create_load_unload_cmd(drive, &pc,
                                                IDETAPE_LU_LOAD_MASK);
                 return idetape_queue_pc_tail(drive, &pc);
@@ -2981,7 +2260,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
                                 if (!idetape_queue_pc_tail(drive, &pc))
                                         tape->door_locked = DOOR_UNLOCKED;
                 }
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 idetape_create_load_unload_cmd(drive, &pc,
                                               !IDETAPE_LU_LOAD_MASK);
                 retval = idetape_queue_pc_tail(drive, &pc);
@@ -2989,10 +2268,10 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
                         clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags);
                 return retval;
         case MTNOP:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 return idetape_flush_tape_buffers(drive);
         case MTRETEN:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 idetape_create_load_unload_cmd(drive, &pc,
                         IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
                 return idetape_queue_pc_tail(drive, &pc);
@@ -3014,11 +2293,11 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
                         set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags);
                 return 0;
         case MTSEEK:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 return idetape_position_tape(drive,
                         mt_count * tape->user_bs_factor, tape->partition, 0);
         case MTSETPART:
-                idetape_discard_read_pipeline(drive, 0);
+                ide_tape_discard_merge_buffer(drive, 0);
                 return idetape_position_tape(drive, 0, mt_count, 0);
         case MTFSR:
         case MTBSR:
@@ -3063,13 +2342,12 @@ static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,
 
         debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd);
 
-        tape->restart_speed_control_req = 1;
         if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
-                idetape_empty_write_pipeline(drive);
+                ide_tape_flush_merge_buffer(drive);
                 idetape_flush_tape_buffers(drive);
         }
         if (cmd == MTIOCGET || cmd == MTIOCPOS) {
-                block_offset = idetape_pipeline_size(drive) /
+                block_offset = tape->merge_bh_size /
                         (tape->blk_size * tape->user_bs_factor);
                 position = idetape_read_position(drive);
                 if (position < 0)
@@ -3101,7 +2379,7 @@ static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,
                 return 0;
         default:
                 if (tape->chrdev_dir == IDETAPE_DIR_READ)
-                        idetape_discard_read_pipeline(drive, 1);
+                        ide_tape_discard_merge_buffer(drive, 1);
                 return idetape_blkdev_ioctl(drive, cmd, arg);
         }
 }
@@ -3175,9 +2453,6 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp)
         if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags))
                 (void)idetape_rewind_tape(drive);
 
-        if (tape->chrdev_dir != IDETAPE_DIR_READ)
-                clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);
-
         /* Read block size and write protect status from drive. */
         ide_tape_get_bsize_from_bdesc(drive);
 
@@ -3206,8 +2481,6 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp)
                         }
                 }
         }
-        idetape_restart_speed_control(drive);
-        tape->restart_speed_control_req = 0;
         return 0;
 
 out_put_tape:
@@ -3219,13 +2492,13 @@ static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
 {
         idetape_tape_t *tape = drive->driver_data;
 
-        idetape_empty_write_pipeline(drive);
-        tape->merge_stage = __idetape_kmalloc_stage(tape, 1, 0);
-        if (tape->merge_stage != NULL) {
+        ide_tape_flush_merge_buffer(drive);
+        tape->merge_bh = ide_tape_kmalloc_buffer(tape, 1, 0);
+        if (tape->merge_bh != NULL) {
                 idetape_pad_zeros(drive, tape->blk_size *
                                 (tape->user_bs_factor - 1));
-                __idetape_kfree_stage(tape->merge_stage);
-                tape->merge_stage = NULL;
+                ide_tape_kfree_buffer(tape);
+                tape->merge_bh = NULL;
         }
         idetape_write_filemark(drive);
         idetape_flush_tape_buffers(drive);
@@ -3248,14 +2521,9 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp)
                 idetape_write_release(drive, minor);
         if (tape->chrdev_dir == IDETAPE_DIR_READ) {
                 if (minor < 128)
-                        idetape_discard_read_pipeline(drive, 1);
-                else
-                        idetape_wait_for_pipeline(drive);
-        }
-        if (tape->cache_stage != NULL) {
-                __idetape_kfree_stage(tape->cache_stage);
-                tape->cache_stage = NULL;
+                        ide_tape_discard_merge_buffer(drive, 1);
         }
+
         if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags))
                 (void) idetape_rewind_tape(drive);
         if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
@@ -3392,33 +2660,15 @@ static void idetape_add_settings(ide_drive_t *drive)
 
         ide_add_setting(drive, "buffer", SETTING_READ, TYPE_SHORT, 0, 0xffff,
                         1, 2, (u16 *)&tape->caps[16], NULL);
-        ide_add_setting(drive, "pipeline_min", SETTING_RW, TYPE_INT, 1, 0xffff,
-                        tape->stage_size / 1024, 1, &tape->min_pipeline, NULL);
-        ide_add_setting(drive, "pipeline", SETTING_RW, TYPE_INT, 1, 0xffff,
-                        tape->stage_size / 1024, 1, &tape->max_stages, NULL);
-        ide_add_setting(drive, "pipeline_max", SETTING_RW, TYPE_INT, 1, 0xffff,
-                        tape->stage_size / 1024, 1, &tape->max_pipeline, NULL);
-        ide_add_setting(drive, "pipeline_used", SETTING_READ, TYPE_INT, 0,
-                        0xffff, tape->stage_size / 1024, 1, &tape->nr_stages,
-                        NULL);
-        ide_add_setting(drive, "pipeline_pending", SETTING_READ, TYPE_INT, 0,
-                        0xffff, tape->stage_size / 1024, 1,
-                        &tape->nr_pending_stages, NULL);
         ide_add_setting(drive, "speed", SETTING_READ, TYPE_SHORT, 0, 0xffff,
                         1, 1, (u16 *)&tape->caps[14], NULL);
-        ide_add_setting(drive, "stage", SETTING_READ, TYPE_INT, 0, 0xffff, 1,
-                        1024, &tape->stage_size, NULL);
+        ide_add_setting(drive, "buffer_size", SETTING_READ, TYPE_INT, 0, 0xffff,
+                        1, 1024, &tape->buffer_size, NULL);
         ide_add_setting(drive, "tdsc", SETTING_RW, TYPE_INT, IDETAPE_DSC_RW_MIN,
                         IDETAPE_DSC_RW_MAX, 1000, HZ, &tape->best_dsc_rw_freq,
                         NULL);
         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1,
                         1, &drive->dsc_overlap, NULL);
-        ide_add_setting(drive, "pipeline_head_speed_c", SETTING_READ, TYPE_INT,
-                        0, 0xffff, 1, 1, &tape->controlled_pipeline_head_speed,
-                        NULL);
-        ide_add_setting(drive, "pipeline_head_speed_u", SETTING_READ, TYPE_INT,
-                        0, 0xffff, 1, 1,
-                        &tape->uncontrolled_pipeline_head_speed, NULL);
         ide_add_setting(drive, "avg_speed", SETTING_READ, TYPE_INT, 0, 0xffff,
                         1, 1, &tape->avg_speed, NULL);
         ide_add_setting(drive, "debug_mask", SETTING_RW, TYPE_INT, 0, 0xffff, 1,
@@ -3441,11 +2691,10 @@ static inline void idetape_add_settings(ide_drive_t *drive) { ; }
  */
 static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
 {
-        unsigned long t1, tmid, tn, t;
+        unsigned long t;
         int speed;
-        int stage_size;
+        int buffer_size;
         u8 gcw[2];
-        struct sysinfo si;
         u16 *ctl = (u16 *)&tape->caps[12];
 
         spin_lock_init(&tape->lock);
@@ -3464,65 +2713,33 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
         tape->name[2] = '0' + minor;
         tape->chrdev_dir = IDETAPE_DIR_NONE;
         tape->pc = tape->pc_stack;
-        tape->max_insert_speed = 10000;
-        tape->speed_control = 1;
         *((unsigned short *) &gcw) = drive->id->config;
 
         /* Command packet DRQ type */
         if (((gcw[0] & 0x60) >> 5) == 1)
                 set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags);
 
-        tape->min_pipeline = 10;
-        tape->max_pipeline = 10;
-        tape->max_stages   = 10;
-
         idetape_get_inquiry_results(drive);
         idetape_get_mode_sense_results(drive);
         ide_tape_get_bsize_from_bdesc(drive);
         tape->user_bs_factor = 1;
-        tape->stage_size = *ctl * tape->blk_size;
-        while (tape->stage_size > 0xffff) {
+        tape->buffer_size = *ctl * tape->blk_size;
+        while (tape->buffer_size > 0xffff) {
                 printk(KERN_NOTICE "ide-tape: decreasing stage size\n");
                 *ctl /= 2;
-                tape->stage_size = *ctl * tape->blk_size;
+                tape->buffer_size = *ctl * tape->blk_size;
         }
-        stage_size = tape->stage_size;
-        tape->pages_per_stage = stage_size / PAGE_SIZE;
-        if (stage_size % PAGE_SIZE) {
-                tape->pages_per_stage++;
-                tape->excess_bh_size = PAGE_SIZE - stage_size % PAGE_SIZE;
+        buffer_size = tape->buffer_size;
+        tape->pages_per_buffer = buffer_size / PAGE_SIZE;
+        if (buffer_size % PAGE_SIZE) {
+                tape->pages_per_buffer++;
+                tape->excess_bh_size = PAGE_SIZE - buffer_size % PAGE_SIZE;
         }
 
-        /* Select the "best" DSC read/write polling freq and pipeline size. */
+        /* select the "best" DSC read/write polling freq */
         speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
 
-        tape->max_stages = speed * 1000 * 10 / tape->stage_size;
-
-        /* Limit memory use for pipeline to 10% of physical memory */
-        si_meminfo(&si);
-        if (tape->max_stages * tape->stage_size >
-                        si.totalram * si.mem_unit / 10)
-                tape->max_stages =
-                        si.totalram * si.mem_unit / (10 * tape->stage_size);
-
-        tape->max_stages   = min(tape->max_stages, IDETAPE_MAX_PIPELINE_STAGES);
-        tape->min_pipeline = min(tape->max_stages, IDETAPE_MIN_PIPELINE_STAGES);
-        tape->max_pipeline =
-                min(tape->max_stages * 2, IDETAPE_MAX_PIPELINE_STAGES);
-        if (tape->max_stages == 0) {
-                tape->max_stages   = 1;
-                tape->min_pipeline = 1;
-                tape->max_pipeline = 1;
-        }
-
-        t1 = (tape->stage_size * HZ) / (speed * 1000);
-        tmid = (*(u16 *)&tape->caps[16] * 32 * HZ) / (speed * 125);
-        tn = (IDETAPE_FIFO_THRESHOLD * tape->stage_size * HZ) / (speed * 1000);
-
-        if (tape->max_stages)
-                t = tn;
-        else
-                t = t1;
+        t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000);
 
         /*
          * Ensure that the number we got makes sense; limit it within
@@ -3532,11 +2749,10 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
                                 min_t(unsigned long, t, IDETAPE_DSC_RW_MAX),
                                 IDETAPE_DSC_RW_MIN);
         printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, "
-                "%dkB pipeline, %lums tDSC%s\n",
+                "%lums tDSC%s\n",
                 drive->name, tape->name, *(u16 *)&tape->caps[14],
-                (*(u16 *)&tape->caps[16] * 512) / tape->stage_size,
-                tape->stage_size / 1024,
-                tape->max_stages * tape->stage_size / 1024,
+                (*(u16 *)&tape->caps[16] * 512) / tape->buffer_size,
+                tape->buffer_size / 1024,
                 tape->best_dsc_rw_freq * 1000 / HZ,
                 drive->using_dma ? ", DMA":"");
 
@@ -3560,7 +2776,7 @@ static void ide_tape_release(struct kref *kref)
         ide_drive_t *drive = tape->drive;
         struct gendisk *g = tape->disk;
 
-        BUG_ON(tape->first_stage != NULL || tape->merge_stage_size);
+        BUG_ON(tape->merge_bh_size);
 
         drive->dsc_overlap = 0;
         drive->driver_data = NULL;
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 155cc904f4eb..9f9ad9fb6b89 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -36,6 +36,7 @@
 void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
 {
         ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
         struct ide_taskfile *tf = &task->tf;
         u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
 
@@ -59,34 +60,33 @@ void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
                 SELECT_MASK(drive, 0);
 
         if (task->tf_flags & IDE_TFLAG_OUT_DATA)
-                hwif->OUTW((tf->hob_data << 8) | tf->data,
-                           hwif->io_ports[IDE_DATA_OFFSET]);
+                hwif->OUTW((tf->hob_data << 8) | tf->data, io_ports->data_addr);
 
         if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                hwif->OUTB(tf->hob_feature, hwif->io_ports[IDE_FEATURE_OFFSET]);
+                hwif->OUTB(tf->hob_feature, io_ports->feature_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                hwif->OUTB(tf->hob_nsect, hwif->io_ports[IDE_NSECTOR_OFFSET]);
+                hwif->OUTB(tf->hob_nsect, io_ports->nsect_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                hwif->OUTB(tf->hob_lbal, hwif->io_ports[IDE_SECTOR_OFFSET]);
+                hwif->OUTB(tf->hob_lbal, io_ports->lbal_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                hwif->OUTB(tf->hob_lbam, hwif->io_ports[IDE_LCYL_OFFSET]);
+                hwif->OUTB(tf->hob_lbam, io_ports->lbam_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                hwif->OUTB(tf->hob_lbah, hwif->io_ports[IDE_HCYL_OFFSET]);
+                hwif->OUTB(tf->hob_lbah, io_ports->lbah_addr);
 
         if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                hwif->OUTB(tf->feature, hwif->io_ports[IDE_FEATURE_OFFSET]);
+                hwif->OUTB(tf->feature, io_ports->feature_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
-                hwif->OUTB(tf->nsect, hwif->io_ports[IDE_NSECTOR_OFFSET]);
+                hwif->OUTB(tf->nsect, io_ports->nsect_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
-                hwif->OUTB(tf->lbal, hwif->io_ports[IDE_SECTOR_OFFSET]);
+                hwif->OUTB(tf->lbal, io_ports->lbal_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
-                hwif->OUTB(tf->lbam, hwif->io_ports[IDE_LCYL_OFFSET]);
+                hwif->OUTB(tf->lbam, io_ports->lbam_addr);
         if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
-                hwif->OUTB(tf->lbah, hwif->io_ports[IDE_HCYL_OFFSET]);
+                hwif->OUTB(tf->lbah, io_ports->lbah_addr);
 
         if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
                 hwif->OUTB((tf->device & HIHI) | drive->select.all,
-                           hwif->io_ports[IDE_SELECT_OFFSET]);
+                           io_ports->device_addr);
 }
 
 int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf)
@@ -135,6 +135,7 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
         ide_hwif_t *hwif        = HWIF(drive);
         struct ide_taskfile *tf = &task->tf;
         ide_handler_t *handler = NULL;
+        const struct ide_dma_ops *dma_ops = hwif->dma_ops;
 
         if (task->data_phase == TASKFILE_MULTI_IN ||
             task->data_phase == TASKFILE_MULTI_OUT) {
@@ -154,8 +155,7 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
         switch (task->data_phase) {
         case TASKFILE_MULTI_OUT:
         case TASKFILE_OUT:
-                hwif->OUTBSYNC(drive, tf->command,
-                               hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTBSYNC(drive, tf->command, hwif->io_ports.command_addr);
                 ndelay(400);    /* FIXME */
                 return pre_task_out_intr(drive, task->rq);
         case TASKFILE_MULTI_IN:
@@ -178,10 +178,10 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
                 return ide_started;
         default:
                 if (task_dma_ok(task) == 0 || drive->using_dma == 0 ||
-                    hwif->dma_setup(drive))
+                    dma_ops->dma_setup(drive))
                         return ide_stopped;
-                hwif->dma_exec_cmd(drive, tf->command);
-                hwif->dma_start(drive);
+                dma_ops->dma_exec_cmd(drive, tf->command);
+                dma_ops->dma_start(drive);
                 return ide_started;
         }
 }
@@ -455,7 +455,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
 
         /* Error? */
         if (stat & ERR_STAT)
-                return task_error(drive, rq, __FUNCTION__, stat);
+                return task_error(drive, rq, __func__, stat);
 
         /* Didn't want any data? Odd. */
         if (!(stat & DRQ_STAT))
@@ -467,7 +467,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
         if (!hwif->nleft) {
                 stat = wait_drive_not_busy(drive);
                 if (!OK_STAT(stat, 0, BAD_STAT))
-                        return task_error(drive, rq, __FUNCTION__, stat);
+                        return task_error(drive, rq, __func__, stat);
                 task_end_request(drive, rq, stat);
                 return ide_stopped;
         }
@@ -488,11 +488,11 @@ static ide_startstop_t task_out_intr (ide_drive_t *drive)
         u8 stat = ide_read_status(drive);
 
         if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat))
-                return task_error(drive, rq, __FUNCTION__, stat);
+                return task_error(drive, rq, __func__, stat);
 
         /* Deal with unexpected ATA data phase. */
         if (((stat & DRQ_STAT) == 0) ^ !hwif->nleft)
-                return task_error(drive, rq, __FUNCTION__, stat);
+                return task_error(drive, rq, __func__, stat);
 
         if (!hwif->nleft) {
                 task_end_request(drive, rq, stat);
@@ -675,7 +675,7 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
                                 /* (hs): give up if multcount is not set */
                                 printk(KERN_ERR "%s: %s Multimode Write " \
                                         "multcount is not set\n",
-                                        drive->name, __FUNCTION__);
+                                        drive->name, __func__);
                                 err = -EPERM;
                                 goto abort;
                         }
@@ -692,7 +692,7 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
                                 /* (hs): give up if multcount is not set */
                                 printk(KERN_ERR "%s: %s Multimode Read failure " \
                                         "multcount is not set\n",
-                                        drive->name, __FUNCTION__);
+                                        drive->name, __func__);
                                 err = -EPERM;
                                 goto abort;
                         }
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 917c72dcd33d..999584c03d97 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -94,19 +94,8 @@ DEFINE_MUTEX(ide_cfg_mtx);
 
 int noautodma = 0;
 
-#ifdef CONFIG_BLK_DEV_IDEACPI
-int ide_noacpi = 0;
-int ide_noacpitfs = 1;
-int ide_noacpionboot = 1;
-#endif
-
-/*
- * This is declared extern in ide.h, for access by other IDE modules:
- */
 ide_hwif_t ide_hwifs[MAX_HWIFS];        /* master data repository */
 
-EXPORT_SYMBOL(ide_hwifs);
-
 static void ide_port_init_devices_data(ide_hwif_t *);
 
 /*
@@ -232,117 +221,6 @@ static int ide_system_bus_speed(void)
         return pci_dev_present(pci_default) ? 33 : 50;
 }
 
-ide_hwif_t * ide_find_port(unsigned long base)
-{
-        ide_hwif_t *hwif;
-        int i;
-
-        for (i = 0; i < MAX_HWIFS; i++) {
-                hwif = &ide_hwifs[i];
-                if (hwif->io_ports[IDE_DATA_OFFSET] == base)
-                        goto found;
-        }
-
-        for (i = 0; i < MAX_HWIFS; i++) {
-                hwif = &ide_hwifs[i];
-                if (hwif->chipset == ide_unknown)
-                        goto found;
-        }
-
-        hwif = NULL;
-found:
-        return hwif;
-}
-
-EXPORT_SYMBOL_GPL(ide_find_port);
-
-static struct resource* hwif_request_region(ide_hwif_t *hwif,
-                                            unsigned long addr, int num)
-{
-        struct resource *res = request_region(addr, num, hwif->name);
-
-        if (!res)
-                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
-                                hwif->name, addr, addr+num-1);
-        return res;
-}
-
-/**
- *      ide_hwif_request_regions - request resources for IDE
- *      @hwif: interface to use
- *
- *      Requests all the needed resources for an interface.
- *      Right now core IDE code does this work which is deeply wrong.
- *      MMIO leaves it to the controller driver,
- *      PIO will migrate this way over time.
- */
-
-int ide_hwif_request_regions(ide_hwif_t *hwif)
-{
-        unsigned long addr;
-        unsigned int i;
-
-        if (hwif->mmio)
-                return 0;
-        addr = hwif->io_ports[IDE_CONTROL_OFFSET];
-        if (addr && !hwif_request_region(hwif, addr, 1))
-                goto control_region_busy;
-        hwif->straight8 = 0;
-        addr = hwif->io_ports[IDE_DATA_OFFSET];
-        if ((addr | 7) == hwif->io_ports[IDE_STATUS_OFFSET]) {
-                if (!hwif_request_region(hwif, addr, 8))
-                        goto data_region_busy;
-                hwif->straight8 = 1;
-                return 0;
-        }
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
-                addr = hwif->io_ports[i];
-                if (!hwif_request_region(hwif, addr, 1)) {
-                        while (--i)
-                                release_region(addr, 1);
-                        goto data_region_busy;
-                }
-        }
-        return 0;
-
-data_region_busy:
-        addr = hwif->io_ports[IDE_CONTROL_OFFSET];
-        if (addr)
-                release_region(addr, 1);
-control_region_busy:
-        /* If any errors are return, we drop the hwif interface. */
-        return -EBUSY;
-}
-
-/**
- *      ide_hwif_release_regions - free IDE resources
- *
- *      Note that we only release the standard ports,
- *      and do not even try to handle any extra ports
- *      allocated for weird IDE interface chipsets.
- *
- *      Note also that we don't yet handle mmio resources here. More
- *      importantly our caller should be doing this so we need to 
- *      restructure this as a helper function for drivers.
- */
-
-void ide_hwif_release_regions(ide_hwif_t *hwif)
-{
-        u32 i = 0;
-
-        if (hwif->mmio)
-                return;
-        if (hwif->io_ports[IDE_CONTROL_OFFSET])
-                release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1);
-        if (hwif->straight8) {
-                release_region(hwif->io_ports[IDE_DATA_OFFSET], 8);
-                return;
-        }
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
-                if (hwif->io_ports[i])
-                        release_region(hwif->io_ports[i], 1);
-}
-
 void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
 {
         ide_hwgroup_t *hwgroup = hwif->hwgroup;
@@ -409,7 +287,7 @@ EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
 
 /**
  *      ide_unregister          -       free an IDE interface
- *      @index: index of interface (will change soon to a pointer)
+ *      @hwif: IDE interface
  *
  *      Perform the final unregister of an IDE interface. At the moment
  *      we don't refcount interfaces so this will also get split up.
@@ -429,19 +307,16 @@ EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
  *      This is raving bonkers.
  */
 
-void ide_unregister(unsigned int index)
+void ide_unregister(ide_hwif_t *hwif)
 {
-        ide_hwif_t *hwif, *g;
+        ide_hwif_t *g;
         ide_hwgroup_t *hwgroup;
         int irq_count = 0;
 
-        BUG_ON(index >= MAX_HWIFS);
-
         BUG_ON(in_interrupt());
         BUG_ON(irqs_disabled());
         mutex_lock(&ide_cfg_mtx);
         spin_lock_irq(&ide_lock);
-        hwif = &ide_hwifs[index];
         if (!hwif->present)
                 goto abort;
         __ide_port_unregister_devices(hwif);
@@ -479,12 +354,10 @@ void ide_unregister(unsigned int index)
         spin_lock_irq(&ide_lock);
 
         if (hwif->dma_base)
-                (void)ide_release_dma(hwif);
-
-        ide_hwif_release_regions(hwif);
+                ide_release_dma_engine(hwif);
 
         /* restore hwif data to pristine status */
-        ide_init_port_data(hwif, index);
+        ide_init_port_data(hwif, hwif->index);
 
 abort:
         spin_unlock_irq(&ide_lock);
@@ -495,9 +368,8 @@ EXPORT_SYMBOL(ide_unregister);
 
 void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
 {
-        memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports));
+        memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
         hwif->irq = hw->irq;
-        hwif->noprobe = 0;
         hwif->chipset = hw->chipset;
         hwif->gendev.parent = hw->dev;
         hwif->ack_intr = hw->ack_intr;
@@ -588,7 +460,7 @@ int set_using_dma(ide_drive_t *drive, int arg)
         if (!drive->id || !(drive->id->capability & 1))
                 goto out;
 
-        if (hwif->dma_host_set == NULL)
+        if (hwif->dma_ops == NULL)
                 goto out;
 
         err = -EBUSY;
@@ -627,11 +499,14 @@ out:
 int set_pio_mode(ide_drive_t *drive, int arg)
 {
         struct request rq;
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
 
         if (arg < 0 || arg > 255)
                 return -EINVAL;
 
-        if (drive->hwif->set_pio_mode == NULL)
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
                 return -ENOSYS;
 
         if (drive->special.b.set_tune)
@@ -953,16 +828,6 @@ static int __init match_parm (char *s, const char *keywords[], int vals[], int m
         return 0;       /* zero = nothing matched */
 }
 
-extern int probe_ali14xx;
-extern int probe_umc8672;
-extern int probe_dtc2278;
-extern int probe_ht6560b;
-extern int probe_qd65xx;
-extern int cmd640_vlb;
-extern int probe_4drives;
-
-static int __initdata is_chipset_set;
-
 /*
  * ide_setup() gets called VERY EARLY during initialization,
  * to handle kernel "command line" strings beginning with "hdx=" or "ide".
@@ -971,14 +836,12 @@ static int __initdata is_chipset_set;
  */
 static int __init ide_setup(char *s)
 {
-        int i, vals[3];
         ide_hwif_t *hwif;
         ide_drive_t *drive;
         unsigned int hw, unit;
+        int vals[3];
         const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
-        const char max_hwif  = '0' + (MAX_HWIFS - 1);
 
-        
         if (strncmp(s,"hd",2) == 0 && s[2] == '=')      /* hd= is for hd.c   */
                 return 0;                               /* driver and not us */
 
@@ -994,7 +857,7 @@ static int __init ide_setup(char *s)
 
                 printk(" : Enabled support for IDE doublers\n");
                 ide_doubler = 1;
-                return 1;
+                goto obsolete_option;
         }
 #endif /* CONFIG_BLK_DEV_IDEDOUBLER */
 
@@ -1008,17 +871,17 @@ static int __init ide_setup(char *s)
         if (!strcmp(s, "ide=noacpi")) {
                 //printk(" : Disable IDE ACPI support.\n");
                 ide_noacpi = 1;
-                return 1;
+                goto obsolete_option;
         }
         if (!strcmp(s, "ide=acpigtf")) {
                 //printk(" : Enable IDE ACPI _GTF support.\n");
-                ide_noacpitfs = 0;
-                return 1;
+                ide_acpigtf = 1;
+                goto obsolete_option;
         }
         if (!strcmp(s, "ide=acpionboot")) {
                 //printk(" : Call IDE ACPI methods on boot.\n");
-                ide_noacpionboot = 0;
-                return 1;
+                ide_acpionboot = 1;
+                goto obsolete_option;
         }
 #endif /* CONFIG_BLK_DEV_IDEACPI */
 
@@ -1028,7 +891,7 @@ static int __init ide_setup(char *s)
         if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) {
                 const char *hd_words[] = {
                         "none", "noprobe", "nowerr", "cdrom", "nodma",
-                        "autotune", "noautotune", "-8", "-9", "-10",
+                        "-6", "-7", "-8", "-9", "-10",
                         "noflush", "remap", "remap63", "scsi", NULL };
                 unit = s[2] - 'a';
                 hw   = unit / MAX_DRIVES;
@@ -1043,30 +906,22 @@ static int __init ide_setup(char *s)
                         case -1: /* "none" */
                         case -2: /* "noprobe" */
                                 drive->noprobe = 1;
-                                goto done;
+                                goto obsolete_option;
                         case -3: /* "nowerr" */
                                 drive->bad_wstat = BAD_R_STAT;
-                                hwif->noprobe = 0;
-                                goto done;
+                                goto obsolete_option;
                         case -4: /* "cdrom" */
                                 drive->present = 1;
                                 drive->media = ide_cdrom;
                                 /* an ATAPI device ignores DRDY */
                                 drive->ready_stat = 0;
-                                hwif->noprobe = 0;
-                                goto done;
+                                goto obsolete_option;
                         case -5: /* nodma */
                                 drive->nodma = 1;
-                                goto done;
-                        case -6: /* "autotune" */
-                                drive->autotune = IDE_TUNE_AUTO;
-                                goto obsolete_option;
-                        case -7: /* "noautotune" */
-                                drive->autotune = IDE_TUNE_NOAUTO;
                                 goto obsolete_option;
                         case -11: /* noflush */
                                 drive->noflush = 1;
-                                goto done;
+                                goto obsolete_option;
                         case -12: /* "remap" */
                                 drive->remap_0_to_1 = 1;
                                 goto obsolete_option;
@@ -1084,8 +939,7 @@ static int __init ide_setup(char *s)
                                 drive->sect     = drive->bios_sect = vals[2];
                                 drive->present  = 1;
                                 drive->forced_geom = 1;
-                                hwif->noprobe = 0;
-                                goto done;
+                                goto obsolete_option;
                         default:
                                 goto bad_option;
                 }
@@ -1103,126 +957,15 @@ static int __init ide_setup(char *s)
                         idebus_parameter = vals[0];
                 } else
                         printk(" -- BAD BUS SPEED! Expected value from 20 to 66");
-                goto done;
+                goto obsolete_option;
         }
-        /*
-         * Look for interface options:  "idex="
-         */
-        if (s[3] >= '0' && s[3] <= max_hwif) {
-                /*
-                 * Be VERY CAREFUL changing this: note hardcoded indexes below
-                 * (-8, -9, -10) are reserved to ease the hardcoding.
-                 */
-                static const char *ide_words[] = {
-                        "minus1", "serialize", "minus3", "minus4",
-                        "reset", "minus6", "ata66", "minus8", "minus9",
-                        "minus10", "four", "qd65xx", "ht6560b", "cmd640_vlb",
-                        "dtc2278", "umc8672", "ali14xx", NULL };
-
-                hw = s[3] - '0';
-                hwif = &ide_hwifs[hw];
-                i = match_parm(&s[4], ide_words, vals, 3);
 
-                /*
-                 * Cryptic check to ensure chipset not already set for hwif.
-                 * Note: we can't depend on hwif->chipset here.
-                 */
-                if (i >= -18 && i <= -11) {
-                        /* chipset already specified */
-                        if (is_chipset_set)
-                                goto bad_option;
-                        /* these drivers are for "ide0=" only */
-                        if (hw != 0)
-                                goto bad_hwif;
-                        is_chipset_set = 1;
-                        printk("\n");
-                }
-
-                switch (i) {
-#ifdef CONFIG_BLK_DEV_ALI14XX
-                        case -17: /* "ali14xx" */
-                                probe_ali14xx = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_UMC8672
-                        case -16: /* "umc8672" */
-                                probe_umc8672 = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_DTC2278
-                        case -15: /* "dtc2278" */
-                                probe_dtc2278 = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_CMD640
-                        case -14: /* "cmd640_vlb" */
-                                cmd640_vlb = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_HT6560B
-                        case -13: /* "ht6560b" */
-                                probe_ht6560b = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_QD65XX
-                        case -12: /* "qd65xx" */
-                                probe_qd65xx = 1;
-                                goto obsolete_option;
-#endif
-#ifdef CONFIG_BLK_DEV_4DRIVES
-                        case -11: /* "four" drives on one set of ports */
-                                probe_4drives = 1;
-                                goto obsolete_option;
-#endif
-                        case -10: /* minus10 */
-                        case -9: /* minus9 */
-                        case -8: /* minus8 */
-                        case -6:
-                        case -4:
-                        case -3:
-                                goto bad_option;
-                        case -7: /* ata66 */
-#ifdef CONFIG_BLK_DEV_IDEPCI
-                                /*
-                                 * Use ATA_CBL_PATA40_SHORT so drive side
-                                 * cable detection is also overriden.
-                                 */
-                                hwif->cbl = ATA_CBL_PATA40_SHORT;
-                                goto obsolete_option;
-#else
-                                goto bad_hwif;
-#endif
-                        case -5: /* "reset" */
-                                hwif->reset = 1;
-                                goto obsolete_option;
-                        case -2: /* "serialize" */
-                                hwif->mate = &ide_hwifs[hw^1];
-                                hwif->mate->mate = hwif;
-                                hwif->serialized = hwif->mate->serialized = 1;
-                                goto obsolete_option;
-
-                        case -1:
-                        case 0:
-                        case 1:
-                        case 2:
-                        case 3:
-                                goto bad_option;
-                        default:
-                                printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
-                                return 1;
-                }
-        }
 bad_option:
         printk(" -- BAD OPTION\n");
         return 1;
 obsolete_option:
         printk(" -- OBSOLETE OPTION, WILL BE REMOVED SOON!\n");
         return 1;
-bad_hwif:
-        printk("-- NOT SUPPORTED ON ide%d", hw);
-done:
-        printk("\n");
-        return 1;
 }
 
 EXPORT_SYMBOL(ide_lock);
@@ -1358,6 +1101,185 @@ static void ide_port_class_release(struct device *portdev)
         put_device(&hwif->gendev);
 }
 
+int ide_vlb_clk;
+EXPORT_SYMBOL_GPL(ide_vlb_clk);
+
+module_param_named(vlb_clock, ide_vlb_clk, int, 0);
+MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)");
+
+int ide_pci_clk;
+EXPORT_SYMBOL_GPL(ide_pci_clk);
+
+module_param_named(pci_clock, ide_pci_clk, int, 0);
+MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)");
+
+static int ide_set_dev_param_mask(const char *s, struct kernel_param *kp)
+{
+        int a, b, i, j = 1;
+        unsigned int *dev_param_mask = (unsigned int *)kp->arg;
+
+        if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 &&
+            sscanf(s, "%d.%d", &a, &b) != 2)
+                return -EINVAL;
+
+        i = a * MAX_DRIVES + b;
+
+        if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
+                return -EINVAL;
+
+        if (j)
+                *dev_param_mask |= (1 << i);
+        else
+                *dev_param_mask &= (1 << i);
+
+        return 0;
+}
+
+static unsigned int ide_nodma;
+
+module_param_call(nodma, ide_set_dev_param_mask, NULL, &ide_nodma, 0);
+MODULE_PARM_DESC(nodma, "disallow DMA for a device");
+
+static unsigned int ide_noflush;
+
+module_param_call(noflush, ide_set_dev_param_mask, NULL, &ide_noflush, 0);
+MODULE_PARM_DESC(noflush, "disable flush requests for a device");
+
+static unsigned int ide_noprobe;
+
+module_param_call(noprobe, ide_set_dev_param_mask, NULL, &ide_noprobe, 0);
+MODULE_PARM_DESC(noprobe, "skip probing for a device");
+
+static unsigned int ide_nowerr;
+
+module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0);
+MODULE_PARM_DESC(nowerr, "ignore the WRERR_STAT bit for a device");
+
+static unsigned int ide_cdroms;
+
+module_param_call(cdrom, ide_set_dev_param_mask, NULL, &ide_cdroms, 0);
+MODULE_PARM_DESC(cdrom, "force device as a CD-ROM");
+
+struct chs_geom {
+        unsigned int    cyl;
+        u8              head;
+        u8              sect;
+};
+
+static unsigned int ide_disks;
+static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES];
+
+static int ide_set_disk_chs(const char *str, struct kernel_param *kp)
+{
+        int a, b, c = 0, h = 0, s = 0, i, j = 1;
+
+        if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 &&
+            sscanf(str, "%d.%d:%d", &a, &b, &j) != 3)
+                return -EINVAL;
+
+        i = a * MAX_DRIVES + b;
+
+        if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
+                return -EINVAL;
+
+        if (c > INT_MAX || h > 255 || s > 255)
+                return -EINVAL;
+
+        if (j)
+                ide_disks |= (1 << i);
+        else
+                ide_disks &= (1 << i);
+
+        ide_disks_chs[i].cyl  = c;
+        ide_disks_chs[i].head = h;
+        ide_disks_chs[i].sect = s;
+
+        return 0;
+}
+
+module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0);
+MODULE_PARM_DESC(chs, "force device as a disk (using CHS)");
+
+static void ide_dev_apply_params(ide_drive_t *drive)
+{
+        int i = drive->hwif->index * MAX_DRIVES + drive->select.b.unit;
+
+        if (ide_nodma & (1 << i)) {
+                printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name);
+                drive->nodma = 1;
+        }
+        if (ide_noflush & (1 << i)) {
+                printk(KERN_INFO "ide: disabling flush requests for %s\n",
+                                 drive->name);
+                drive->noflush = 1;
+        }
+        if (ide_noprobe & (1 << i)) {
+                printk(KERN_INFO "ide: skipping probe for %s\n", drive->name);
+                drive->noprobe = 1;
+        }
+        if (ide_nowerr & (1 << i)) {
+                printk(KERN_INFO "ide: ignoring the WRERR_STAT bit for %s\n",
+                                 drive->name);
+                drive->bad_wstat = BAD_R_STAT;
+        }
+        if (ide_cdroms & (1 << i)) {
+                printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name);
+                drive->present = 1;
+                drive->media = ide_cdrom;
+                /* an ATAPI device ignores DRDY */
+                drive->ready_stat = 0;
+        }
+        if (ide_disks & (1 << i)) {
+                drive->cyl  = drive->bios_cyl  = ide_disks_chs[i].cyl;
+                drive->head = drive->bios_head = ide_disks_chs[i].head;
+                drive->sect = drive->bios_sect = ide_disks_chs[i].sect;
+                drive->forced_geom = 1;
+                printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n",
+                                 drive->name,
+                                 drive->cyl, drive->head, drive->sect);
+                drive->present = 1;
+                drive->media = ide_disk;
+                drive->ready_stat = READY_STAT;
+        }
+}
+
+static unsigned int ide_ignore_cable;
+
+static int ide_set_ignore_cable(const char *s, struct kernel_param *kp)
+{
+        int i, j = 1;
+
+        if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1)
+                return -EINVAL;
+
+        if (i >= MAX_HWIFS || j < 0 || j > 1)
+                return -EINVAL;
+
+        if (j)
+                ide_ignore_cable |= (1 << i);
+        else
+                ide_ignore_cable &= (1 << i);
+
+        return 0;
+}
+
+module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0);
+MODULE_PARM_DESC(ignore_cable, "ignore cable detection");
+
+void ide_port_apply_params(ide_hwif_t *hwif)
+{
+        int i;
+
+        if (ide_ignore_cable & (1 << hwif->index)) {
+                printk(KERN_INFO "ide: ignoring cable detection for %s\n",
+                                 hwif->name);
+                hwif->cbl = ATA_CBL_PATA40_SHORT;
+        }
+
+        for (i = 0; i < MAX_DRIVES; i++)
+                ide_dev_apply_params(&hwif->drives[i]);
+}
+
 /*
  * This is gets invoked once during initialization, to set *everything* up
  */
@@ -1424,11 +1346,6 @@ int __init init_module (void)
 
 void __exit cleanup_module (void)
 {
-        int index;
-
-        for (index = 0; index < MAX_HWIFS; ++index)
-                ide_unregister(index);
-
         proc_ide_destroy();
 
         class_destroy(ide_port_class);
diff --git a/drivers/ide/legacy/ali14xx.c b/drivers/ide/legacy/ali14xx.c
index bc8b1f8de614..90c65cf97448 100644
--- a/drivers/ide/legacy/ali14xx.c
+++ b/drivers/ide/legacy/ali14xx.c
@@ -49,6 +49,8 @@
 
 #include <asm/io.h>
 
+#define DRV_NAME "ali14xx"
+
 /* port addresses for auto-detection */
 #define ALI_NUM_PORTS 4
 static const int ports[ALI_NUM_PORTS] __initdata =
@@ -86,7 +88,7 @@ static u8 regOff;	/* output to base port to close registers */
 /*
  * Read a controller register.
  */
-static inline u8 inReg (u8 reg)
+static inline u8 inReg(u8 reg)
 {
         outb_p(reg, regPort);
         return inb(dataPort);
@@ -95,7 +97,7 @@ static inline u8 inReg (u8 reg)
 /*
  * Write a controller register.
  */
-static void outReg (u8 data, u8 reg)
+static void outReg(u8 data, u8 reg)
 {
         outb_p(reg, regPort);
         outb_p(data, dataPort);
@@ -114,7 +116,7 @@ static void ali14xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
         int time1, time2;
         u8 param1, param2, param3, param4;
         unsigned long flags;
-        int bus_speed = system_bus_clock();
+        int bus_speed = ide_vlb_clk ? ide_vlb_clk : system_bus_clock();
 
         /* calculate timing, according to PIO mode */
         time1 = ide_pio_cycle_time(drive, pio);
@@ -143,7 +145,7 @@ static void ali14xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 /*
  * Auto-detect the IDE controller port.
  */
-static int __init findPort (void)
+static int __init findPort(void)
 {
         int i;
         u8 t;
@@ -175,7 +177,8 @@ static int __init findPort (void)
 /*
  * Initialize controller registers with default values.
  */
-static int __init initRegisters (void) {
+static int __init initRegisters(void)
+{
         const RegInitializer *p;
         u8 t;
         unsigned long flags;
@@ -191,17 +194,20 @@ static int __init initRegisters (void) {
         return t;
 }
 
+static const struct ide_port_ops ali14xx_port_ops = {
+        .set_pio_mode           = ali14xx_set_pio_mode,
+};
+
 static const struct ide_port_info ali14xx_port_info = {
+        .name                   = DRV_NAME,
         .chipset                = ide_ali14xx,
-        .host_flags             = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE,
+        .port_ops               = &ali14xx_port_ops,
+        .host_flags             = IDE_HFLAG_NO_DMA,
         .pio_mask               = ATA_PIO4,
 };
 
 static int __init ali14xx_probe(void)
 {
-        static u8 idx[4] = { 0, 1, 0xff, 0xff };
-        hw_regs_t hw[2];
-
         printk(KERN_DEBUG "ali14xx: base=0x%03x, regOn=0x%02x.\n",
                           basePort, regOn);
 
@@ -211,26 +217,10 @@ static int __init ali14xx_probe(void)
                 return 1;
         }
 
-        memset(&hw, 0, sizeof(hw));
-
-        ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
-        hw[0].irq = 14;
-
-        ide_std_init_ports(&hw[1], 0x170, 0x376);
-        hw[1].irq = 15;
-
-        ide_init_port_hw(&ide_hwifs[0], &hw[0]);
-        ide_init_port_hw(&ide_hwifs[1], &hw[1]);
-
-        ide_hwifs[0].set_pio_mode = &ali14xx_set_pio_mode;
-        ide_hwifs[1].set_pio_mode = &ali14xx_set_pio_mode;
-
-        ide_device_add(idx, &ali14xx_port_info);
-
-        return 0;
+        return ide_legacy_device_add(&ali14xx_port_info, 0);
 }
 
-int probe_ali14xx = 0;
+static int probe_ali14xx;
 
 module_param_named(probe, probe_ali14xx, bool, 0);
 MODULE_PARM_DESC(probe, "probe for ALI M14xx chipsets");
diff --git a/drivers/ide/legacy/buddha.c b/drivers/ide/legacy/buddha.c
index fdd3791e465f..5c730e4dd735 100644
--- a/drivers/ide/legacy/buddha.c
+++ b/drivers/ide/legacy/buddha.c
@@ -102,7 +102,7 @@ static int buddha_ack_intr(ide_hwif_t *hwif)
 {
     unsigned char ch;
 
-    ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]);
+    ch = z_readb(hwif->io_ports.irq_addr);
     if (!(ch & 0x80))
             return 0;
     return 1;
@@ -112,9 +112,9 @@ static int xsurf_ack_intr(ide_hwif_t *hwif)
 {
     unsigned char ch;
 
-    ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]);
+    ch = z_readb(hwif->io_ports.irq_addr);
     /* X-Surf needs a 0 written to IRQ register to ensure ISA bit A11 stays at 0 */
-    z_writeb(0, hwif->io_ports[IDE_IRQ_OFFSET]); 
+    z_writeb(0, hwif->io_ports.irq_addr);
     if (!(ch & 0x80))
             return 0;
     return 1;
@@ -128,13 +128,13 @@ static void __init buddha_setup_ports(hw_regs_t *hw, unsigned long base,
 
         memset(hw, 0, sizeof(*hw));
 
-        hw->io_ports[IDE_DATA_OFFSET] = base;
+        hw->io_ports.data_addr = base;
 
         for (i = 1; i < 8; i++)
-                hw->io_ports[i] = base + 2 + i * 4;
+                hw->io_ports_array[i] = base + 2 + i * 4;
 
-        hw->io_ports[IDE_CONTROL_OFFSET] = ctl;
-        hw->io_ports[IDE_IRQ_OFFSET] = irq_port;
+        hw->io_ports.ctl_addr = ctl;
+        hw->io_ports.irq_addr = irq_port;
 
         hw->irq = IRQ_AMIGA_PORTS;
         hw->ack_intr = ack_intr;
@@ -221,15 +221,13 @@ fail_base2:
 
                         buddha_setup_ports(&hw, base, ctl, irq_port, ack_intr);
 
-                        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+                        hwif = ide_find_port();
                         if (hwif) {
                                 u8 index = hwif->index;
 
                                 ide_init_port_data(hwif, index);
                                 ide_init_port_hw(hwif, &hw);
 
-                                hwif->mmio = 1;
-
                                 idx[i] = index;
                         }
                 }
diff --git a/drivers/ide/legacy/dtc2278.c b/drivers/ide/legacy/dtc2278.c
index 5f69cd2ea6f7..af791a02a120 100644
--- a/drivers/ide/legacy/dtc2278.c
+++ b/drivers/ide/legacy/dtc2278.c
@@ -16,6 +16,8 @@
 
 #include <asm/io.h>
 
+#define DRV_NAME "dtc2278"
+
 /*
  * Changing this #undef to #define may solve start up problems in some systems.
  */
@@ -86,30 +88,26 @@ static void dtc2278_set_pio_mode(ide_drive_t *drive, const u8 pio)
         }
 }
 
+static const struct ide_port_ops dtc2278_port_ops = {
+        .set_pio_mode           = dtc2278_set_pio_mode,
+};
+
 static const struct ide_port_info dtc2278_port_info __initdata = {
+        .name                   = DRV_NAME,
         .chipset                = ide_dtc2278,
+        .port_ops               = &dtc2278_port_ops,
         .host_flags             = IDE_HFLAG_SERIALIZE |
                                   IDE_HFLAG_NO_UNMASK_IRQS |
                                   IDE_HFLAG_IO_32BIT |
                                   /* disallow ->io_32bit changes */
                                   IDE_HFLAG_NO_IO_32BIT |
-                                  IDE_HFLAG_NO_DMA |
-                                  IDE_HFLAG_NO_AUTOTUNE,
+                                  IDE_HFLAG_NO_DMA,
         .pio_mask               = ATA_PIO4,
 };
 
 static int __init dtc2278_probe(void)
 {
         unsigned long flags;
-        ide_hwif_t *hwif, *mate;
-        static u8 idx[4] = { 0, 1, 0xff, 0xff };
-        hw_regs_t hw[2];
-
-        hwif = &ide_hwifs[0];
-        mate = &ide_hwifs[1];
-
-        if (hwif->chipset != ide_unknown || mate->chipset != ide_unknown)
-                return 1;
 
         local_irq_save(flags);
         /*
@@ -129,25 +127,10 @@ static int __init dtc2278_probe(void)
 #endif
         local_irq_restore(flags);
 
-        memset(&hw, 0, sizeof(hw));
-
-        ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
-        hw[0].irq = 14;
-
-        ide_std_init_ports(&hw[1], 0x170, 0x376);
-        hw[1].irq = 15;
-
-        ide_init_port_hw(hwif, &hw[0]);
-        ide_init_port_hw(mate, &hw[1]);
-
-        hwif->set_pio_mode = &dtc2278_set_pio_mode;
-
-        ide_device_add(idx, &dtc2278_port_info);
-
-        return 0;
+        return ide_legacy_device_add(&dtc2278_port_info, 0);
 }
 
-int probe_dtc2278 = 0;
+static int probe_dtc2278;
 
 module_param_named(probe, probe_dtc2278, bool, 0);
 MODULE_PARM_DESC(probe, "probe for DTC2278xx chipsets");
diff --git a/drivers/ide/legacy/falconide.c b/drivers/ide/legacy/falconide.c
index e950afa5939c..56cdaa0eeea5 100644
--- a/drivers/ide/legacy/falconide.c
+++ b/drivers/ide/legacy/falconide.c
@@ -22,6 +22,7 @@
 #include <asm/atariints.h>
 #include <asm/atari_stdma.h>
 
+#define DRV_NAME "falconide"
 
     /*
      *  Base of the IDE interface
@@ -49,12 +50,12 @@ static void __init falconide_setup_ports(hw_regs_t *hw)
 
         memset(hw, 0, sizeof(*hw));
 
-        hw->io_ports[IDE_DATA_OFFSET] = ATA_HD_BASE;
+        hw->io_ports.data_addr = ATA_HD_BASE;
 
         for (i = 1; i < 8; i++)
-                hw->io_ports[i] = ATA_HD_BASE + 1 + i * 4;
+                hw->io_ports_array[i] = ATA_HD_BASE + 1 + i * 4;
 
-        hw->io_ports[IDE_CONTROL_OFFSET] = ATA_HD_BASE + ATA_HD_CONTROL;
+        hw->io_ports.ctl_addr = ATA_HD_BASE + ATA_HD_CONTROL;
 
         hw->irq = IRQ_MFP_IDE;
         hw->ack_intr = NULL;
@@ -74,9 +75,14 @@ static int __init falconide_init(void)
 
         printk(KERN_INFO "ide: Falcon IDE controller\n");
 
+        if (!request_mem_region(ATA_HD_BASE, 0x40, DRV_NAME)) {
+                printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
+                return -EBUSY;
+        }
+
         falconide_setup_ports(&hw);
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif) {
                 u8 index = hwif->index;
                 u8 idx[4] = { index, 0xff, 0xff, 0xff };
diff --git a/drivers/ide/legacy/gayle.c b/drivers/ide/legacy/gayle.c
index e3b4638cc883..a9c2593a898c 100644
--- a/drivers/ide/legacy/gayle.c
+++ b/drivers/ide/legacy/gayle.c
@@ -63,6 +63,8 @@
 #define GAYLE_HAS_CONTROL_REG   (!ide_doubler)
 #define GAYLE_IDEREG_SIZE       (ide_doubler ? 0x1000 : 0x2000)
 int ide_doubler = 0;    /* support IDE doublers? */
+module_param_named(doubler, ide_doubler, bool, 0);
+MODULE_PARM_DESC(doubler, "enable support for IDE doublers");
 #endif /* CONFIG_BLK_DEV_IDEDOUBLER */
 
 
@@ -74,7 +76,7 @@ static int gayle_ack_intr_a4000(ide_hwif_t *hwif)
 {
     unsigned char ch;
 
-    ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]);
+    ch = z_readb(hwif->io_ports.irq_addr);
     if (!(ch & GAYLE_IRQ_IDE))
         return 0;
     return 1;
@@ -84,11 +86,11 @@ static int gayle_ack_intr_a1200(ide_hwif_t *hwif)
 {
     unsigned char ch;
 
-    ch = z_readb(hwif->io_ports[IDE_IRQ_OFFSET]);
+    ch = z_readb(hwif->io_ports.irq_addr);
     if (!(ch & GAYLE_IRQ_IDE))
         return 0;
-    (void)z_readb(hwif->io_ports[IDE_STATUS_OFFSET]);
-    z_writeb(0x7c, hwif->io_ports[IDE_IRQ_OFFSET]);
+    (void)z_readb(hwif->io_ports.status_addr);
+    z_writeb(0x7c, hwif->io_ports.irq_addr);
     return 1;
 }
 
@@ -100,13 +102,13 @@ static void __init gayle_setup_ports(hw_regs_t *hw, unsigned long base,
 
         memset(hw, 0, sizeof(*hw));
 
-        hw->io_ports[IDE_DATA_OFFSET] = base;
+        hw->io_ports.data_addr = base;
 
         for (i = 1; i < 8; i++)
-                hw->io_ports[i] = base + 2 + i * 4;
+                hw->io_ports_array[i] = base + 2 + i * 4;
 
-        hw->io_ports[IDE_CONTROL_OFFSET] = ctl;
-        hw->io_ports[IDE_IRQ_OFFSET] = irq_port;
+        hw->io_ports.ctl_addr = ctl;
+        hw->io_ports.irq_addr = irq_port;
 
         hw->irq = IRQ_AMIGA_PORTS;
         hw->ack_intr = ack_intr;
@@ -175,15 +177,13 @@ found:
 
         gayle_setup_ports(&hw, base, ctrlport, irqport, ack_intr);
 
-        hwif = ide_find_port(base);
+        hwif = ide_find_port();
         if (hwif) {
             u8 index = hwif->index;
 
             ide_init_port_data(hwif, index);
             ide_init_port_hw(hwif, &hw);
 
-            hwif->mmio = 1;
-
             idx[i] = index;
         } else
             release_mem_region(res_start, res_n);
diff --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index 0b0d86731927..abdedf56643e 100644
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -122,12 +122,12 @@ static int hd_error;
  *  This struct defines the HD's and their types.
  */
 struct hd_i_struct {
-        unsigned int head,sect,cyl,wpcom,lzone,ctl;
+        unsigned int head, sect, cyl, wpcom, lzone, ctl;
         int unit;
         int recalibrate;
         int special_op;
 };
-        
+
 #ifdef HD_TYPE
 static struct hd_i_struct hd_info[] = { HD_TYPE };
 static int NR_HD = ARRAY_SIZE(hd_info);
@@ -168,7 +168,7 @@ unsigned long read_timer(void)
 
         spin_lock_irqsave(&i8253_lock, flags);
         t = jiffies * 11932;
-        outb_p(0, 0x43);
+        outb_p(0, 0x43);
         i = inb_p(0x40);
         i |= inb(0x40) << 8;
         spin_unlock_irqrestore(&i8253_lock, flags);
@@ -183,7 +183,7 @@ static void __init hd_setup(char *str, int *ints)
         if (ints[0] != 3)
                 return;
         if (hd_info[0].head != 0)
-                hdind=1;
+                hdind = 1;
         hd_info[hdind].head = ints[2];
         hd_info[hdind].sect = ints[3];
         hd_info[hdind].cyl = ints[1];
@@ -193,7 +193,7 @@ static void __init hd_setup(char *str, int *ints)
         NR_HD = hdind+1;
 }
 
-static void dump_status (const char *msg, unsigned int stat)
+static void dump_status(const char *msg, unsigned int stat)
 {
         char *name = "hd?";
         if (CURRENT)
@@ -291,7 +291,6 @@ static int controller_ready(unsigned int drive, unsigned int head)
         return 0;
 }
 
-                
 static void hd_out(struct hd_i_struct *disk,
                    unsigned int nsect,
                    unsigned int sect,
@@ -313,15 +312,15 @@ static void hd_out(struct hd_i_struct *disk,
                 return;
         }
         SET_HANDLER(intr_addr);
-        outb_p(disk->ctl,HD_CMD);
-        port=HD_DATA;
-        outb_p(disk->wpcom>>2,++port);
-        outb_p(nsect,++port);
-        outb_p(sect,++port);
-        outb_p(cyl,++port);
-        outb_p(cyl>>8,++port);
-        outb_p(0xA0|(disk->unit<<4)|head,++port);
-        outb_p(cmd,++port);
+        outb_p(disk->ctl, HD_CMD);
+        port = HD_DATA;
+        outb_p(disk->wpcom >> 2, ++port);
+        outb_p(nsect, ++port);
+        outb_p(sect, ++port);
+        outb_p(cyl, ++port);
+        outb_p(cyl >> 8, ++port);
+        outb_p(0xA0 | (disk->unit << 4) | head, ++port);
+        outb_p(cmd, ++port);
 }
 
 static void hd_request (void);
@@ -344,14 +343,14 @@ static void reset_controller(void)
 {
         int     i;
 
-        outb_p(4,HD_CMD);
-        for(i = 0; i < 1000; i++) barrier();
-        outb_p(hd_info[0].ctl & 0x0f,HD_CMD);
-        for(i = 0; i < 1000; i++) barrier();
+        outb_p(4, HD_CMD);
+        for (i = 0; i < 1000; i++) barrier();
+        outb_p(hd_info[0].ctl & 0x0f, HD_CMD);
+        for (i = 0; i < 1000; i++) barrier();
         if (drive_busy())
                 printk("hd: controller still busy\n");
         else if ((hd_error = inb(HD_ERROR)) != 1)
-                printk("hd: controller reset failed: %02x\n",hd_error);
+                printk("hd: controller reset failed: %02x\n", hd_error);
 }
 
 static void reset_hd(void)
@@ -371,8 +370,8 @@ repeat:
         if (++i < NR_HD) {
                 struct hd_i_struct *disk = &hd_info[i];
                 disk->special_op = disk->recalibrate = 1;
-                hd_out(disk,disk->sect,disk->sect,disk->head-1,
-                        disk->cyl,WIN_SPECIFY,&reset_hd);
+                hd_out(disk, disk->sect, disk->sect, disk->head-1,
+                        disk->cyl, WIN_SPECIFY, &reset_hd);
                 if (reset)
                         goto repeat;
         } else
@@ -393,7 +392,7 @@ static void unexpected_hd_interrupt(void)
         unsigned int stat = inb_p(HD_STATUS);
 
         if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {
-                dump_status ("unexpected interrupt", stat);
+                dump_status("unexpected interrupt", stat);
                 SET_TIMER;
         }
 }
@@ -453,7 +452,7 @@ static void read_intr(void)
         return;
 ok_to_read:
         req = CURRENT;
-        insw(HD_DATA,req->buffer,256);
+        insw(HD_DATA, req->buffer, 256);
         req->sector++;
         req->buffer += 512;
         req->errors = 0;
@@ -507,7 +506,7 @@ ok_to_write:
                 end_request(req, 1);
         if (i > 0) {
                 SET_HANDLER(&write_intr);
-                outsw(HD_DATA,req->buffer,256);
+                outsw(HD_DATA, req->buffer, 256);
                 local_irq_enable();
         } else {
 #if (HD_DELAY > 0)
@@ -560,11 +559,11 @@ static int do_special_op(struct hd_i_struct *disk, struct request *req)
 {
         if (disk->recalibrate) {
                 disk->recalibrate = 0;
-                hd_out(disk,disk->sect,0,0,0,WIN_RESTORE,&recal_intr);
+                hd_out(disk, disk->sect, 0, 0, 0, WIN_RESTORE, &recal_intr);
                 return reset;
         }
         if (disk->head > 16) {
-                printk ("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
+                printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
                 end_request(req, 0);
         }
         disk->special_op = 0;
@@ -633,19 +632,21 @@ repeat:
         if (blk_fs_request(req)) {
                 switch (rq_data_dir(req)) {
                 case READ:
-                        hd_out(disk,nsect,sec,head,cyl,WIN_READ,&read_intr);
+                        hd_out(disk, nsect, sec, head, cyl, WIN_READ,
+                                &read_intr);
                         if (reset)
                                 goto repeat;
                         break;
                 case WRITE:
-                        hd_out(disk,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
+                        hd_out(disk, nsect, sec, head, cyl, WIN_WRITE,
+                                &write_intr);
                         if (reset)
                                 goto repeat;
                         if (wait_DRQ()) {
                                 bad_rw_intr();
                                 goto repeat;
                         }
-                        outsw(HD_DATA,req->buffer,256);
+                        outsw(HD_DATA, req->buffer, 256);
                         break;
                 default:
                         printk("unknown hd-command\n");
@@ -655,7 +656,7 @@ repeat:
         }
 }
 
-static void do_hd_request (struct request_queue * q)
+static void do_hd_request(struct request_queue *q)
 {
         disable_irq(HD_IRQ);
         hd_request();
@@ -708,12 +709,12 @@ static int __init hd_init(void)
 {
         int drive;
 
-        if (register_blkdev(MAJOR_NR,"hd"))
+        if (register_blkdev(MAJOR_NR, "hd"))
                 return -1;
 
         hd_queue = blk_init_queue(do_hd_request, &hd_lock);
         if (!hd_queue) {
-                unregister_blkdev(MAJOR_NR,"hd");
+                unregister_blkdev(MAJOR_NR, "hd");
                 return -ENOMEM;
         }
 
@@ -742,7 +743,7 @@ static int __init hd_init(void)
                 goto out;
         }
 
-        for (drive=0 ; drive < NR_HD ; drive++) {
+        for (drive = 0 ; drive < NR_HD ; drive++) {
                 struct gendisk *disk = alloc_disk(64);
                 struct hd_i_struct *p = &hd_info[drive];
                 if (!disk)
@@ -756,7 +757,7 @@ static int __init hd_init(void)
                 disk->queue = hd_queue;
                 p->unit = drive;
                 hd_gendisk[drive] = disk;
-                printk ("%s: %luMB, CHS=%d/%d/%d\n",
+                printk("%s: %luMB, CHS=%d/%d/%d\n",
                         disk->disk_name, (unsigned long)get_capacity(disk)/2048,
                         p->cyl, p->head, p->sect);
         }
@@ -776,7 +777,7 @@ static int __init hd_init(void)
         }
 
         /* Let them fly */
-        for(drive=0; drive < NR_HD; drive++)
+        for (drive = 0; drive < NR_HD; drive++)
                 add_disk(hd_gendisk[drive]);
 
         return 0;
@@ -791,7 +792,7 @@ out1:
         NR_HD = 0;
 out:
         del_timer(&device_timer);
-        unregister_blkdev(MAJOR_NR,"hd");
+        unregister_blkdev(MAJOR_NR, "hd");
         blk_cleanup_queue(hd_queue);
         return -1;
 Enomem:
@@ -800,7 +801,8 @@ Enomem:
         goto out;
 }
 
-static int __init parse_hd_setup (char *line) {
+static int __init parse_hd_setup(char *line)
+{
         int ints[6];
 
         (void) get_options(line, ARRAY_SIZE(ints), ints);
diff --git a/drivers/ide/legacy/ht6560b.c b/drivers/ide/legacy/ht6560b.c
index 88fe9070c9c3..4fe516df9f74 100644
--- a/drivers/ide/legacy/ht6560b.c
+++ b/drivers/ide/legacy/ht6560b.c
@@ -35,6 +35,7 @@
  *  Try:  http://www.maf.iki.fi/~maf/ht6560b/
  */
 
+#define DRV_NAME        "ht6560b"
 #define HT6560B_VERSION "v0.08"
 
 #include <linux/module.h>
@@ -156,8 +157,8 @@ static void ht6560b_selectproc (ide_drive_t *drive)
                 /*
                  * Set timing for this drive:
                  */
-                outb(timing, hwif->io_ports[IDE_SELECT_OFFSET]);
-                (void)inb(hwif->io_ports[IDE_STATUS_OFFSET]);
+                outb(timing, hwif->io_ports.device_addr);
+                (void)inb(hwif->io_ports.status_addr);
 #ifdef DEBUG
                 printk("ht6560b: %s: select=%#x timing=%#x\n",
                         drive->name, select, timing);
@@ -211,8 +212,8 @@ static u8 ht_pio2timings(ide_drive_t *drive, const u8 pio)
 {
         int active_time, recovery_time;
         int active_cycles, recovery_cycles;
-        int bus_speed = system_bus_clock();
-        
+        int bus_speed = ide_vlb_clk ? ide_vlb_clk : system_bus_clock();
+
         if (pio) {
                 unsigned int cycle_time;
 
@@ -322,66 +323,44 @@ static void __init ht6560b_port_init_devs(ide_hwif_t *hwif)
         hwif->drives[1].drive_data = t;
 }
 
-int probe_ht6560b = 0;
+static int probe_ht6560b;
 
 module_param_named(probe, probe_ht6560b, bool, 0);
 MODULE_PARM_DESC(probe, "probe for HT6560B chipset");
 
+static const struct ide_port_ops ht6560b_port_ops = {
+        .port_init_devs         = ht6560b_port_init_devs,
+        .set_pio_mode           = ht6560b_set_pio_mode,
+        .selectproc             = ht6560b_selectproc,
+};
+
 static const struct ide_port_info ht6560b_port_info __initdata = {
+        .name                   = DRV_NAME,
         .chipset                = ide_ht6560b,
+        .port_ops               = &ht6560b_port_ops,
         .host_flags             = IDE_HFLAG_SERIALIZE | /* is this needed? */
                                   IDE_HFLAG_NO_DMA |
-                                  IDE_HFLAG_NO_AUTOTUNE |
                                   IDE_HFLAG_ABUSE_PREFETCH,
         .pio_mask               = ATA_PIO4,
 };
 
 static int __init ht6560b_init(void)
 {
-        ide_hwif_t *hwif, *mate;
-        static u8 idx[4] = { 0, 1, 0xff, 0xff };
-        hw_regs_t hw[2];
-
         if (probe_ht6560b == 0)
                 return -ENODEV;
 
-        hwif = &ide_hwifs[0];
-        mate = &ide_hwifs[1];
-
-        if (!request_region(HT_CONFIG_PORT, 1, hwif->name)) {
+        if (!request_region(HT_CONFIG_PORT, 1, DRV_NAME)) {
                 printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n",
-                        __FUNCTION__);
+                        __func__);
                 return -ENODEV;
         }
 
         if (!try_to_init_ht6560b()) {
-                printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__);
+                printk(KERN_NOTICE "%s: HBA not found\n", __func__);
                 goto release_region;
         }
 
-        memset(&hw, 0, sizeof(hw));
-
-        ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
-        hw[0].irq = 14;
-
-        ide_std_init_ports(&hw[1], 0x170, 0x376);
-        hw[1].irq = 15;
-
-        ide_init_port_hw(hwif, &hw[0]);
-        ide_init_port_hw(mate, &hw[1]);
-
-        hwif->selectproc = &ht6560b_selectproc;
-        hwif->set_pio_mode = &ht6560b_set_pio_mode;
-
-        mate->selectproc = &ht6560b_selectproc;
-        mate->set_pio_mode = &ht6560b_set_pio_mode;
-
-        hwif->port_init_devs = ht6560b_port_init_devs;
-        mate->port_init_devs = ht6560b_port_init_devs;
-
-        ide_device_add(idx, &ht6560b_port_info);
-
-        return 0;
+        return ide_legacy_device_add(&ht6560b_port_info, 0);
 
 release_region:
         release_region(HT_CONFIG_PORT, 1);
diff --git a/drivers/ide/legacy/ide-4drives.c b/drivers/ide/legacy/ide-4drives.c
index ecd7f3553554..ecae916a3385 100644
--- a/drivers/ide/legacy/ide-4drives.c
+++ b/drivers/ide/legacy/ide-4drives.c
@@ -4,7 +4,9 @@
 #include <linux/module.h>
 #include <linux/ide.h>
 
-int probe_4drives = 0;
+#define DRV_NAME "ide-4drives"
+
+static int probe_4drives;
 
 module_param_named(probe, probe_4drives, bool, 0);
 MODULE_PARM_DESC(probe, "probe for generic IDE chipset with 4 drives/port");
@@ -12,31 +14,51 @@ MODULE_PARM_DESC(probe, "probe for generic IDE chipset with 4 drives/port");
 static int __init ide_4drives_init(void)
 {
         ide_hwif_t *hwif, *mate;
-        u8 idx[4] = { 0, 1, 0xff, 0xff };
+        unsigned long base = 0x1f0, ctl = 0x3f6;
+        u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
         hw_regs_t hw;
 
         if (probe_4drives == 0)
                 return -ENODEV;
 
-        hwif = &ide_hwifs[0];
-        mate = &ide_hwifs[1];
+        if (!request_region(base, 8, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                DRV_NAME, base, base + 7);
+                return -EBUSY;
+        }
+
+        if (!request_region(ctl, 1, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                DRV_NAME, ctl);
+                release_region(base, 8);
+                return -EBUSY;
+        }
 
         memset(&hw, 0, sizeof(hw));
 
-        ide_std_init_ports(&hw, 0x1f0, 0x3f6);
+        ide_std_init_ports(&hw, base, ctl);
         hw.irq = 14;
         hw.chipset = ide_4drives;
 
-        ide_init_port_hw(hwif, &hw);
-        ide_init_port_hw(mate, &hw);
-
-        mate->drives[0].select.all ^= 0x20;
-        mate->drives[1].select.all ^= 0x20;
-
-        hwif->mate = mate;
-        mate->mate = hwif;
-
-        hwif->serialized = mate->serialized = 1;
+        hwif = ide_find_port();
+        if (hwif) {
+                ide_init_port_hw(hwif, &hw);
+                idx[0] = hwif->index;
+        }
+
+        mate = ide_find_port();
+        if (mate) {
+                ide_init_port_hw(mate, &hw);
+                mate->drives[0].select.all ^= 0x20;
+                mate->drives[1].select.all ^= 0x20;
+                idx[1] = mate->index;
+
+                if (hwif) {
+                        hwif->mate = mate;
+                        mate->mate = hwif;
+                        hwif->serialized = mate->serialized = 1;
+                }
+        }
 
         ide_device_add(idx, NULL);
 
diff --git a/drivers/ide/legacy/ide-cs.c b/drivers/ide/legacy/ide-cs.c
index 9a23b94f2939..aa2ea3deac85 100644
--- a/drivers/ide/legacy/ide-cs.c
+++ b/drivers/ide/legacy/ide-cs.c
@@ -51,6 +51,8 @@
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
 
+#define DRV_NAME "ide-cs"
+
 /*====================================================================*/
 
 /* Module parameters */
@@ -72,16 +74,11 @@ static char *version =
 
 /*====================================================================*/
 
-static const char ide_major[] = {
-    IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR,
-    IDE4_MAJOR, IDE5_MAJOR
-};
-
 typedef struct ide_info_t {
         struct pcmcia_device    *p_dev;
+        ide_hwif_t              *hwif;
     int         ndev;
     dev_node_t  node;
-    int         hd;
 } ide_info_t;
 
 static void ide_release(struct pcmcia_device *);
@@ -136,45 +133,71 @@ static int ide_probe(struct pcmcia_device *link)
 
 static void ide_detach(struct pcmcia_device *link)
 {
+    ide_info_t *info = link->priv;
+    ide_hwif_t *hwif = info->hwif;
+
     DEBUG(0, "ide_detach(0x%p)\n", link);
 
     ide_release(link);
 
-    kfree(link->priv);
+    release_region(hwif->io_ports.ctl_addr, 1);
+    release_region(hwif->io_ports.data_addr, 8);
+
+    kfree(info);
 } /* ide_detach */
 
-static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq, struct pcmcia_device *handle)
+static const struct ide_port_ops idecs_port_ops = {
+        .quirkproc              = ide_undecoded_slave,
+};
+
+static ide_hwif_t *idecs_register(unsigned long io, unsigned long ctl,
+                                unsigned long irq, struct pcmcia_device *handle)
 {
     ide_hwif_t *hwif;
     hw_regs_t hw;
     int i;
     u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
 
+    if (!request_region(io, 8, DRV_NAME)) {
+        printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                        DRV_NAME, io, io + 7);
+        return NULL;
+    }
+
+    if (!request_region(ctl, 1, DRV_NAME)) {
+        printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                        DRV_NAME, ctl);
+        release_region(io, 8);
+        return NULL;
+    }
+
     memset(&hw, 0, sizeof(hw));
     ide_std_init_ports(&hw, io, ctl);
     hw.irq = irq;
     hw.chipset = ide_pci;
     hw.dev = &handle->dev;
 
-    hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+    hwif = ide_find_port();
     if (hwif == NULL)
-        return -1;
+        goto out_release;
 
     i = hwif->index;
 
-    if (hwif->present)
-        ide_unregister(i);
-    else
-        ide_init_port_data(hwif, i);
-
+    ide_init_port_data(hwif, i);
     ide_init_port_hw(hwif, &hw);
-    hwif->quirkproc = &ide_undecoded_slave;
+    hwif->port_ops = &idecs_port_ops;
 
     idx[0] = i;
 
     ide_device_add(idx, NULL);
 
-    return hwif->present ? i : -1;
+    if (hwif->present)
+        return hwif;
+
+out_release:
+    release_region(ctl, 1);
+    release_region(io, 8);
+    return NULL;
 }
 
 /*======================================================================
@@ -199,8 +222,9 @@ static int ide_config(struct pcmcia_device *link)
         cistpl_cftable_entry_t dflt;
     } *stk = NULL;
     cistpl_cftable_entry_t *cfg;
-    int i, pass, last_ret = 0, last_fn = 0, hd, is_kme = 0;
+    int i, pass, last_ret = 0, last_fn = 0, is_kme = 0;
     unsigned long io_base, ctl_base;
+    ide_hwif_t *hwif;
 
     DEBUG(0, "ide_config(0x%p)\n", link);
 
@@ -296,14 +320,15 @@ static int ide_config(struct pcmcia_device *link)
         outb(0x81, ctl_base+1);
 
     /* retry registration in case device is still spinning up */
-    for (hd = -1, i = 0; i < 10; i++) {
-        hd = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
-        if (hd >= 0) break;
+    for (i = 0; i < 10; i++) {
+        hwif = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
+        if (hwif)
+            break;
         if (link->io.NumPorts1 == 0x20) {
             outb(0x02, ctl_base + 0x10);
-            hd = idecs_register(io_base + 0x10, ctl_base + 0x10,
-                                link->irq.AssignedIRQ, link);
-            if (hd >= 0) {
+            hwif = idecs_register(io_base + 0x10, ctl_base + 0x10,
+                                  link->irq.AssignedIRQ, link);
+            if (hwif) {
                 io_base += 0x10;
                 ctl_base += 0x10;
                 break;
@@ -312,7 +337,7 @@ static int ide_config(struct pcmcia_device *link)
         msleep(100);
     }
 
-    if (hd < 0) {
+    if (hwif == NULL) {
         printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx"
                ", irq %u failed\n", io_base, ctl_base,
                link->irq.AssignedIRQ);
@@ -320,10 +345,10 @@ static int ide_config(struct pcmcia_device *link)
     }
 
     info->ndev = 1;
-    sprintf(info->node.dev_name, "hd%c", 'a' + (hd * 2));
-    info->node.major = ide_major[hd];
+    sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
+    info->node.major = hwif->major;
     info->node.minor = 0;
-    info->hd = hd;
+    info->hwif = hwif;
     link->dev_node = &info->node;
     printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
            info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
@@ -354,13 +379,14 @@ failed:
 void ide_release(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
+    ide_hwif_t *hwif = info->hwif;
 
     DEBUG(0, "ide_release(0x%p)\n", link);
 
     if (info->ndev) {
         /* FIXME: if this fails we need to queue the cleanup somehow
            -- need to investigate the required PCMCIA magic */
-        ide_unregister(info->hd);
+        ide_unregister(hwif);
     }
     info->ndev = 0;
 
diff --git a/drivers/ide/legacy/ide_platform.c b/drivers/ide/legacy/ide_platform.c
index 361b1bb544bf..8279dc7ca4c0 100644
--- a/drivers/ide/legacy/ide_platform.c
+++ b/drivers/ide/legacy/ide_platform.c
@@ -30,14 +30,14 @@ static void __devinit plat_ide_setup_ports(hw_regs_t *hw,
         unsigned long port = (unsigned long)base;
         int i;
 
-        hw->io_ports[IDE_DATA_OFFSET] = port;
+        hw->io_ports.data_addr = port;
 
         port += (1 << pdata->ioport_shift);
-        for (i = IDE_ERROR_OFFSET; i <= IDE_STATUS_OFFSET;
+        for (i = 1; i <= 7;
              i++, port += (1 << pdata->ioport_shift))
-                hw->io_ports[i] = port;
+                hw->io_ports_array[i] = port;
 
-        hw->io_ports[IDE_CONTROL_OFFSET] = (unsigned long)ctrl;
+        hw->io_ports.ctl_addr = (unsigned long)ctrl;
 
         hw->irq = irq;
 
@@ -89,7 +89,7 @@ static int __devinit plat_ide_probe(struct platform_device *pdev)
                         res_alt->start, res_alt->end - res_alt->start + 1);
         }
 
-        hwif = ide_find_port((unsigned long)base);
+        hwif = ide_find_port();
         if (!hwif) {
                 ret = -ENODEV;
                 goto out;
@@ -101,10 +101,8 @@ static int __devinit plat_ide_probe(struct platform_device *pdev)
 
         ide_init_port_hw(hwif, &hw);
 
-        if (mmio) {
-                hwif->mmio = 1;
+        if (mmio)
                 default_hwif_mmiops(hwif);
-        }
 
         idx[0] = hwif->index;
 
@@ -122,7 +120,7 @@ static int __devexit plat_ide_remove(struct platform_device *pdev)
 {
         ide_hwif_t *hwif = pdev->dev.driver_data;
 
-        ide_unregister(hwif->index);
+        ide_unregister(hwif);
 
         return 0;
 }
diff --git a/drivers/ide/legacy/macide.c b/drivers/ide/legacy/macide.c
index eaf5dbe58bc2..1f527bbf8d96 100644
--- a/drivers/ide/legacy/macide.c
+++ b/drivers/ide/legacy/macide.c
@@ -72,9 +72,9 @@ static void __init macide_setup_ports(hw_regs_t *hw, unsigned long base,
         memset(hw, 0, sizeof(*hw));
 
         for (i = 0; i < 8; i++)
-                hw->io_ports[i] = base + i * 4;
+                hw->io_ports_array[i] = base + i * 4;
 
-        hw->io_ports[IDE_CONTROL_OFFSET] = base + IDE_CONTROL;
+        hw->io_ports.ctl_addr = base + IDE_CONTROL;
 
         hw->irq = irq;
         hw->ack_intr = ack_intr;
@@ -120,7 +120,7 @@ static int __init macide_init(void)
 
         macide_setup_ports(&hw, base, irq, ack_intr);
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif) {
                 u8 index = hwif->index;
                 u8 idx[4] = { index, 0xff, 0xff, 0xff };
@@ -128,8 +128,6 @@ static int __init macide_init(void)
                 ide_init_port_data(hwif, index);
                 ide_init_port_hw(hwif, &hw);
 
-                hwif->mmio = 1;
-
                 ide_device_add(idx, NULL);
         }
 
diff --git a/drivers/ide/legacy/q40ide.c b/drivers/ide/legacy/q40ide.c
index 2da28759686e..a3573d40b4b7 100644
--- a/drivers/ide/legacy/q40ide.c
+++ b/drivers/ide/legacy/q40ide.c
@@ -80,10 +80,10 @@ void q40_ide_setup_ports ( hw_regs_t *hw,
         for (i = 0; i < IDE_NR_PORTS; i++) {
                 /* BIG FAT WARNING: 
                    assumption: only DATA port is ever used in 16 bit mode */
-                if ( i==0 )
-                        hw->io_ports[i] = Q40_ISA_IO_W(base + offsets[i]);
+                if (i == 0)
+                        hw->io_ports_array[i] = Q40_ISA_IO_W(base + offsets[i]);
                 else
-                        hw->io_ports[i] = Q40_ISA_IO_B(base + offsets[i]);
+                        hw->io_ports_array[i] = Q40_ISA_IO_B(base + offsets[i]);
         }
 
         hw->irq = irq;
@@ -137,11 +137,10 @@ static int __init q40ide_init(void)
 //                      m68kide_iops,
                         q40ide_default_irq(pcide_bases[i]));
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif) {
                 ide_init_port_data(hwif, hwif->index);
                 ide_init_port_hw(hwif, &hw);
-                hwif->mmio = 1;
 
                 idx[i] = hwif->index;
         }
diff --git a/drivers/ide/legacy/qd65xx.c b/drivers/ide/legacy/qd65xx.c
index 7016bdf4fcc1..6424af154325 100644
--- a/drivers/ide/legacy/qd65xx.c
+++ b/drivers/ide/legacy/qd65xx.c
@@ -11,11 +11,7 @@
  *
  * QDI QD6500/QD6580 EIDE controller fast support
  *
- * Please set local bus speed using kernel parameter idebus
- *      for example, "idebus=33" stands for 33Mhz VLbus
  * To activate controller support, use "ide0=qd65xx"
- * To enable tuning, use "hda=autotune hdb=autotune"
- * To enable 2nd channel tuning (qd6580 only), use "hdc=autotune hdd=autotune"
  */
 
 /*
@@ -37,6 +33,8 @@
 #include <asm/system.h>
 #include <asm/io.h>
 
+#define DRV_NAME "qd65xx"
+
 #include "qd65xx.h"
 
 /*
@@ -88,12 +86,12 @@
 static int timings[4]={-1,-1,-1,-1}; /* stores current timing for each timer */
 
 /*
- * qd_select:
+ * qd65xx_select:
  *
- * This routine is invoked from ide.c to prepare for access to a given drive.
+ * This routine is invoked to prepare for access to a given drive.
  */
 
-static void qd_select (ide_drive_t *drive)
+static void qd65xx_select(ide_drive_t *drive)
 {
         u8 index = ((   (QD_TIMREG(drive)) & 0x80 ) >> 7) |
                         (QD_TIMREG(drive) & 0x02);
@@ -112,17 +110,18 @@ static void qd_select (ide_drive_t *drive)
 
 static u8 qd6500_compute_timing (ide_hwif_t *hwif, int active_time, int recovery_time)
 {
-        u8 active_cycle,recovery_cycle;
+        int clk = ide_vlb_clk ? ide_vlb_clk : system_bus_clock();
+        u8 act_cyc, rec_cyc;
 
-        if (system_bus_clock()<=33) {
-                active_cycle =   9  - IDE_IN(active_time   * system_bus_clock() / 1000 + 1, 2, 9);
-                recovery_cycle = 15 - IDE_IN(recovery_time * system_bus_clock() / 1000 + 1, 0, 15);
+        if (clk <= 33) {
+                act_cyc =  9 - IDE_IN(active_time   * clk / 1000 + 1, 2,  9);
+                rec_cyc = 15 - IDE_IN(recovery_time * clk / 1000 + 1, 0, 15);
         } else {
-                active_cycle =   8  - IDE_IN(active_time   * system_bus_clock() / 1000 + 1, 1, 8);
-                recovery_cycle = 18 - IDE_IN(recovery_time * system_bus_clock() / 1000 + 1, 3, 18);
+                act_cyc =  8 - IDE_IN(active_time   * clk / 1000 + 1, 1,  8);
+                rec_cyc = 18 - IDE_IN(recovery_time * clk / 1000 + 1, 3, 18);
         }
 
-        return((recovery_cycle<<4) | 0x08 | active_cycle);
+        return (rec_cyc << 4) | 0x08 | act_cyc;
 }
 
 /*
@@ -133,10 +132,13 @@ static u8 qd6500_compute_timing (ide_hwif_t *hwif, int active_time, int recovery
 
 static u8 qd6580_compute_timing (int active_time, int recovery_time)
 {
-        u8 active_cycle   = 17 - IDE_IN(active_time   * system_bus_clock() / 1000 + 1, 2, 17);
-        u8 recovery_cycle = 15 - IDE_IN(recovery_time * system_bus_clock() / 1000 + 1, 2, 15);
+        int clk = ide_vlb_clk ? ide_vlb_clk : system_bus_clock();
+        u8 act_cyc, rec_cyc;
+
+        act_cyc = 17 - IDE_IN(active_time   * clk / 1000 + 1, 2, 17);
+        rec_cyc = 15 - IDE_IN(recovery_time * clk / 1000 + 1, 2, 15);
 
-        return((recovery_cycle<<4) | active_cycle);
+        return (rec_cyc << 4) | act_cyc;
 }
 
 /*
@@ -168,36 +170,15 @@ static int qd_find_disk_type (ide_drive_t *drive,
 }
 
 /*
- * qd_timing_ok:
- *
- * check whether timings don't conflict
- */
-
-static int qd_timing_ok (ide_drive_t drives[])
-{
-        return (IDE_IMPLY(drives[0].present && drives[1].present,
-                        IDE_IMPLY(QD_TIMREG(drives) == QD_TIMREG(drives+1),
-                                  QD_TIMING(drives) == QD_TIMING(drives+1))));
-        /* if same timing register, must be same timing */
-}
-
-/*
  * qd_set_timing:
  *
- * records the timing, and enables selectproc as needed
+ * records the timing
  */
 
 static void qd_set_timing (ide_drive_t *drive, u8 timing)
 {
-        ide_hwif_t *hwif = HWIF(drive);
-
         drive->drive_data &= 0xff00;
         drive->drive_data |= timing;
-        if (qd_timing_ok(hwif->drives)) {
-                qd_select(drive); /* selects once */
-                hwif->selectproc = NULL;
-        } else
-                hwif->selectproc = &qd_select;
 
         printk(KERN_DEBUG "%s: %#x\n", drive->name, timing);
 }
@@ -225,10 +206,11 @@ static void qd6500_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void qd6580_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        int base = HWIF(drive)->select_data;
+        ide_hwif_t *hwif = drive->hwif;
         unsigned int cycle_time;
         int active_time   = 175;
         int recovery_time = 415; /* worst case values from the dos driver */
+        u8 base = (hwif->config_data & 0xff00) >> 8;
 
         if (drive->id && !qd_find_disk_type(drive, &active_time, &recovery_time)) {
                 cycle_time = ide_pio_cycle_time(drive, pio);
@@ -299,21 +281,10 @@ static int __init qd_testreg(int port)
         return (readreg != QD_TESTVAL);
 }
 
-/*
- * qd_setup:
- *
- * called to setup an ata channel : adjusts attributes & links for tuning
- */
-
-static void __init qd_setup(ide_hwif_t *hwif, int base, int config)
-{
-        hwif->select_data = base;
-        hwif->config_data = config;
-}
-
 static void __init qd6500_port_init_devs(ide_hwif_t *hwif)
 {
-        u8 base = hwif->select_data, config = QD_CONFIG(hwif);
+        u8 base = (hwif->config_data & 0xff00) >> 8;
+        u8 config = QD_CONFIG(hwif);
 
         hwif->drives[0].drive_data = QD6500_DEF_DATA;
         hwif->drives[1].drive_data = QD6500_DEF_DATA;
@@ -322,9 +293,10 @@ static void __init qd6500_port_init_devs(ide_hwif_t *hwif)
 static void __init qd6580_port_init_devs(ide_hwif_t *hwif)
 {
         u16 t1, t2;
-        u8 base = hwif->select_data, config = QD_CONFIG(hwif);
+        u8 base = (hwif->config_data & 0xff00) >> 8;
+        u8 config = QD_CONFIG(hwif);
 
-        if (QD_CONTROL(hwif) & QD_CONTR_SEC_DISABLED) {
+        if (hwif->host_flags & IDE_HFLAG_SINGLE) {
                 t1 = QD6580_DEF_DATA;
                 t2 = QD6580_DEF_DATA2;
         } else
@@ -334,11 +306,23 @@ static void __init qd6580_port_init_devs(ide_hwif_t *hwif)
         hwif->drives[1].drive_data = t2;
 }
 
+static const struct ide_port_ops qd6500_port_ops = {
+        .port_init_devs         = qd6500_port_init_devs,
+        .set_pio_mode           = qd6500_set_pio_mode,
+        .selectproc             = qd65xx_select,
+};
+
+static const struct ide_port_ops qd6580_port_ops = {
+        .port_init_devs         = qd6580_port_init_devs,
+        .set_pio_mode           = qd6580_set_pio_mode,
+        .selectproc             = qd65xx_select,
+};
+
 static const struct ide_port_info qd65xx_port_info __initdata = {
+        .name                   = DRV_NAME,
         .chipset                = ide_qd65xx,
         .host_flags             = IDE_HFLAG_IO_32BIT |
-                                  IDE_HFLAG_NO_DMA |
-                                  IDE_HFLAG_NO_AUTOTUNE,
+                                  IDE_HFLAG_NO_DMA,
         .pio_mask               = ATA_PIO4,
 };
 
@@ -351,65 +335,41 @@ static const struct ide_port_info qd65xx_port_info __initdata = {
 
 static int __init qd_probe(int base)
 {
-        ide_hwif_t *hwif;
-        u8 config, unit;
-        u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
-        hw_regs_t hw[2];
+        int rc;
+        u8 config, unit, control;
+        struct ide_port_info d = qd65xx_port_info;
 
         config = inb(QD_CONFIG_PORT);
 
         if (! ((config & QD_CONFIG_BASEPORT) >> 1 == (base == 0xb0)) )
-                return 1;
+                return -ENODEV;
 
         unit = ! (config & QD_CONFIG_IDE_BASEPORT);
 
-        memset(&hw, 0, sizeof(hw));
+        if (unit)
+                d.host_flags |= IDE_HFLAG_QD_2ND_PORT;
 
-        ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
-        hw[0].irq = 14;
+        switch (config & 0xf0) {
+        case QD_CONFIG_QD6500:
+                if (qd_testreg(base))
+                         return -ENODEV;        /* bad register */
 
-        ide_std_init_ports(&hw[1], 0x170, 0x376);
-        hw[1].irq = 15;
-
-        if ((config & 0xf0) == QD_CONFIG_QD6500) {
-
-                if (qd_testreg(base)) return 1;         /* bad register */
-
-                /* qd6500 found */
-
-                hwif = &ide_hwifs[unit];
-                printk(KERN_NOTICE "%s: qd6500 at %#x\n", hwif->name, base);
-                printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n",
-                        config, QD_ID3);
-                
                 if (config & QD_CONFIG_DISABLED) {
                         printk(KERN_WARNING "qd6500 is disabled !\n");
-                        return 1;
+                        return -ENODEV;
                 }
 
-                ide_init_port_hw(hwif, &hw[unit]);
-
-                qd_setup(hwif, base, config);
-
-                hwif->port_init_devs = qd6500_port_init_devs;
-                hwif->set_pio_mode = &qd6500_set_pio_mode;
-
-                idx[unit] = unit;
-
-                ide_device_add(idx, &qd65xx_port_info);
-
-                return 1;
-        }
-
-        if (((config & 0xf0) == QD_CONFIG_QD6580_A) ||
-            ((config & 0xf0) == QD_CONFIG_QD6580_B)) {
-
-                u8 control;
-
-                if (qd_testreg(base) || qd_testreg(base+0x02)) return 1;
-                        /* bad registers */
+                printk(KERN_NOTICE "qd6500 at %#x\n", base);
+                printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n",
+                        config, QD_ID3);
 
-                /* qd6580 found */
+                d.port_ops = &qd6500_port_ops;
+                d.host_flags |= IDE_HFLAG_SINGLE;
+                break;
+        case QD_CONFIG_QD6580_A:
+        case QD_CONFIG_QD6580_B:
+                if (qd_testreg(base) || qd_testreg(base + 0x02))
+                        return -ENODEV; /* bad registers */
 
                 control = inb(QD_CONTROL_PORT);
 
@@ -419,74 +379,44 @@ static int __init qd_probe(int base)
 
                 outb(QD_DEF_CONTR, QD_CONTROL_PORT);
 
-                if (control & QD_CONTR_SEC_DISABLED) {
-                        /* secondary disabled */
-
-                        hwif = &ide_hwifs[unit];
-                        printk(KERN_INFO "%s: qd6580: single IDE board\n",
-                                         hwif->name);
-
-                        ide_init_port_hw(hwif, &hw[unit]);
-
-                        qd_setup(hwif, base, config | (control << 8));
-
-                        hwif->port_init_devs = qd6580_port_init_devs;
-                        hwif->set_pio_mode = &qd6580_set_pio_mode;
-
-                        idx[unit] = unit;
+                d.port_ops = &qd6580_port_ops;
+                if (control & QD_CONTR_SEC_DISABLED)
+                        d.host_flags |= IDE_HFLAG_SINGLE;
 
-                        ide_device_add(idx, &qd65xx_port_info);
-
-                        return 1;
-                } else {
-                        ide_hwif_t *mate;
-
-                        hwif = &ide_hwifs[0];
-                        mate = &ide_hwifs[1];
-                        /* secondary enabled */
-                        printk(KERN_INFO "%s&%s: qd6580: dual IDE board\n",
-                                        hwif->name, mate->name);
-
-                        ide_init_port_hw(hwif, &hw[0]);
-                        ide_init_port_hw(mate, &hw[1]);
-
-                        qd_setup(hwif, base, config | (control << 8));
-
-                        hwif->port_init_devs = qd6580_port_init_devs;
-                        hwif->set_pio_mode = &qd6580_set_pio_mode;
-
-                        qd_setup(mate, base, config | (control << 8));
-
-                        mate->port_init_devs = qd6580_port_init_devs;
-                        mate->set_pio_mode = &qd6580_set_pio_mode;
+                printk(KERN_INFO "qd6580: %s IDE board\n",
+                        (control & QD_CONTR_SEC_DISABLED) ? "single" : "dual");
+                break;
+        default:
+                return -ENODEV;
+        }
 
-                        idx[0] = 0;
-                        idx[1] = 1;
+        rc = ide_legacy_device_add(&d, (base << 8) | config);
 
-                        ide_device_add(idx, &qd65xx_port_info);
+        if (d.host_flags & IDE_HFLAG_SINGLE)
+                return (rc == 0) ? 1 : rc;
 
-                        return 0; /* no other qd65xx possible */
-                }
-        }
-        /* no qd65xx found */
-        return 1;
+        return rc;
 }
 
-int probe_qd65xx = 0;
+static int probe_qd65xx;
 
 module_param_named(probe, probe_qd65xx, bool, 0);
 MODULE_PARM_DESC(probe, "probe for QD65xx chipsets");
 
 static int __init qd65xx_init(void)
 {
+        int rc1, rc2 = -ENODEV;
+
         if (probe_qd65xx == 0)
                 return -ENODEV;
 
-        if (qd_probe(0x30))
-                qd_probe(0xb0);
-        if (ide_hwifs[0].chipset != ide_qd65xx &&
-            ide_hwifs[1].chipset != ide_qd65xx)
+        rc1 = qd_probe(0x30);
+        if (rc1)
+                rc2 = qd_probe(0xb0);
+
+        if (rc1 < 0 && rc2 < 0)
                 return -ENODEV;
+
         return 0;
 }
 
diff --git a/drivers/ide/legacy/qd65xx.h b/drivers/ide/legacy/qd65xx.h
index 28dd50a15d55..c83dea85e621 100644
--- a/drivers/ide/legacy/qd65xx.h
+++ b/drivers/ide/legacy/qd65xx.h
@@ -30,7 +30,6 @@
 #define QD_ID3                  ((config & QD_CONFIG_ID3)!=0)
 
 #define QD_CONFIG(hwif)         ((hwif)->config_data & 0x00ff)
-#define QD_CONTROL(hwif)        (((hwif)->config_data & 0xff00) >> 8)
 
 #define QD_TIMING(drive)        (byte)(((drive)->drive_data) & 0x00ff)
 #define QD_TIMREG(drive)        (byte)((((drive)->drive_data) & 0xff00) >> 8)
diff --git a/drivers/ide/legacy/umc8672.c b/drivers/ide/legacy/umc8672.c
index bc1944811b99..b54a14a57755 100644
--- a/drivers/ide/legacy/umc8672.c
+++ b/drivers/ide/legacy/umc8672.c
@@ -19,7 +19,7 @@
  */
 
 /*
- * VLB Controller Support from 
+ * VLB Controller Support from
  * Wolfram Podien
  * Rohoefe 3
  * D28832 Achim
@@ -32,7 +32,7 @@
  * #define UMC_DRIVE0 11
  * in the beginning of the driver, which sets the speed of drive 0 to 11 (there
  * are some lines present). 0 - 11 are allowed speed values. These values are
- * the results from the DOS speed test program supplied from UMC. 11 is the 
+ * the results from the DOS speed test program supplied from UMC. 11 is the
  * highest speed (about PIO mode 3)
  */
 #define REALLY_SLOW_IO          /* some systems can safely undef this */
@@ -51,6 +51,8 @@
 
 #include <asm/io.h>
 
+#define DRV_NAME "umc8672"
+
 /*
  * Default speeds.  These can be changed with "auto-tune" and/or hdparm.
  */
@@ -60,115 +62,103 @@
 #define UMC_DRIVE3      1              /* In case of crash reduce speed */
 
 static u8 current_speeds[4] = {UMC_DRIVE0, UMC_DRIVE1, UMC_DRIVE2, UMC_DRIVE3};
-static const u8 pio_to_umc [5] = {0,3,7,10,11}; /* rough guesses */
+static const u8 pio_to_umc [5] = {0, 3, 7, 10, 11};     /* rough guesses */
 
 /*       0    1    2    3    4    5    6    7    8    9    10   11      */
 static const u8 speedtab [3][12] = {
-        {0xf, 0xb, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1 },
-        {0x3, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1 },
-        {0xff,0xcb,0xc0,0x58,0x36,0x33,0x23,0x22,0x21,0x11,0x10,0x0}};
+        {0x0f, 0x0b, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x1},
+        {0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x1},
+        {0xff, 0xcb, 0xc0, 0x58, 0x36, 0x33, 0x23, 0x22, 0x21, 0x11, 0x10, 0x0}
+};
 
-static void out_umc (char port,char wert)
+static void out_umc(char port, char wert)
 {
-        outb_p(port,0x108);
-        outb_p(wert,0x109);
+        outb_p(port, 0x108);
+        outb_p(wert, 0x109);
 }
 
-static inline u8 in_umc (char port)
+static inline u8 in_umc(char port)
 {
-        outb_p(port,0x108);
+        outb_p(port, 0x108);
         return inb_p(0x109);
 }
 
-static void umc_set_speeds (u8 speeds[])
+static void umc_set_speeds(u8 speeds[])
 {
         int i, tmp;
 
-        outb_p(0x5A,0x108); /* enable umc */
+        outb_p(0x5A, 0x108); /* enable umc */
 
-        out_umc (0xd7,(speedtab[0][speeds[2]] | (speedtab[0][speeds[3]]<<4)));
-        out_umc (0xd6,(speedtab[0][speeds[0]] | (speedtab[0][speeds[1]]<<4)));
+        out_umc(0xd7, (speedtab[0][speeds[2]] | (speedtab[0][speeds[3]]<<4)));
+        out_umc(0xd6, (speedtab[0][speeds[0]] | (speedtab[0][speeds[1]]<<4)));
         tmp = 0;
-        for (i = 3; i >= 0; i--) {
+        for (i = 3; i >= 0; i--)
                 tmp = (tmp << 2) | speedtab[1][speeds[i]];
+        out_umc(0xdc, tmp);
+        for (i = 0; i < 4; i++) {
+                out_umc(0xd0 + i, speedtab[2][speeds[i]]);
+                out_umc(0xd8 + i, speedtab[2][speeds[i]]);
         }
-        out_umc (0xdc,tmp);
-        for (i = 0;i < 4; i++) {
-                out_umc (0xd0+i,speedtab[2][speeds[i]]);
-                out_umc (0xd8+i,speedtab[2][speeds[i]]);
-        }
-        outb_p(0xa5,0x108); /* disable umc */
+        outb_p(0xa5, 0x108); /* disable umc */
 
-        printk ("umc8672: drive speeds [0 to 11]: %d %d %d %d\n",
+        printk("umc8672: drive speeds [0 to 11]: %d %d %d %d\n",
                 speeds[0], speeds[1], speeds[2], speeds[3]);
 }
 
 static void umc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long flags;
-        ide_hwgroup_t *hwgroup = ide_hwifs[HWIF(drive)->index^1].hwgroup;
 
         printk("%s: setting umc8672 to PIO mode%d (speed %d)\n",
                 drive->name, pio, pio_to_umc[pio]);
         spin_lock_irqsave(&ide_lock, flags);
-        if (hwgroup && hwgroup->handler != NULL) {
+        if (hwif->mate && hwif->mate->hwgroup->handler) {
                 printk(KERN_ERR "umc8672: other interface is busy: exiting tune_umc()\n");
         } else {
                 current_speeds[drive->name[2] - 'a'] = pio_to_umc[pio];
-                umc_set_speeds (current_speeds);
+                umc_set_speeds(current_speeds);
         }
         spin_unlock_irqrestore(&ide_lock, flags);
 }
 
+static const struct ide_port_ops umc8672_port_ops = {
+        .set_pio_mode           = umc_set_pio_mode,
+};
+
 static const struct ide_port_info umc8672_port_info __initdata = {
+        .name                   = DRV_NAME,
         .chipset                = ide_umc8672,
-        .host_flags             = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE,
+        .port_ops               = &umc8672_port_ops,
+        .host_flags             = IDE_HFLAG_NO_DMA,
         .pio_mask               = ATA_PIO4,
 };
 
 static int __init umc8672_probe(void)
 {
         unsigned long flags;
-        static u8 idx[4] = { 0, 1, 0xff, 0xff };
-        hw_regs_t hw[2];
 
         if (!request_region(0x108, 2, "umc8672")) {
                 printk(KERN_ERR "umc8672: ports 0x108-0x109 already in use.\n");
                 return 1;
         }
         local_irq_save(flags);
-        outb_p(0x5A,0x108); /* enable umc */
+        outb_p(0x5A, 0x108); /* enable umc */
         if (in_umc (0xd5) != 0xa0) {
                 local_irq_restore(flags);
                 printk(KERN_ERR "umc8672: not found\n");
                 release_region(0x108, 2);
-                return 1;  
+                return 1;
         }
-        outb_p(0xa5,0x108); /* disable umc */
+        outb_p(0xa5, 0x108); /* disable umc */
 
-        umc_set_speeds (current_speeds);
+        umc_set_speeds(current_speeds);
         local_irq_restore(flags);
 
-        memset(&hw, 0, sizeof(hw));
-
-        ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
-        hw[0].irq = 14;
-
-        ide_std_init_ports(&hw[1], 0x170, 0x376);
-        hw[1].irq = 15;
-
-        ide_init_port_hw(&ide_hwifs[0], &hw[0]);
-        ide_init_port_hw(&ide_hwifs[1], &hw[1]);
-
-        ide_hwifs[0].set_pio_mode = &umc_set_pio_mode;
-        ide_hwifs[1].set_pio_mode = &umc_set_pio_mode;
-
-        ide_device_add(idx, &umc8672_port_info);
-
-        return 0;
+        return ide_legacy_device_add(&umc8672_port_info, 0);
 }
 
-int probe_umc8672 = 0;
+static int probe_umc8672;
 
 module_param_named(probe, probe_umc8672, bool, 0);
 MODULE_PARM_DESC(probe, "probe for UMC8672 chipset");
diff --git a/drivers/ide/mips/au1xxx-ide.c b/drivers/ide/mips/au1xxx-ide.c
index 9b628248f2f4..296b9c674bae 100644
--- a/drivers/ide/mips/au1xxx-ide.c
+++ b/drivers/ide/mips/au1xxx-ide.c
@@ -47,7 +47,6 @@
 #define IDE_AU1XXX_BURSTMODE    1
 
 static _auide_hwif auide_hwif;
-static int dbdma_init_done;
 
 static int auide_ddma_init(_auide_hwif *auide);
 
@@ -61,7 +60,7 @@ void auide_insw(unsigned long port, void *addr, u32 count)
 
         if(!put_dest_flags(ahwif->rx_chan, (void*)addr, count << 1, 
                            DDMA_FLAGS_NOIE)) {
-                printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
+                printk(KERN_ERR "%s failed %d\n", __func__, __LINE__);
                 return;
         }
         ctp = *((chan_tab_t **)ahwif->rx_chan);
@@ -79,7 +78,7 @@ void auide_outsw(unsigned long port, void *addr, u32 count)
 
         if(!put_source_flags(ahwif->tx_chan, (void*)addr,
                              count << 1, DDMA_FLAGS_NOIE)) {
-                printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
+                printk(KERN_ERR "%s failed %d\n", __func__, __LINE__);
                 return;
         }
         ctp = *((chan_tab_t **)ahwif->tx_chan);
@@ -250,7 +249,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
                                                      (void*) sg_virt(sg),
                                                      tc, flags)) { 
                                         printk(KERN_ERR "%s failed %d\n", 
-                                               __FUNCTION__, __LINE__);
+                                               __func__, __LINE__);
                                 }
                         } else 
                         {
@@ -258,7 +257,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
                                                    (void*) sg_virt(sg),
                                                    tc, flags)) { 
                                         printk(KERN_ERR "%s failed %d\n", 
-                                               __FUNCTION__, __LINE__);
+                                               __func__, __LINE__);
                                 }
                         }
 
@@ -315,35 +314,6 @@ static int auide_dma_setup(ide_drive_t *drive)
         return 0;
 }
 
-static u8 auide_mdma_filter(ide_drive_t *drive)
-{
-        /*
-         * FIXME: ->white_list and ->black_list are based on completely bogus
-         * ->ide_dma_check implementation which didn't set neither the host
-         * controller timings nor the device for the desired transfer mode.
-         *
-         * They should be either removed or 0x00 MWDMA mask should be
-         * returned for devices on the ->black_list.
-         */
-
-        if (dbdma_init_done == 0) {
-                auide_hwif.white_list = ide_in_drive_list(drive->id,
-                                                          dma_white_list);
-                auide_hwif.black_list = ide_in_drive_list(drive->id,
-                                                          dma_black_list);
-                auide_hwif.drive = drive;
-                auide_ddma_init(&auide_hwif);
-                dbdma_init_done = 1;
-        }
-
-        /* Is the drive in our DMA black list? */
-        if (auide_hwif.black_list)
-                printk(KERN_WARNING "%s: Disabling DMA for %s (blacklisted)\n",
-                                    drive->name, drive->id->model);
-
-        return drive->hwif->mwdma_mask;
-}
-
 static int auide_dma_test_irq(ide_drive_t *drive)
 {       
         if (drive->waiting_for_dma == 0)
@@ -396,41 +366,41 @@ static void auide_init_dbdma_dev(dbdev_tab_t *dev, u32 dev_id, u32 tsize, u32 de
         dev->dev_devwidth    = devwidth;
         dev->dev_flags       = flags;
 }
-  
-#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
 
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
 static void auide_dma_timeout(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
 
         printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name);
 
-        if (hwif->ide_dma_test_irq(drive))
+        if (auide_dma_test_irq(drive))
                 return;
 
-        hwif->ide_dma_end(drive);
+        auide_dma_end(drive);
 }
-                                        
 
-static int auide_ddma_init(_auide_hwif *auide) {
-        
+static const struct ide_dma_ops au1xxx_dma_ops = {
+        .dma_host_set           = auide_dma_host_set,
+        .dma_setup              = auide_dma_setup,
+        .dma_exec_cmd           = auide_dma_exec_cmd,
+        .dma_start              = auide_dma_start,
+        .dma_end                = auide_dma_end,
+        .dma_test_irq           = auide_dma_test_irq,
+        .dma_lost_irq           = auide_dma_lost_irq,
+        .dma_timeout            = auide_dma_timeout,
+};
+
+static int auide_ddma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
+{
+        _auide_hwif *auide = (_auide_hwif *)hwif->hwif_data;
         dbdev_tab_t source_dev_tab, target_dev_tab;
         u32 dev_id, tsize, devwidth, flags;
-        ide_hwif_t *hwif = auide->hwif;
 
         dev_id   = AU1XXX_ATA_DDMA_REQ;
 
-        if (auide->white_list || auide->black_list) {
-                tsize    = 8;
-                devwidth = 32;
-        }
-        else { 
-                tsize    = 1;
-                devwidth = 16;
-                
-                printk(KERN_ERR "au1xxx-ide: %s is not on ide driver whitelist.\n",auide_hwif.drive->id->model);
-                printk(KERN_ERR "            please read 'Documentation/mips/AU1xxx_IDE.README'");
-        }
+        tsize    =  8; /*  1 */
+        devwidth = 32; /* 16 */
 
 #ifdef IDE_AU1XXX_BURSTMODE 
         flags = DEV_FLAGS_SYNC | DEV_FLAGS_BURSTABLE;
@@ -482,9 +452,9 @@ static int auide_ddma_init(_auide_hwif *auide) {
         return 0;
 } 
 #else
- 
-static int auide_ddma_init( _auide_hwif *auide )
+static int auide_ddma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
+        _auide_hwif *auide = (_auide_hwif *)hwif->hwif_data;
         dbdev_tab_t source_dev_tab;
         int flags;
 
@@ -532,20 +502,28 @@ static int auide_ddma_init( _auide_hwif *auide )
 static void auide_setup_ports(hw_regs_t *hw, _auide_hwif *ahwif)
 {
         int i;
-        unsigned long *ata_regs = hw->io_ports;
+        unsigned long *ata_regs = hw->io_ports_array;
 
         /* FIXME? */
-        for (i = 0; i < IDE_CONTROL_OFFSET; i++) {
+        for (i = 0; i < 8; i++)
                 *ata_regs++ = ahwif->regbase + (i << AU1XXX_ATA_REG_OFFSET);
-        }
 
         /* set the Alternative Status register */
         *ata_regs = ahwif->regbase + (14 << AU1XXX_ATA_REG_OFFSET);
 }
 
+static const struct ide_port_ops au1xxx_port_ops = {
+        .set_pio_mode           = au1xxx_set_pio_mode,
+        .set_dma_mode           = auide_set_dma_mode,
+};
+
 static const struct ide_port_info au1xxx_port_info = {
+        .init_dma               = auide_ddma_init,
+        .port_ops               = &au1xxx_port_ops,
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        .dma_ops                = &au1xxx_dma_ops,
+#endif
         .host_flags             = IDE_HFLAG_POST_SET_MODE |
-                                  IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
                                   IDE_HFLAG_NO_IO_32BIT |
                                   IDE_HFLAG_UNMASK_IRQS,
         .pio_mask               = ATA_PIO4,
@@ -599,9 +577,11 @@ static int au_ide_probe(struct device *dev)
                 goto out;
         }
 
-        /* FIXME:  This might possibly break PCMCIA IDE devices */
-
-        hwif                            = &ide_hwifs[pdev->id];
+        hwif = ide_find_port();
+        if (hwif == NULL) {
+                ret = -ENOENT;
+                goto out;
+        }
 
         memset(&hw, 0, sizeof(hw));
         auide_setup_ports(&hw, ahwif);
@@ -613,8 +593,6 @@ static int au_ide_probe(struct device *dev)
 
         hwif->dev = dev;
 
-        hwif->mmio  = 1;
-
         /* If the user has selected DDMA assisted copies,
            then set up a few local I/O function entry points 
         */
@@ -623,34 +601,12 @@ static int au_ide_probe(struct device *dev)
         hwif->INSW                      = auide_insw;
         hwif->OUTSW                     = auide_outsw;
 #endif
-
-        hwif->set_pio_mode              = &au1xxx_set_pio_mode;
-        hwif->set_dma_mode              = &auide_set_dma_mode;
-
-#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
-        hwif->dma_timeout               = &auide_dma_timeout;
-
-        hwif->mdma_filter               = &auide_mdma_filter;
-
-        hwif->dma_host_set              = &auide_dma_host_set;
-        hwif->dma_exec_cmd              = &auide_dma_exec_cmd;
-        hwif->dma_start                 = &auide_dma_start;
-        hwif->ide_dma_end               = &auide_dma_end;
-        hwif->dma_setup                 = &auide_dma_setup;
-        hwif->ide_dma_test_irq          = &auide_dma_test_irq;
-        hwif->dma_lost_irq              = &auide_dma_lost_irq;
-#endif
         hwif->select_data               = 0;    /* no chipset-specific code */
         hwif->config_data               = 0;    /* no chipset-specific code */
 
         auide_hwif.hwif                 = hwif;
         hwif->hwif_data                 = &auide_hwif;
 
-#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA           
-        auide_ddma_init(&auide_hwif);
-        dbdma_init_done = 1;
-#endif
-
         idx[0] = hwif->index;
 
         ide_device_add(idx, &au1xxx_port_info);
@@ -670,7 +626,7 @@ static int au_ide_remove(struct device *dev)
         ide_hwif_t *hwif = dev_get_drvdata(dev);
         _auide_hwif *ahwif = &auide_hwif;
 
-        ide_unregister(hwif->index);
+        ide_unregister(hwif);
 
         iounmap((void *)ahwif->regbase);
 
diff --git a/drivers/ide/mips/swarm.c b/drivers/ide/mips/swarm.c
index 956259fc09ba..68947626e4aa 100644
--- a/drivers/ide/mips/swarm.c
+++ b/drivers/ide/mips/swarm.c
@@ -76,17 +76,12 @@ static int __devinit swarm_ide_probe(struct device *dev)
         if (!SIBYTE_HAVE_IDE)
                 return -ENODEV;
 
-        /* Find an empty slot.  */
-        for (i = 0; i < MAX_HWIFS; i++)
-                if (!ide_hwifs[i].io_ports[IDE_DATA_OFFSET])
-                        break;
-        if (i >= MAX_HWIFS) {
+        hwif = ide_find_port();
+        if (hwif == NULL) {
                 printk(KERN_ERR DRV_NAME ": no free slot for interface\n");
                 return -ENOMEM;
         }
 
-        hwif = ide_hwifs + i;
-
         base = ioremap(A_IO_EXT_BASE, 0x800);
         offset = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_START_ADDR, IDE_CS));
         size = __raw_readq(base + R_IO_EXT_REG(R_IO_EXT_MULT_SIZE, IDE_CS));
@@ -115,15 +110,13 @@ static int __devinit swarm_ide_probe(struct device *dev)
 
         /* Setup MMIO ops.  */
         default_hwif_mmiops(hwif);
-        /* Prevent resource map manipulation.  */
-        hwif->mmio = 1;
+
         hwif->chipset = ide_generic;
-        hwif->noprobe = 0;
 
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
-                hwif->io_ports[i] =
+        for (i = 0; i <= 7; i++)
+                hwif->io_ports_array[i] =
                                 (unsigned long)(base + ((0x1f0 + i) << 5));
-        hwif->io_ports[IDE_CONTROL_OFFSET] =
+        hwif->io_ports.ctl_addr =
                                 (unsigned long)(base + (0x3f6 << 5));
         hwif->irq = K_INT_GB_IDE;
 
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index cfb3265bc1a8..7f46c224b7c4 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -135,12 +135,12 @@ static void aec6260_set_mode(ide_drive_t *drive, const u8 speed)
 
 static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        drive->hwif->set_dma_mode(drive, pio + XFER_PIO_0);
+        drive->hwif->port_ops->set_dma_mode(drive, pio + XFER_PIO_0);
 }
 
 static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const char *name)
 {
-        int bus_speed = system_bus_clock();
+        int bus_speed = ide_pci_clk ? ide_pci_clk : system_bus_clock();
 
         if (bus_speed <= 33)
                 pci_set_drvdata(dev, (void *) aec6xxx_33_base);
@@ -175,27 +175,23 @@ static u8 __devinit atp86x_cable_detect(ide_hwif_t *hwif)
         return (ata66 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
 }
 
-static void __devinit init_hwif_aec62xx(ide_hwif_t *hwif)
-{
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-
-        hwif->set_pio_mode = &aec_set_pio_mode;
-
-        if (dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF)
-                hwif->set_dma_mode = &aec6210_set_mode;
-        else {
-                hwif->set_dma_mode = &aec6260_set_mode;
+static const struct ide_port_ops atp850_port_ops = {
+        .set_pio_mode           = aec_set_pio_mode,
+        .set_dma_mode           = aec6210_set_mode,
+};
 
-                hwif->cable_detect = atp86x_cable_detect;
-        }
-}
+static const struct ide_port_ops atp86x_port_ops = {
+        .set_pio_mode           = aec_set_pio_mode,
+        .set_dma_mode           = aec6260_set_mode,
+        .cable_detect           = atp86x_cable_detect,
+};
 
 static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "AEC6210",
                 .init_chipset   = init_chipset_aec62xx,
-                .init_hwif      = init_hwif_aec62xx,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
+                .port_ops       = &atp850_port_ops,
                 .host_flags     = IDE_HFLAG_SERIALIZE |
                                   IDE_HFLAG_NO_ATAPI_DMA |
                                   IDE_HFLAG_NO_DSC |
@@ -207,7 +203,7 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
         },{     /* 1 */
                 .name           = "AEC6260",
                 .init_chipset   = init_chipset_aec62xx,
-                .init_hwif      = init_hwif_aec62xx,
+                .port_ops       = &atp86x_port_ops,
                 .host_flags     = IDE_HFLAG_NO_ATAPI_DMA | IDE_HFLAG_NO_AUTODMA |
                                   IDE_HFLAG_ABUSE_SET_DMA_MODE |
                                   IDE_HFLAG_OFF_BOARD,
@@ -217,17 +213,18 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
         },{     /* 2 */
                 .name           = "AEC6260R",
                 .init_chipset   = init_chipset_aec62xx,
-                .init_hwif      = init_hwif_aec62xx,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
+                .port_ops       = &atp86x_port_ops,
                 .host_flags     = IDE_HFLAG_NO_ATAPI_DMA |
-                                  IDE_HFLAG_ABUSE_SET_DMA_MODE,
+                                  IDE_HFLAG_ABUSE_SET_DMA_MODE |
+                                  IDE_HFLAG_NON_BOOTABLE,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA4,
         },{     /* 3 */
                 .name           = "AEC6280",
                 .init_chipset   = init_chipset_aec62xx,
-                .init_hwif      = init_hwif_aec62xx,
+                .port_ops       = &atp86x_port_ops,
                 .host_flags     = IDE_HFLAG_NO_ATAPI_DMA |
                                   IDE_HFLAG_ABUSE_SET_DMA_MODE |
                                   IDE_HFLAG_OFF_BOARD,
@@ -237,8 +234,8 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
         },{     /* 4 */
                 .name           = "AEC6280R",
                 .init_chipset   = init_chipset_aec62xx,
-                .init_hwif      = init_hwif_aec62xx,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
+                .port_ops       = &atp86x_port_ops,
                 .host_flags     = IDE_HFLAG_NO_ATAPI_DMA |
                                   IDE_HFLAG_ABUSE_SET_DMA_MODE |
                                   IDE_HFLAG_OFF_BOARD,
diff --git a/drivers/ide/pci/alim15x3.c b/drivers/ide/pci/alim15x3.c
index b3b6f514ce2d..b36a22b8c213 100644
--- a/drivers/ide/pci/alim15x3.c
+++ b/drivers/ide/pci/alim15x3.c
@@ -38,8 +38,6 @@
 
 #include <asm/io.h>
 
-#define DISPLAY_ALI_TIMINGS
-
 /*
  *      ALi devices are not plug in. Otherwise these static values would
  *      need to go. They ought to go away anyway
@@ -49,236 +47,6 @@ static u8 m5229_revision;
 static u8 chip_is_1543c_e;
 static struct pci_dev *isa_dev;
 
-#if defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS)
-#include <linux/stat.h>
-#include <linux/proc_fs.h>
-
-static u8 ali_proc = 0;
-
-static struct pci_dev *bmide_dev;
-
-static char *fifo[4] = {
-        "FIFO Off",
-        "FIFO On ",
-        "DMA mode",
-        "PIO mode" };
-
-static char *udmaT[8] = {
-        "1.5T",
-        "  2T",
-        "2.5T",
-        "  3T",
-        "3.5T",
-        "  4T",
-        "  6T",
-        "  8T"
-};
-
-static char *channel_status[8] = {
-        "OK            ",
-        "busy          ",
-        "DRQ           ",
-        "DRQ busy      ",
-        "error         ",
-        "error busy    ",
-        "error DRQ     ",
-        "error DRQ busy"
-};
-
-/**
- *      ali_get_info            -       generate proc file for ALi IDE
- *      @buffer: buffer to fill
- *      @addr: address of user start in buffer
- *      @offset: offset into 'file'
- *      @count: buffer count
- *
- *      Walks the Ali devices and outputs summary data on the tuning and
- *      anything else that will help with debugging
- */
- 
-static int ali_get_info (char *buffer, char **addr, off_t offset, int count)
-{
-        unsigned long bibma;
-        u8 reg53h, reg5xh, reg5yh, reg5xh1, reg5yh1, c0, c1, rev, tmp;
-        char *q, *p = buffer;
-
-        /* fetch rev. */
-        pci_read_config_byte(bmide_dev, 0x08, &rev);
-        if (rev >= 0xc1)        /* M1543C or newer */
-                udmaT[7] = " ???";
-        else
-                fifo[3]  = "   ???  ";
-
-        /* first fetch bibma: */
-        
-        bibma = pci_resource_start(bmide_dev, 4);
-
-        /*
-         * at that point bibma+0x2 et bibma+0xa are byte
-         * registers to investigate:
-         */
-        c0 = inb(bibma + 0x02);
-        c1 = inb(bibma + 0x0a);
-
-        p += sprintf(p,
-                "\n                                Ali M15x3 Chipset.\n");
-        p += sprintf(p,
-                "                                ------------------\n");
-        pci_read_config_byte(bmide_dev, 0x78, &reg53h);
-        p += sprintf(p, "PCI Clock: %d.\n", reg53h);
-
-        pci_read_config_byte(bmide_dev, 0x53, &reg53h);
-        p += sprintf(p,
-                "CD_ROM FIFO:%s, CD_ROM DMA:%s\n",
-                (reg53h & 0x02) ? "Yes" : "No ",
-                (reg53h & 0x01) ? "Yes" : "No " );
-        pci_read_config_byte(bmide_dev, 0x74, &reg53h);
-        p += sprintf(p,
-                "FIFO Status: contains %d Words, runs%s%s\n\n",
-                (reg53h & 0x3f),
-                (reg53h & 0x40) ? " OVERWR" : "",
-                (reg53h & 0x80) ? " OVERRD." : "." );
-
-        p += sprintf(p,
-                "-------------------primary channel"
-                "-------------------secondary channel"
-                "---------\n\n");
-
-        pci_read_config_byte(bmide_dev, 0x09, &reg53h);
-        p += sprintf(p,
-                "channel status:       %s"
-                "                               %s\n",
-                (reg53h & 0x20) ? "On " : "Off",
-                (reg53h & 0x10) ? "On " : "Off" );
-
-        p += sprintf(p,
-                "both channels togth:  %s"
-                "                               %s\n",
-                (c0&0x80) ? "No " : "Yes",
-                (c1&0x80) ? "No " : "Yes" );
-
-        pci_read_config_byte(bmide_dev, 0x76, &reg53h);
-        p += sprintf(p,
-                "Channel state:        %s                    %s\n",
-                channel_status[reg53h & 0x07],
-                channel_status[(reg53h & 0x70) >> 4] );
-
-        pci_read_config_byte(bmide_dev, 0x58, &reg5xh);
-        pci_read_config_byte(bmide_dev, 0x5c, &reg5yh);
-        p += sprintf(p,
-                "Add. Setup Timing:    %dT"
-                "                                %dT\n",
-                (reg5xh & 0x07) ? (reg5xh & 0x07) : 8,
-                (reg5yh & 0x07) ? (reg5yh & 0x07) : 8 );
-
-        pci_read_config_byte(bmide_dev, 0x59, &reg5xh);
-        pci_read_config_byte(bmide_dev, 0x5d, &reg5yh);
-        p += sprintf(p,
-                "Command Act. Count:   %dT"
-                "                                %dT\n"
-                "Command Rec. Count:   %dT"
-                "                               %dT\n\n",
-                (reg5xh & 0x70) ? ((reg5xh & 0x70) >> 4) : 8,
-                (reg5yh & 0x70) ? ((reg5yh & 0x70) >> 4) : 8, 
-                (reg5xh & 0x0f) ? (reg5xh & 0x0f) : 16,
-                (reg5yh & 0x0f) ? (reg5yh & 0x0f) : 16 );
-
-        p += sprintf(p,
-                "----------------drive0-----------drive1"
-                "------------drive0-----------drive1------\n\n");
-        p += sprintf(p,
-                "DMA enabled:      %s              %s"
-                "               %s              %s\n",
-                (c0&0x20) ? "Yes" : "No ",
-                (c0&0x40) ? "Yes" : "No ",
-                (c1&0x20) ? "Yes" : "No ",
-                (c1&0x40) ? "Yes" : "No " );
-
-        pci_read_config_byte(bmide_dev, 0x54, &reg5xh);
-        pci_read_config_byte(bmide_dev, 0x55, &reg5yh);
-        q = "FIFO threshold:   %2d Words         %2d Words"
-                "          %2d Words         %2d Words\n";
-        if (rev < 0xc1) {
-                if ((rev == 0x20) &&
-                    (pci_read_config_byte(bmide_dev, 0x4f, &tmp), (tmp &= 0x20))) {
-                        p += sprintf(p, q, 8, 8, 8, 8);
-                } else {
-                        p += sprintf(p, q,
-                                (reg5xh & 0x03) + 12,
-                                ((reg5xh & 0x30)>>4) + 12,
-                                (reg5yh & 0x03) + 12,
-                                ((reg5yh & 0x30)>>4) + 12 );
-                }
-        } else {
-                int t1 = (tmp = (reg5xh & 0x03)) ? (tmp << 3) : 4;
-                int t2 = (tmp = ((reg5xh & 0x30)>>4)) ? (tmp << 3) : 4;
-                int t3 = (tmp = (reg5yh & 0x03)) ? (tmp << 3) : 4;
-                int t4 = (tmp = ((reg5yh & 0x30)>>4)) ? (tmp << 3) : 4;
-                p += sprintf(p, q, t1, t2, t3, t4);
-        }
-
-#if 0
-        p += sprintf(p, 
-                "FIFO threshold:   %2d Words         %2d Words"
-                "          %2d Words         %2d Words\n",
-                (reg5xh & 0x03) + 12,
-                ((reg5xh & 0x30)>>4) + 12,
-                (reg5yh & 0x03) + 12,
-                ((reg5yh & 0x30)>>4) + 12 );
-#endif
-
-        p += sprintf(p,
-                "FIFO mode:        %s         %s          %s         %s\n",
-                fifo[((reg5xh & 0x0c) >> 2)],
-                fifo[((reg5xh & 0xc0) >> 6)],
-                fifo[((reg5yh & 0x0c) >> 2)],
-                fifo[((reg5yh & 0xc0) >> 6)] );
-
-        pci_read_config_byte(bmide_dev, 0x5a, &reg5xh);
-        pci_read_config_byte(bmide_dev, 0x5b, &reg5xh1);
-        pci_read_config_byte(bmide_dev, 0x5e, &reg5yh);
-        pci_read_config_byte(bmide_dev, 0x5f, &reg5yh1);
-
-        p += sprintf(p,/*
-                "------------------drive0-----------drive1"
-                "------------drive0-----------drive1------\n")*/
-                "Dt RW act. Cnt    %2dT              %2dT"
-                "               %2dT              %2dT\n"
-                "Dt RW rec. Cnt    %2dT              %2dT"
-                "               %2dT              %2dT\n\n",
-                (reg5xh & 0x70) ? ((reg5xh & 0x70) >> 4) : 8,
-                (reg5xh1 & 0x70) ? ((reg5xh1 & 0x70) >> 4) : 8,
-                (reg5yh & 0x70) ? ((reg5yh & 0x70) >> 4) : 8,
-                (reg5yh1 & 0x70) ? ((reg5yh1 & 0x70) >> 4) : 8,
-                (reg5xh & 0x0f) ? (reg5xh & 0x0f) : 16,
-                (reg5xh1 & 0x0f) ? (reg5xh1 & 0x0f) : 16,
-                (reg5yh & 0x0f) ? (reg5yh & 0x0f) : 16,
-                (reg5yh1 & 0x0f) ? (reg5yh1 & 0x0f) : 16 );
-
-        p += sprintf(p,
-                "-----------------------------------UDMA Timings"
-                "--------------------------------\n\n");
-
-        pci_read_config_byte(bmide_dev, 0x56, &reg5xh);
-        pci_read_config_byte(bmide_dev, 0x57, &reg5yh);
-        p += sprintf(p,
-                "UDMA:             %s               %s"
-                "                %s               %s\n"
-                "UDMA timings:     %s             %s"
-                "              %s             %s\n\n",
-                (reg5xh & 0x08) ? "OK" : "No",
-                (reg5xh & 0x80) ? "OK" : "No",
-                (reg5yh & 0x08) ? "OK" : "No",
-                (reg5yh & 0x80) ? "OK" : "No",
-                udmaT[(reg5xh & 0x07)],
-                udmaT[(reg5xh & 0x70) >> 4],
-                udmaT[reg5yh & 0x07],
-                udmaT[(reg5yh & 0x70) >> 4] );
-
-        return p-buffer; /* => must be less than 4k! */
-}
-#endif  /* defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS) */
-
 /**
  *      ali_set_pio_mode        -       set host controller for PIO mode
  *      @drive: drive
@@ -294,7 +62,7 @@ static void ali_set_pio_mode(ide_drive_t *drive, const u8 pio)
         int s_time, a_time, c_time;
         u8 s_clc, a_clc, r_clc;
         unsigned long flags;
-        int bus_speed = system_bus_clock();
+        int bus_speed = ide_pci_clk ? ide_pci_clk : system_bus_clock();
         int port = hwif->channel ? 0x5c : 0x58;
         int portFIFO = hwif->channel ? 0x55 : 0x54;
         u8 cd_dma_fifo = 0;
@@ -465,14 +233,6 @@ static unsigned int __devinit init_chipset_ali15x3 (struct pci_dev *dev, const c
 
         isa_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
 
-#if defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS)
-        if (!ali_proc) {
-                ali_proc = 1;
-                bmide_dev = dev;
-                ide_pci_create_host_proc("ali", ali_get_info);
-        }
-#endif  /* defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS) */
-
         local_irq_save(flags);
 
         if (m5229_revision < 0xC2) {
@@ -610,7 +370,7 @@ static int ali_cable_override(struct pci_dev *pdev)
 }
 
 /**
- *      ata66_ali15x3   -       check for UDMA 66 support
+ *      ali_cable_detect        -       cable detection
  *      @hwif: IDE interface
  *
  *      This checks if the controller and the cable are capable
@@ -620,7 +380,7 @@ static int ali_cable_override(struct pci_dev *pdev)
  *      FIXME: frobs bits that are not defined on newer ALi devicea
  */
 
-static u8 __devinit ata66_ali15x3(ide_hwif_t *hwif)
+static u8 __devinit ali_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         unsigned long flags;
@@ -652,27 +412,7 @@ static u8 __devinit ata66_ali15x3(ide_hwif_t *hwif)
         return cbl;
 }
 
-/**
- *      init_hwif_common_ali15x3        -       Set up ALI IDE hardware
- *      @hwif: IDE interface
- *
- *      Initialize the IDE structure side of the ALi 15x3 driver.
- */
- 
-static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &ali_set_pio_mode;
-        hwif->set_dma_mode = &ali_set_dma_mode;
-        hwif->udma_filter = &ali_udma_filter;
-
-        hwif->cable_detect = ata66_ali15x3;
-
-        if (hwif->dma_base == 0)
-                return;
-
-        hwif->dma_setup = &ali15x3_dma_setup;
-}
-
+#ifndef CONFIG_SPARC64
 /**
  *      init_hwif_ali15x3       -       Initialize the ALI IDE x86 stuff
  *      @hwif: interface to configure
@@ -722,35 +462,66 @@ static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
                 if(irq >= 0)
                         hwif->irq = irq;
         }
-
-        init_hwif_common_ali15x3(hwif);
 }
+#endif
 
 /**
  *      init_dma_ali15x3        -       set up DMA on ALi15x3
  *      @hwif: IDE interface
- *      @dmabase: DMA interface base PCI address
+ *      @d: IDE port info
  *
- *      Set up the DMA functionality on the ALi 15x3. For the ALi
- *      controllers this is generic so we can let the generic code do
- *      the actual work.
+ *      Set up the DMA functionality on the ALi 15x3.
  */
 
-static void __devinit init_dma_ali15x3 (ide_hwif_t *hwif, unsigned long dmabase)
+static int __devinit init_dma_ali15x3(ide_hwif_t *hwif,
+                                      const struct ide_port_info *d)
 {
-        if (m5229_revision < 0x20)
-                return;
+        struct pci_dev *dev = to_pci_dev(hwif->dev);
+        unsigned long base = ide_pci_dma_base(hwif, d);
+
+        if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
+                return -1;
+
         if (!hwif->channel)
-                outb(inb(dmabase + 2) & 0x60, dmabase + 2);
-        ide_setup_dma(hwif, dmabase);
+                outb(inb(base + 2) & 0x60, base + 2);
+
+        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx\n",
+                         hwif->name, base, base + 7);
+
+        if (ide_allocate_dma_engine(hwif))
+                return -1;
+
+        ide_setup_dma(hwif, base);
+
+        return 0;
 }
 
+static const struct ide_port_ops ali_port_ops = {
+        .set_pio_mode           = ali_set_pio_mode,
+        .set_dma_mode           = ali_set_dma_mode,
+        .udma_filter            = ali_udma_filter,
+        .cable_detect           = ali_cable_detect,
+};
+
+static const struct ide_dma_ops ali_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ali15x3_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 static const struct ide_port_info ali15x3_chipset __devinitdata = {
         .name           = "ALI15X3",
         .init_chipset   = init_chipset_ali15x3,
+#ifndef CONFIG_SPARC64
         .init_hwif      = init_hwif_ali15x3,
+#endif
         .init_dma       = init_dma_ali15x3,
-        .host_flags     = IDE_HFLAG_BOOTABLE,
+        .port_ops       = &ali_port_ops,
         .pio_mask       = ATA_PIO5,
         .swdma_mask     = ATA_SWDMA2,
         .mwdma_mask     = ATA_MWDMA2,
@@ -793,14 +564,17 @@ static int __devinit alim15x3_init_one(struct pci_dev *dev, const struct pci_dev
                         d.udma_mask = ATA_UDMA5;
                 else
                         d.udma_mask = ATA_UDMA6;
+
+                d.dma_ops = &ali_dma_ops;
+        } else {
+                d.host_flags |= IDE_HFLAG_NO_DMA;
+
+                d.mwdma_mask = d.swdma_mask = 0;
         }
 
         if (idx == 0)
                 d.host_flags |= IDE_HFLAG_CLEAR_SIMPLEX;
 
-#if defined(CONFIG_SPARC64)
-        d.init_hwif = init_hwif_common_ali15x3;
-#endif /* CONFIG_SPARC64 */
         return ide_setup_pci_device(dev, &d);
 }
 
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 2ef890ce8097..efcf54338be7 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -179,7 +179,7 @@ static unsigned int __devinit init_chipset_amd74xx(struct pci_dev *dev,
  * Determine the system bus clock.
  */
 
-        amd_clock = system_bus_clock() * 1000;
+        amd_clock = (ide_pci_clk ? ide_pci_clk : system_bus_clock()) * 1000;
 
         switch (amd_clock) {
                 case 33000: amd_clock = 33333; break;
@@ -210,21 +210,20 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
 
         if (hwif->irq == 0) /* 0 is bogus but will do for now */
                 hwif->irq = pci_get_legacy_ide_irq(dev, hwif->channel);
-
-        hwif->set_pio_mode = &amd_set_pio_mode;
-        hwif->set_dma_mode = &amd_set_drive;
-
-        hwif->cable_detect = amd_cable_detect;
 }
 
+static const struct ide_port_ops amd_port_ops = {
+        .set_pio_mode           = amd_set_pio_mode,
+        .set_dma_mode           = amd_set_drive,
+        .cable_detect           = amd_cable_detect,
+};
+
 #define IDE_HFLAGS_AMD \
         (IDE_HFLAG_PIO_NO_BLACKLIST | \
-         IDE_HFLAG_PIO_NO_DOWNGRADE | \
          IDE_HFLAG_ABUSE_SET_DMA_MODE | \
          IDE_HFLAG_POST_SET_MODE | \
          IDE_HFLAG_IO_32BIT | \
-         IDE_HFLAG_UNMASK_IRQS | \
-         IDE_HFLAG_BOOTABLE)
+         IDE_HFLAG_UNMASK_IRQS)
 
 #define DECLARE_AMD_DEV(name_str, swdma, udma)                          \
         {                                                               \
@@ -232,6 +231,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .init_chipset   = init_chipset_amd74xx,                 \
                 .init_hwif      = init_hwif_amd74xx,                    \
                 .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \
+                .port_ops       = &amd_port_ops,                        \
                 .host_flags     = IDE_HFLAGS_AMD,                       \
                 .pio_mask       = ATA_PIO5,                             \
                 .swdma_mask     = swdma,                                \
@@ -245,6 +245,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .init_chipset   = init_chipset_amd74xx,                 \
                 .init_hwif      = init_hwif_amd74xx,                    \
                 .enablebits     = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \
+                .port_ops       = &amd_port_ops,                        \
                 .host_flags     = IDE_HFLAGS_AMD,                       \
                 .pio_mask       = ATA_PIO5,                             \
                 .swdma_mask     = ATA_SWDMA2,                           \
diff --git a/drivers/ide/pci/atiixp.c b/drivers/ide/pci/atiixp.c
index 7e037c880cb0..8b637181681a 100644
--- a/drivers/ide/pci/atiixp.c
+++ b/drivers/ide/pci/atiixp.c
@@ -130,37 +130,26 @@ static u8 __devinit atiixp_cable_detect(ide_hwif_t *hwif)
                 return ATA_CBL_PATA40;
 }
 
-/**
- *      init_hwif_atiixp                -       fill in the hwif for the ATIIXP
- *      @hwif: IDE interface
- *
- *      Set up the ide_hwif_t for the ATIIXP interface according to the
- *      capabilities of the hardware.
- */
-
-static void __devinit init_hwif_atiixp(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &atiixp_set_pio_mode;
-        hwif->set_dma_mode = &atiixp_set_dma_mode;
-
-        hwif->cable_detect = atiixp_cable_detect;
-}
+static const struct ide_port_ops atiixp_port_ops = {
+        .set_pio_mode           = atiixp_set_pio_mode,
+        .set_dma_mode           = atiixp_set_dma_mode,
+        .cable_detect           = atiixp_cable_detect,
+};
 
 static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
         {       /* 0 */
                 .name           = "ATIIXP",
-                .init_hwif      = init_hwif_atiixp,
                 .enablebits     = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
-                .host_flags     = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_BOOTABLE,
+                .port_ops       = &atiixp_port_ops,
+                .host_flags     = IDE_HFLAG_LEGACY_IRQS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA5,
         },{     /* 1 */
                 .name           = "SB600_PATA",
-                .init_hwif      = init_hwif_atiixp,
                 .enablebits     = {{0x48,0x01,0x00}, {0x00,0x00,0x00}},
-                .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS |
-                                  IDE_HFLAG_BOOTABLE,
+                .port_ops       = &atiixp_port_ops,
+                .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA5,
diff --git a/drivers/ide/pci/cmd640.c b/drivers/ide/pci/cmd640.c
index a1cfe033a55f..aaf38109eaec 100644
--- a/drivers/ide/pci/cmd640.c
+++ b/drivers/ide/pci/cmd640.c
@@ -4,7 +4,7 @@
 
 /*
  *  Original authors:   abramov@cecmow.enet.dec.com (Igor Abramov)
- *                      mlord@pobox.com (Mark Lord)
+ *                      mlord@pobox.com (Mark Lord)
  *
  *  See linux/MAINTAINERS for address of current maintainer.
  *
@@ -98,7 +98,7 @@
 
 #define CMD640_PREFETCH_MASKS 1
 
-//#define CMD640_DUMP_REGS
+/*#define CMD640_DUMP_REGS */
 
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -109,10 +109,9 @@
 
 #include <asm/io.h>
 
-/*
- * This flag is set in ide.c by the parameter:  ide0=cmd640_vlb
- */
-int cmd640_vlb = 0;
+#define DRV_NAME "cmd640"
+
+static int cmd640_vlb;
 
 /*
  * CMD640 specific registers definition.
@@ -185,7 +184,6 @@ static DEFINE_SPINLOCK(cmd640_lock);
  * These are initialized to point at the devices we control
  */
 static ide_hwif_t  *cmd_hwif0, *cmd_hwif1;
-static ide_drive_t *cmd_drives[4];
 
 /*
  * Interface to access cmd640x registers
@@ -207,13 +205,13 @@ static unsigned int cmd640_chip_version;
 
 /* PCI method 1 access */
 
-static void put_cmd640_reg_pci1 (u16 reg, u8 val)
+static void put_cmd640_reg_pci1(u16 reg, u8 val)
 {
         outl_p((reg & 0xfc) | cmd640_key, 0xcf8);
         outb_p(val, (reg & 3) | 0xcfc);
 }
 
-static u8 get_cmd640_reg_pci1 (u16 reg)
+static u8 get_cmd640_reg_pci1(u16 reg)
 {
         outl_p((reg & 0xfc) | cmd640_key, 0xcf8);
         return inb_p((reg & 3) | 0xcfc);
@@ -221,14 +219,14 @@ static u8 get_cmd640_reg_pci1 (u16 reg)
 
 /* PCI method 2 access (from CMD datasheet) */
 
-static void put_cmd640_reg_pci2 (u16 reg, u8 val)
+static void put_cmd640_reg_pci2(u16 reg, u8 val)
 {
         outb_p(0x10, 0xcf8);
         outb_p(val, cmd640_key + reg);
         outb_p(0, 0xcf8);
 }
 
-static u8 get_cmd640_reg_pci2 (u16 reg)
+static u8 get_cmd640_reg_pci2(u16 reg)
 {
         u8 b;
 
@@ -240,13 +238,13 @@ static u8 get_cmd640_reg_pci2 (u16 reg)
 
 /* VLB access */
 
-static void put_cmd640_reg_vlb (u16 reg, u8 val)
+static void put_cmd640_reg_vlb(u16 reg, u8 val)
 {
         outb_p(reg, cmd640_key);
         outb_p(val, cmd640_key + 4);
 }
 
-static u8 get_cmd640_reg_vlb (u16 reg)
+static u8 get_cmd640_reg_vlb(u16 reg)
 {
         outb_p(reg, cmd640_key);
         return inb_p(cmd640_key + 4);
@@ -268,11 +266,11 @@ static void put_cmd640_reg(u16 reg, u8 val)
         unsigned long flags;
 
         spin_lock_irqsave(&cmd640_lock, flags);
-        __put_cmd640_reg(reg,val);
+        __put_cmd640_reg(reg, val);
         spin_unlock_irqrestore(&cmd640_lock, flags);
 }
 
-static int __init match_pci_cmd640_device (void)
+static int __init match_pci_cmd640_device(void)
 {
         const u8 ven_dev[4] = {0x95, 0x10, 0x40, 0x06};
         unsigned int i;
@@ -292,7 +290,7 @@ static int __init match_pci_cmd640_device (void)
 /*
  * Probe for CMD640x -- pci method 1
  */
-static int __init probe_for_cmd640_pci1 (void)
+static int __init probe_for_cmd640_pci1(void)
 {
         __get_cmd640_reg = get_cmd640_reg_pci1;
         __put_cmd640_reg = put_cmd640_reg_pci1;
@@ -308,7 +306,7 @@ static int __init probe_for_cmd640_pci1 (void)
 /*
  * Probe for CMD640x -- pci method 2
  */
-static int __init probe_for_cmd640_pci2 (void)
+static int __init probe_for_cmd640_pci2(void)
 {
         __get_cmd640_reg = get_cmd640_reg_pci2;
         __put_cmd640_reg = put_cmd640_reg_pci2;
@@ -322,7 +320,7 @@ static int __init probe_for_cmd640_pci2 (void)
 /*
  * Probe for CMD640x -- vlb
  */
-static int __init probe_for_cmd640_vlb (void)
+static int __init probe_for_cmd640_vlb(void)
 {
         u8 b;
 
@@ -343,18 +341,18 @@ static int __init probe_for_cmd640_vlb (void)
  *  Returns 1 if an IDE interface/drive exists at 0x170,
  *  Returns 0 otherwise.
  */
-static int __init secondary_port_responding (void)
+static int __init secondary_port_responding(void)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&cmd640_lock, flags);
 
-        outb_p(0x0a, 0x170 + IDE_SELECT_OFFSET);        /* select drive0 */
+        outb_p(0x0a, 0x176);    /* select drive0 */
         udelay(100);
-        if ((inb_p(0x170 + IDE_SELECT_OFFSET) & 0x1f) != 0x0a) {
-                outb_p(0x1a, 0x170 + IDE_SELECT_OFFSET); /* select drive1 */
+        if ((inb_p(0x176) & 0x1f) != 0x0a) {
+                outb_p(0x1a, 0x176); /* select drive1 */
                 udelay(100);
-                if ((inb_p(0x170 + IDE_SELECT_OFFSET) & 0x1f) != 0x1a) {
+                if ((inb_p(0x176) & 0x1f) != 0x1a) {
                         spin_unlock_irqrestore(&cmd640_lock, flags);
                         return 0; /* nothing responded */
                 }
@@ -367,7 +365,7 @@ static int __init secondary_port_responding (void)
 /*
  * Dump out all cmd640 registers.  May be called from ide.c
  */
-static void cmd640_dump_regs (void)
+static void cmd640_dump_regs(void)
 {
         unsigned int reg = cmd640_vlb ? 0x50 : 0x00;
 
@@ -382,13 +380,13 @@ static void cmd640_dump_regs (void)
 }
 #endif
 
+#ifndef CONFIG_BLK_DEV_CMD640_ENHANCED
 /*
  * Check whether prefetch is on for a drive,
  * and initialize the unmask flags for safe operation.
  */
-static void __init check_prefetch (unsigned int index)
+static void __init check_prefetch(ide_drive_t *drive, unsigned int index)
 {
-        ide_drive_t *drive = cmd_drives[index];
         u8 b = get_cmd640_reg(prefetch_regs[index]);
 
         if (b & prefetch_masks[index]) {        /* is prefetch off? */
@@ -403,29 +401,12 @@ static void __init check_prefetch (unsigned int index)
                 drive->no_io_32bit = 0;
         }
 }
-
-/*
- * Figure out which devices we control
- */
-static void __init setup_device_ptrs (void)
-{
-        cmd_hwif0 = &ide_hwifs[0];
-        cmd_hwif1 = &ide_hwifs[1];
-
-        cmd_drives[0] = &cmd_hwif0->drives[0];
-        cmd_drives[1] = &cmd_hwif0->drives[1];
-        cmd_drives[2] = &cmd_hwif1->drives[0];
-        cmd_drives[3] = &cmd_hwif1->drives[1];
-}
-
-#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
-
+#else
 /*
  * Sets prefetch mode for a drive.
  */
-static void set_prefetch_mode (unsigned int index, int mode)
+static void set_prefetch_mode(ide_drive_t *drive, unsigned int index, int mode)
 {
-        ide_drive_t *drive = cmd_drives[index];
         unsigned long flags;
         int reg = prefetch_regs[index];
         u8 b;
@@ -452,7 +433,7 @@ static void set_prefetch_mode (unsigned int index, int mode)
 /*
  * Dump out current drive clocks settings
  */
-static void display_clocks (unsigned int index)
+static void display_clocks(unsigned int index)
 {
         u8 active_count, recovery_count;
 
@@ -471,44 +452,16 @@ static void display_clocks (unsigned int index)
  * Pack active and recovery counts into single byte representation
  * used by controller
  */
-static inline u8 pack_nibbles (u8 upper, u8 lower)
+static inline u8 pack_nibbles(u8 upper, u8 lower)
 {
         return ((upper & 0x0f) << 4) | (lower & 0x0f);
 }
 
 /*
- * This routine retrieves the initial drive timings from the chipset.
- */
-static void __init retrieve_drive_counts (unsigned int index)
-{
-        u8 b;
-
-        /*
-         * Get the internal setup timing, and convert to clock count
-         */
-        b = get_cmd640_reg(arttim_regs[index]) & ~0x3f;
-        switch (b) {
-                case 0x00: b = 4; break;
-                case 0x80: b = 3; break;
-                case 0x40: b = 2; break;
-                default:   b = 5; break;
-        }
-        setup_counts[index] = b;
-
-        /*
-         * Get the active/recovery counts
-         */
-        b = get_cmd640_reg(drwtim_regs[index]);
-        active_counts[index]   = (b >> 4)   ? (b >> 4)   : 0x10;
-        recovery_counts[index] = (b & 0x0f) ? (b & 0x0f) : 0x10;
-}
-
-
-/*
  * This routine writes the prepared setup/active/recovery counts
  * for a drive into the cmd640 chipset registers to active them.
  */
-static void program_drive_counts (unsigned int index)
+static void program_drive_counts(ide_drive_t *drive, unsigned int index)
 {
         unsigned long flags;
         u8 setup_count    = setup_counts[index];
@@ -522,8 +475,11 @@ static void program_drive_counts (unsigned int index)
          * so we merge the timings, using the slowest value for each timing.
          */
         if (index > 1) {
-                unsigned int mate;
-                if (cmd_drives[mate = index ^ 1]->present) {
+                ide_hwif_t *hwif = drive->hwif;
+                ide_drive_t *peer = &hwif->drives[!drive->select.b.unit];
+                unsigned int mate = index ^ 1;
+
+                if (peer->present) {
                         if (setup_count < setup_counts[mate])
                                 setup_count = setup_counts[mate];
                         if (active_count < active_counts[mate])
@@ -537,11 +493,11 @@ static void program_drive_counts (unsigned int index)
          * Convert setup_count to internal chipset representation
          */
         switch (setup_count) {
-                case 4:  setup_count = 0x00; break;
-                case 3:  setup_count = 0x80; break;
-                case 1:
-                case 2:  setup_count = 0x40; break;
-                default: setup_count = 0xc0; /* case 5 */
+        case 4:  setup_count = 0x00; break;
+        case 3:  setup_count = 0x80; break;
+        case 1:
+        case 2:  setup_count = 0x40; break;
+        default: setup_count = 0xc0; /* case 5 */
         }
 
         /*
@@ -562,11 +518,19 @@ static void program_drive_counts (unsigned int index)
 /*
  * Set a specific pio_mode for a drive
  */
-static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle_time)
+static void cmd640_set_mode(ide_drive_t *drive, unsigned int index,
+                            u8 pio_mode, unsigned int cycle_time)
 {
         int setup_time, active_time, recovery_time, clock_time;
         u8 setup_count, active_count, recovery_count, recovery_count2, cycle_count;
-        int bus_speed = system_bus_clock();
+        int bus_speed;
+
+        if (cmd640_vlb && ide_vlb_clk)
+                bus_speed = ide_vlb_clk;
+        else if (!cmd640_vlb && ide_pci_clk)
+                bus_speed = ide_pci_clk;
+        else
+                bus_speed = system_bus_clock();
 
         if (pio_mode > 5)
                 pio_mode = 5;
@@ -574,15 +538,15 @@ static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle
         active_time = ide_pio_timings[pio_mode].active_time;
         recovery_time = cycle_time - (setup_time + active_time);
         clock_time = 1000 / bus_speed;
-        cycle_count = (cycle_time + clock_time - 1) / clock_time;
+        cycle_count = DIV_ROUND_UP(cycle_time, clock_time);
 
-        setup_count = (setup_time + clock_time - 1) / clock_time;
+        setup_count = DIV_ROUND_UP(setup_time, clock_time);
 
-        active_count = (active_time + clock_time - 1) / clock_time;
+        active_count = DIV_ROUND_UP(active_time, clock_time);
         if (active_count < 2)
                 active_count = 2; /* minimum allowed by cmd640 */
 
-        recovery_count = (recovery_time + clock_time - 1) / clock_time;
+        recovery_count = DIV_ROUND_UP(recovery_time, clock_time);
         recovery_count2 = cycle_count - (setup_count + active_count);
         if (recovery_count2 > recovery_count)
                 recovery_count = recovery_count2;
@@ -611,7 +575,7 @@ static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle
          *      1) this is the wrong place to do it (proper is do_special() in ide.c)
          *      2) in practice this is rarely, if ever, necessary
          */
-        program_drive_counts (index);
+        program_drive_counts(drive, index);
 }
 
 static void cmd640_set_pio_mode(ide_drive_t *drive, const u8 pio)
@@ -619,32 +583,26 @@ static void cmd640_set_pio_mode(ide_drive_t *drive, const u8 pio)
         unsigned int index = 0, cycle_time;
         u8 b;
 
-        while (drive != cmd_drives[index]) {
-                if (++index > 3) {
-                        printk(KERN_ERR "%s: bad news in %s\n",
-                                        drive->name, __FUNCTION__);
-                        return;
-                }
-        }
         switch (pio) {
-                case 6: /* set fast-devsel off */
-                case 7: /* set fast-devsel on */
-                        b = get_cmd640_reg(CNTRL) & ~0x27;
-                        if (pio & 1)
-                                b |= 0x27;
-                        put_cmd640_reg(CNTRL, b);
-                        printk("%s: %sabled cmd640 fast host timing (devsel)\n", drive->name, (pio & 1) ? "en" : "dis");
-                        return;
-
-                case 8: /* set prefetch off */
-                case 9: /* set prefetch on */
-                        set_prefetch_mode(index, pio & 1);
-                        printk("%s: %sabled cmd640 prefetch\n", drive->name, (pio & 1) ? "en" : "dis");
-                        return;
+        case 6: /* set fast-devsel off */
+        case 7: /* set fast-devsel on */
+                b = get_cmd640_reg(CNTRL) & ~0x27;
+                if (pio & 1)
+                        b |= 0x27;
+                put_cmd640_reg(CNTRL, b);
+                printk("%s: %sabled cmd640 fast host timing (devsel)\n",
+                        drive->name, (pio & 1) ? "en" : "dis");
+                return;
+        case 8: /* set prefetch off */
+        case 9: /* set prefetch on */
+                set_prefetch_mode(drive, index, pio & 1);
+                printk("%s: %sabled cmd640 prefetch\n",
+                        drive->name, (pio & 1) ? "en" : "dis");
+                return;
         }
 
         cycle_time = ide_pio_cycle_time(drive, pio);
-        cmd640_set_mode(index, pio, cycle_time);
+        cmd640_set_mode(drive, index, pio, cycle_time);
 
         printk("%s: selected cmd640 PIO mode%d (%dns)",
                 drive->name, pio, cycle_time);
@@ -652,6 +610,9 @@ static void cmd640_set_pio_mode(ide_drive_t *drive, const u8 pio)
         display_clocks(index);
 }
 
+static const struct ide_port_ops cmd640_port_ops = {
+        .set_pio_mode           = cmd640_set_pio_mode,
+};
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
 
 static int pci_conf1(void)
@@ -693,14 +654,32 @@ static const struct ide_port_info cmd640_port_info __initdata = {
         .chipset                = ide_cmd640,
         .host_flags             = IDE_HFLAG_SERIALIZE |
                                   IDE_HFLAG_NO_DMA |
-                                  IDE_HFLAG_NO_AUTOTUNE |
                                   IDE_HFLAG_ABUSE_PREFETCH |
                                   IDE_HFLAG_ABUSE_FAST_DEVSEL,
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+        .port_ops               = &cmd640_port_ops,
         .pio_mask               = ATA_PIO5,
 #endif
 };
 
+static int cmd640x_init_one(unsigned long base, unsigned long ctl)
+{
+        if (!request_region(base, 8, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                DRV_NAME, base, base + 7);
+                return -EBUSY;
+        }
+
+        if (!request_region(ctl, 1, DRV_NAME)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                DRV_NAME, ctl);
+                release_region(base, 8);
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
 /*
  * Probe for a cmd640 chipset, and initialize it if found.
  */
@@ -709,7 +688,7 @@ static int __init cmd640x_init(void)
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
         int second_port_toggled = 0;
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
-        int second_port_cmd640 = 0;
+        int second_port_cmd640 = 0, rc;
         const char *bus_type, *port2;
         unsigned int index;
         u8 b, cfr;
@@ -749,10 +728,21 @@ static int __init cmd640x_init(void)
         cfr = get_cmd640_reg(CFR);
         cmd640_chip_version = cfr & CFR_DEVREV;
         if (cmd640_chip_version == 0) {
-                printk ("ide: bad cmd640 revision: %d\n", cmd640_chip_version);
+                printk("ide: bad cmd640 revision: %d\n", cmd640_chip_version);
                 return 0;
         }
 
+        rc = cmd640x_init_one(0x1f0, 0x3f6);
+        if (rc)
+                return rc;
+
+        rc = cmd640x_init_one(0x170, 0x376);
+        if (rc) {
+                release_region(0x3f6, 1);
+                release_region(0x1f0, 8);
+                return rc;
+        }
+
         memset(&hw, 0, sizeof(hw));
 
         ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
@@ -764,17 +754,15 @@ static int __init cmd640x_init(void)
         printk(KERN_INFO "cmd640: buggy cmd640%c interface on %s, config=0x%02x"
                          "\n", 'a' + cmd640_chip_version - 1, bus_type, cfr);
 
+        cmd_hwif0 = ide_find_port();
+
         /*
          * Initialize data for primary port
          */
-        setup_device_ptrs ();
-
-        ide_init_port_hw(cmd_hwif0, &hw[0]);
-#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
-        cmd_hwif0->set_pio_mode = &cmd640_set_pio_mode;
-#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
-
-        idx[0] = cmd_hwif0->index;
+        if (cmd_hwif0) {
+                ide_init_port_hw(cmd_hwif0, &hw[0]);
+                idx[0] = cmd_hwif0->index;
+        }
 
         /*
          * Ensure compatibility by always using the slowest timings
@@ -786,10 +774,13 @@ static int __init cmd640x_init(void)
         put_cmd640_reg(CMDTIM, 0);
         put_cmd640_reg(BRST, 0x40);
 
+        cmd_hwif1 = ide_find_port();
+
         /*
          * Try to enable the secondary interface, if not already enabled
          */
-        if (cmd_hwif1->drives[0].noprobe && cmd_hwif1->drives[1].noprobe) {
+        if (cmd_hwif1 &&
+            cmd_hwif1->drives[0].noprobe && cmd_hwif1->drives[1].noprobe) {
                 port2 = "not probed";
         } else {
                 b = get_cmd640_reg(CNTRL);
@@ -820,15 +811,11 @@ static int __init cmd640x_init(void)
         /*
          * Initialize data for secondary cmd640 port, if enabled
          */
-        if (second_port_cmd640) {
+        if (second_port_cmd640 && cmd_hwif1) {
                 ide_init_port_hw(cmd_hwif1, &hw[1]);
-#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
-                cmd_hwif1->set_pio_mode = &cmd640_set_pio_mode;
-#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
-
                 idx[1] = cmd_hwif1->index;
         }
-        printk(KERN_INFO "%s: %sserialized, secondary interface %s\n", cmd_hwif1->name,
+        printk(KERN_INFO "cmd640: %sserialized, secondary interface %s\n",
                          second_port_cmd640 ? "" : "not ", port2);
 
         /*
@@ -836,35 +823,34 @@ static int __init cmd640x_init(void)
          * Do not unnecessarily disturb any prior BIOS setup of these.
          */
         for (index = 0; index < (2 + (second_port_cmd640 << 1)); index++) {
-                ide_drive_t *drive = cmd_drives[index];
-#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
-                if (drive->autotune || ((index > 1) && second_port_toggled)) {
-                        /*
-                         * Reset timing to the slowest speed and turn off prefetch.
-                         * This way, the drive identify code has a better chance.
-                         */
-                        setup_counts    [index] = 4;    /* max possible */
-                        active_counts   [index] = 16;   /* max possible */
-                        recovery_counts [index] = 16;   /* max possible */
-                        program_drive_counts (index);
-                        set_prefetch_mode (index, 0);
-                        printk("cmd640: drive%d timings/prefetch cleared\n", index);
-                } else {
-                        /*
-                         * Record timings/prefetch without changing them.
-                         * This preserves any prior BIOS setup.
-                         */
-                        retrieve_drive_counts (index);
-                        check_prefetch (index);
-                        printk("cmd640: drive%d timings/prefetch(%s) preserved",
-                                index, drive->no_io_32bit ? "off" : "on");
-                        display_clocks(index);
+                ide_drive_t *drive;
+
+                if (index > 1) {
+                        if (cmd_hwif1 == NULL)
+                                continue;
+                        drive = &cmd_hwif1->drives[index & 1];
+                } else  {
+                        if (cmd_hwif0 == NULL)
+                                continue;
+                        drive = &cmd_hwif0->drives[index & 1];
                 }
+
+#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+                /*
+                 * Reset timing to the slowest speed and turn off prefetch.
+                 * This way, the drive identify code has a better chance.
+                 */
+                setup_counts    [index] = 4;    /* max possible */
+                active_counts   [index] = 16;   /* max possible */
+                recovery_counts [index] = 16;   /* max possible */
+                program_drive_counts(drive, index);
+                set_prefetch_mode(drive, index, 0);
+                printk("cmd640: drive%d timings/prefetch cleared\n", index);
 #else
                 /*
                  * Set the drive unmask flags to match the prefetch setting
                  */
-                check_prefetch (index);
+                check_prefetch(drive, index);
                 printk("cmd640: drive%d timings/prefetch(%s) preserved\n",
                         index, drive->no_io_32bit ? "off" : "on");
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
diff --git a/drivers/ide/pci/cmd64x.c b/drivers/ide/pci/cmd64x.c
index edabe6299efd..08674711d089 100644
--- a/drivers/ide/pci/cmd64x.c
+++ b/drivers/ide/pci/cmd64x.c
@@ -68,8 +68,8 @@ static u8 quantize_timing(int timing, int quant)
  */
 static void program_cycle_times (ide_drive_t *drive, int cycle_time, int active_time)
 {
-        struct pci_dev *dev     = to_pci_dev(drive->hwif->dev);
-        int clock_time          = 1000 / system_bus_clock();
+        struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
+        int clock_time = 1000 / (ide_pci_clk ? ide_pci_clk : system_bus_clock());
         u8  cycle_count, active_count, recovery_count, drwtim;
         static const u8 recovery_values[] =
                 {15, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0};
@@ -128,7 +128,7 @@ static void cmd64x_tune_pio(ide_drive_t *drive, const u8 pio)
                             ide_pio_timings[pio].active_time);
 
         setup_count = quantize_timing(ide_pio_timings[pio].setup_time,
-                                      1000 / system_bus_clock());
+                        1000 / (ide_pci_clk ? ide_pci_clk : system_bus_clock()));
 
         /*
          * The primary channel has individual address setup timing registers
@@ -223,7 +223,7 @@ static void cmd64x_set_dma_mode(ide_drive_t *drive, const u8 speed)
                 (void) pci_write_config_byte(dev, pciU, regU);
 }
 
-static int cmd648_ide_dma_end (ide_drive_t *drive)
+static int cmd648_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long base      = hwif->dma_base - (hwif->channel * 8);
@@ -239,7 +239,7 @@ static int cmd648_ide_dma_end (ide_drive_t *drive)
         return err;
 }
 
-static int cmd64x_ide_dma_end (ide_drive_t *drive)
+static int cmd64x_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -256,7 +256,7 @@ static int cmd64x_ide_dma_end (ide_drive_t *drive)
         return err;
 }
 
-static int cmd648_ide_dma_test_irq (ide_drive_t *drive)
+static int cmd648_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long base      = hwif->dma_base - (hwif->channel * 8);
@@ -279,7 +279,7 @@ static int cmd648_ide_dma_test_irq (ide_drive_t *drive)
         return 0;
 }
 
-static int cmd64x_ide_dma_test_irq (ide_drive_t *drive)
+static int cmd64x_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -310,7 +310,7 @@ static int cmd64x_ide_dma_test_irq (ide_drive_t *drive)
  * event order for DMA transfers.
  */
 
-static int cmd646_1_ide_dma_end (ide_drive_t *drive)
+static int cmd646_1_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
         u8 dma_stat = 0, dma_cmd = 0;
@@ -370,7 +370,7 @@ static unsigned int __devinit init_chipset_cmd64x(struct pci_dev *dev, const cha
         return 0;
 }
 
-static u8 __devinit ata66_cmd64x(ide_hwif_t *hwif)
+static u8 __devinit cmd64x_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev  *dev    = to_pci_dev(hwif->dev);
         u8 bmidecsr = 0, mask   = hwif->channel ? 0x02 : 0x01;
@@ -385,91 +385,85 @@ static u8 __devinit ata66_cmd64x(ide_hwif_t *hwif)
         }
 }
 
-static void __devinit init_hwif_cmd64x(ide_hwif_t *hwif)
-{
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-
-        hwif->set_pio_mode = &cmd64x_set_pio_mode;
-        hwif->set_dma_mode = &cmd64x_set_dma_mode;
-
-        hwif->cable_detect = ata66_cmd64x;
+static const struct ide_port_ops cmd64x_port_ops = {
+        .set_pio_mode           = cmd64x_set_pio_mode,
+        .set_dma_mode           = cmd64x_set_dma_mode,
+        .cable_detect           = cmd64x_cable_detect,
+};
 
-        if (!hwif->dma_base)
-                return;
+static const struct ide_dma_ops cmd64x_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = cmd64x_dma_end,
+        .dma_test_irq           = cmd64x_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
-        /*
-         * UltraDMA only supported on PCI646U and PCI646U2, which
-         * correspond to revisions 0x03, 0x05 and 0x07 respectively.
-         * Actually, although the CMD tech support people won't
-         * tell me the details, the 0x03 revision cannot support
-         * UDMA correctly without hardware modifications, and even
-         * then it only works with Quantum disks due to some
-         * hold time assumptions in the 646U part which are fixed
-         * in the 646U2.
-         *
-         * So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
-         */
-        if (dev->device == PCI_DEVICE_ID_CMD_646 && dev->revision < 5)
-                hwif->ultra_mask = 0x00;
+static const struct ide_dma_ops cmd646_rev1_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = cmd646_1_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
-        switch (dev->device) {
-        case PCI_DEVICE_ID_CMD_648:
-        case PCI_DEVICE_ID_CMD_649:
-        alt_irq_bits:
-                hwif->ide_dma_end       = &cmd648_ide_dma_end;
-                hwif->ide_dma_test_irq  = &cmd648_ide_dma_test_irq;
-                break;
-        case PCI_DEVICE_ID_CMD_646:
-                if (dev->revision == 0x01) {
-                        hwif->ide_dma_end = &cmd646_1_ide_dma_end;
-                        break;
-                } else if (dev->revision >= 0x03)
-                        goto alt_irq_bits;
-                /* fall thru */
-        default:
-                hwif->ide_dma_end       = &cmd64x_ide_dma_end;
-                hwif->ide_dma_test_irq  = &cmd64x_ide_dma_test_irq;
-                break;
-        }
-}
+static const struct ide_dma_ops cmd648_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = cmd648_dma_end,
+        .dma_test_irq           = cmd648_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
 static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "CMD643",
                 .init_chipset   = init_chipset_cmd64x,
-                .init_hwif      = init_hwif_cmd64x,
                 .enablebits     = {{0x00,0x00,0x00}, {0x51,0x08,0x08}},
+                .port_ops       = &cmd64x_port_ops,
+                .dma_ops        = &cmd64x_dma_ops,
                 .host_flags     = IDE_HFLAG_CLEAR_SIMPLEX |
-                                  IDE_HFLAG_ABUSE_PREFETCH |
-                                  IDE_HFLAG_BOOTABLE,
+                                  IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = 0x00, /* no udma */
         },{     /* 1 */
                 .name           = "CMD646",
                 .init_chipset   = init_chipset_cmd64x,
-                .init_hwif      = init_hwif_cmd64x,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .chipset        = ide_cmd646,
-                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH | IDE_HFLAG_BOOTABLE,
+                .port_ops       = &cmd64x_port_ops,
+                .dma_ops        = &cmd648_dma_ops,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA2,
         },{     /* 2 */
                 .name           = "CMD648",
                 .init_chipset   = init_chipset_cmd64x,
-                .init_hwif      = init_hwif_cmd64x,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
-                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH | IDE_HFLAG_BOOTABLE,
+                .port_ops       = &cmd64x_port_ops,
+                .dma_ops        = &cmd648_dma_ops,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA4,
         },{     /* 3 */
                 .name           = "CMD649",
                 .init_chipset   = init_chipset_cmd64x,
-                .init_hwif      = init_hwif_cmd64x,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
-                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH | IDE_HFLAG_BOOTABLE,
+                .port_ops       = &cmd64x_port_ops,
+                .dma_ops        = &cmd648_dma_ops,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA5,
@@ -483,12 +477,35 @@ static int __devinit cmd64x_init_one(struct pci_dev *dev, const struct pci_devic
 
         d = cmd64x_chipsets[idx];
 
-        /*
-         * The original PCI0646 didn't have the primary channel enable bit,
-         * it appeared starting with PCI0646U (i.e. revision ID 3).
-         */
-        if (idx == 1 && dev->revision < 3)
-                d.enablebits[0].reg = 0;
+        if (idx == 1) {
+                /*
+                 * UltraDMA only supported on PCI646U and PCI646U2, which
+                 * correspond to revisions 0x03, 0x05 and 0x07 respectively.
+                 * Actually, although the CMD tech support people won't
+                 * tell me the details, the 0x03 revision cannot support
+                 * UDMA correctly without hardware modifications, and even
+                 * then it only works with Quantum disks due to some
+                 * hold time assumptions in the 646U part which are fixed
+                 * in the 646U2.
+                 *
+                 * So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
+                 */
+                if (dev->revision < 5) {
+                        d.udma_mask = 0x00;
+                        /*
+                         * The original PCI0646 didn't have the primary
+                         * channel enable bit, it appeared starting with
+                         * PCI0646U (i.e. revision ID 3).
+                         */
+                        if (dev->revision < 3) {
+                                d.enablebits[0].reg = 0;
+                                if (dev->revision == 1)
+                                        d.dma_ops = &cmd646_rev1_dma_ops;
+                                else
+                                        d.dma_ops = &cmd64x_dma_ops;
+                        }
+                }
+        }
 
         return ide_setup_pci_device(dev, &d);
 }
diff --git a/drivers/ide/pci/cs5520.c b/drivers/ide/pci/cs5520.c
index 1c163e4ef03f..17669a434438 100644
--- a/drivers/ide/pci/cs5520.c
+++ b/drivers/ide/pci/cs5520.c
@@ -103,27 +103,32 @@ static void cs5520_dma_host_set(ide_drive_t *drive, int on)
         ide_dma_host_set(drive, on);
 }
 
-static void __devinit init_hwif_cs5520(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &cs5520_set_pio_mode;
-        hwif->set_dma_mode = &cs5520_set_dma_mode;
-
-        if (hwif->dma_base == 0)
-                return;
+static const struct ide_port_ops cs5520_port_ops = {
+        .set_pio_mode           = cs5520_set_pio_mode,
+        .set_dma_mode           = cs5520_set_dma_mode,
+};
 
-        hwif->dma_host_set = &cs5520_dma_host_set;
-}
+static const struct ide_dma_ops cs5520_dma_ops = {
+        .dma_host_set           = cs5520_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
 #define DECLARE_CS_DEV(name_str)                                \
         {                                                       \
                 .name           = name_str,                     \
-                .init_hwif      = init_hwif_cs5520,             \
+                .port_ops       = &cs5520_port_ops,             \
+                .dma_ops        = &cs5520_dma_ops,              \
                 .host_flags     = IDE_HFLAG_ISA_PORTS |         \
                                   IDE_HFLAG_CS5520 |            \
                                   IDE_HFLAG_VDMA |              \
                                   IDE_HFLAG_NO_ATAPI_DMA |      \
-                                  IDE_HFLAG_ABUSE_SET_DMA_MODE |\
-                                  IDE_HFLAG_BOOTABLE,           \
+                                  IDE_HFLAG_ABUSE_SET_DMA_MODE, \
                 .pio_mask       = ATA_PIO4,                     \
         }
 
diff --git a/drivers/ide/pci/cs5530.c b/drivers/ide/pci/cs5530.c
index 941a1344820b..f5534c1ff349 100644
--- a/drivers/ide/pci/cs5530.c
+++ b/drivers/ide/pci/cs5530.c
@@ -228,29 +228,27 @@ static void __devinit init_hwif_cs5530 (ide_hwif_t *hwif)
         unsigned long basereg;
         u32 d0_timings;
 
-        hwif->set_pio_mode = &cs5530_set_pio_mode;
-        hwif->set_dma_mode = &cs5530_set_dma_mode;
-
         basereg = CS5530_BASEREG(hwif);
         d0_timings = inl(basereg + 0);
         if (CS5530_BAD_PIO(d0_timings))
                 outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 0);
         if (CS5530_BAD_PIO(inl(basereg + 8)))
                 outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 8);
-
-        if (hwif->dma_base == 0)
-                return;
-
-        hwif->udma_filter = cs5530_udma_filter;
 }
 
+static const struct ide_port_ops cs5530_port_ops = {
+        .set_pio_mode           = cs5530_set_pio_mode,
+        .set_dma_mode           = cs5530_set_dma_mode,
+        .udma_filter            = cs5530_udma_filter,
+};
+
 static const struct ide_port_info cs5530_chipset __devinitdata = {
         .name           = "CS5530",
         .init_chipset   = init_chipset_cs5530,
         .init_hwif      = init_hwif_cs5530,
+        .port_ops       = &cs5530_port_ops,
         .host_flags     = IDE_HFLAG_SERIALIZE |
-                          IDE_HFLAG_POST_SET_MODE |
-                          IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_POST_SET_MODE,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA2,
diff --git a/drivers/ide/pci/cs5535.c b/drivers/ide/pci/cs5535.c
index d7b5ea992e94..99fe91a191b8 100644
--- a/drivers/ide/pci/cs5535.c
+++ b/drivers/ide/pci/cs5535.c
@@ -166,27 +166,17 @@ static u8 __devinit cs5535_cable_detect(ide_hwif_t *hwif)
         return (bit & 1) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
 }
 
-/****
- *      init_hwif_cs5535        -       Initialize one ide cannel
- *      @hwif: Channel descriptor
- *
- *      This gets invoked by the IDE driver once for each channel. It
- *      performs channel-specific pre-initialization before drive probing.
- *
- */
-static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &cs5535_set_pio_mode;
-        hwif->set_dma_mode = &cs5535_set_dma_mode;
-
-        hwif->cable_detect = cs5535_cable_detect;
-}
+static const struct ide_port_ops cs5535_port_ops = {
+        .set_pio_mode           = cs5535_set_pio_mode,
+        .set_dma_mode           = cs5535_set_dma_mode,
+        .cable_detect           = cs5535_cable_detect,
+};
 
 static const struct ide_port_info cs5535_chipset __devinitdata = {
         .name           = "CS5535",
-        .init_hwif      = init_hwif_cs5535,
+        .port_ops       = &cs5535_port_ops,
         .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_POST_SET_MODE |
-                          IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_ABUSE_SET_DMA_MODE,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA4,
diff --git a/drivers/ide/pci/cy82c693.c b/drivers/ide/pci/cy82c693.c
index 724cbacf4e5b..77cc22c2ad45 100644
--- a/drivers/ide/pci/cy82c693.c
+++ b/drivers/ide/pci/cy82c693.c
@@ -6,7 +6,7 @@
  *
  * The CY82C693 chipset is used on Digital's PC-Alpha 164SX boards.
  * Writing the driver was quite simple, since most of the job is
- * done by the generic pci-ide support. 
+ * done by the generic pci-ide support.
  * The hard part was finding the CY82C693's datasheet on Cypress's
  * web page :-(. But Altavista solved this problem :-).
  *
@@ -15,12 +15,10 @@
  * - I recently got a 16.8G IBM DTTA, so I was able to test it with
  *   a large and fast disk - the results look great, so I'd say the
  *   driver is working fine :-)
- *   hdparm -t reports 8.17 MB/sec at about 6% CPU usage for the DTTA 
- * - this is my first linux driver, so there's probably a lot  of room 
+ *   hdparm -t reports 8.17 MB/sec at about 6% CPU usage for the DTTA
+ * - this is my first linux driver, so there's probably a lot  of room
  *   for optimizations and bug fixing, so feel free to do it.
- * - use idebus=xx parameter to set PCI bus speed - needed to calc
- *   timings for PIO modes (default will be 40)
- * - if using PIO mode it's a good idea to set the PIO mode and 
+ * - if using PIO mode it's a good idea to set the PIO mode and
  *   32-bit I/O support (if possible), e.g. hdparm -p2 -c1 /dev/hda
  * - I had some problems with my IBM DHEA with PIO modes < 2
  *   (lost interrupts) ?????
@@ -110,11 +108,11 @@ typedef struct pio_clocks_s {
  * calc clocks using bus_speed
  * returns (rounded up) time in bus clocks for time in ns
  */
-static int calc_clk (int time, int bus_speed)
+static int calc_clk(int time, int bus_speed)
 {
         int clocks;
 
-        clocks = (time*bus_speed+999)/1000 -1;
+        clocks = (time*bus_speed+999)/1000 - 1;
 
         if (clocks < 0)
                 clocks = 0;
@@ -132,11 +130,11 @@ static int calc_clk (int time, int bus_speed)
  * NOTE: for mode 0,1 and 2 drives 8-bit IDE command control registers are used
  *       for mode 3 and 4 drives 8 and 16-bit timings are the same
  *
- */ 
-static void compute_clocks (u8 pio, pio_clocks_t *p_pclk)
+ */
+static void compute_clocks(u8 pio, pio_clocks_t *p_pclk)
 {
         int clk1, clk2;
-        int bus_speed = system_bus_clock();     /* get speed of PCI bus */
+        int bus_speed = ide_pci_clk ? ide_pci_clk : system_bus_clock();
 
         /* we don't check against CY82C693's min and max speed,
          * so you can play with the idebus=xx parameter
@@ -158,7 +156,7 @@ static void compute_clocks (u8 pio, pio_clocks_t *p_pclk)
         clk1 = (clk1<<4)|clk2;  /* combine active and recovery clocks */
 
         /* note: we use the same values for 16bit IOR and IOW
-         *      those are all the same, since I don't have other
+         *      those are all the same, since I don't have other
          *      timings than those from ide-lib.c
          */
 
@@ -186,7 +184,7 @@ static void cy82c693_set_dma_mode(ide_drive_t *drive, const u8 mode)
         outb(index, CY82_INDEX_PORT);
         data = inb(CY82_DATA_PORT);
 
-        printk (KERN_INFO "%s (ch=%d, dev=%d): DMA mode is %d (single=%d)\n",
+        printk(KERN_INFO "%s (ch=%d, dev=%d): DMA mode is %d (single=%d)\n",
                 drive->name, HWIF(drive)->channel, drive->select.b.unit,
                 (data&0x3), ((data>>2)&1));
 #endif /* CY82C693_DEBUG_LOGS */
@@ -202,7 +200,7 @@ static void cy82c693_set_dma_mode(ide_drive_t *drive, const u8 mode)
                 mode & 3, single);
 #endif /* CY82C693_DEBUG_INFO */
 
-        /* 
+        /*
          * note: below we set the value for Bus Master IDE TimeOut Register
          * I'm not absolutly sure what this does, but it solved my problem
          * with IDE DMA and sound, so I now can play sound and work with
@@ -216,8 +214,8 @@ static void cy82c693_set_dma_mode(ide_drive_t *drive, const u8 mode)
         outb(CY82_INDEX_TIMEOUT, CY82_INDEX_PORT);
         outb(data, CY82_DATA_PORT);
 
-#if CY82C693_DEBUG_INFO 
-        printk (KERN_INFO "%s: Set IDE Bus Master TimeOut Register to 0x%X\n",
+#if CY82C693_DEBUG_INFO
+        printk(KERN_INFO "%s: Set IDE Bus Master TimeOut Register to 0x%X\n",
                 drive->name, data);
 #endif /* CY82C693_DEBUG_INFO */
 }
@@ -242,14 +240,14 @@ static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 #if CY82C693_DEBUG_LOGS
         /* for debug let's show the register values */
-        
-        if (drive->select.b.unit == 0) {
+
+        if (drive->select.b.unit == 0) {
                 /*
-                 * get master drive registers                   
+                 * get master drive registers
                  * address setup control register
                  * is 32 bit !!!
-                 */ 
-                pci_read_config_dword(dev, CY82_IDE_ADDRSETUP, &addrCtrl);                
+                 */
+                pci_read_config_dword(dev, CY82_IDE_ADDRSETUP, &addrCtrl);
                 addrCtrl &= 0x0F;
 
                 /* now let's get the remaining registers */
@@ -261,7 +259,7 @@ static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
                  * set slave drive registers
                  * address setup control register
                  * is 32 bit !!!
-                 */ 
+                 */
                 pci_read_config_dword(dev, CY82_IDE_ADDRSETUP, &addrCtrl);
 
                 addrCtrl &= 0xF0;
@@ -288,9 +286,9 @@ static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
                  * set master drive
                  * address setup control register
                  * is 32 bit !!!
-                 */ 
+                 */
                 pci_read_config_dword(dev, CY82_IDE_ADDRSETUP, &addrCtrl);
-                
+
                 addrCtrl &= (~0xF);
                 addrCtrl |= (unsigned int)pclk.address_time;
                 pci_write_config_dword(dev, CY82_IDE_ADDRSETUP, addrCtrl);
@@ -299,14 +297,14 @@ static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 pci_write_config_byte(dev, CY82_IDE_MASTER_IOR, pclk.time_16r);
                 pci_write_config_byte(dev, CY82_IDE_MASTER_IOW, pclk.time_16w);
                 pci_write_config_byte(dev, CY82_IDE_MASTER_8BIT, pclk.time_8);
-                
+
                 addrCtrl &= 0xF;
         } else {
                 /*
                  * set slave drive
                  * address setup control register
                  * is 32 bit !!!
-                 */ 
+                 */
                 pci_read_config_dword(dev, CY82_IDE_ADDRSETUP, &addrCtrl);
 
                 addrCtrl &= (~0xF0);
@@ -320,7 +318,7 @@ static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
                 addrCtrl >>= 4;
                 addrCtrl &= 0xF;
-        }       
+        }
 
 #if CY82C693_DEBUG_INFO
         printk(KERN_INFO "%s (ch=%d, dev=%d): set PIO timing to "
@@ -340,41 +338,41 @@ static unsigned int __devinit init_chipset_cy82c693(struct pci_dev *dev, const c
 
 #ifdef CY82C693_SETDMA_CLOCK
         u8 data = 0;
-#endif /* CY82C693_SETDMA_CLOCK */ 
+#endif /* CY82C693_SETDMA_CLOCK */
 
         /* write info about this verion of the driver */
         printk(KERN_INFO CY82_VERSION "\n");
 
 #ifdef CY82C693_SETDMA_CLOCK
        /* okay let's set the DMA clock speed */
-        
-        outb(CY82_INDEX_CTRLREG1, CY82_INDEX_PORT);
-        data = inb(CY82_DATA_PORT);
+
+        outb(CY82_INDEX_CTRLREG1, CY82_INDEX_PORT);
+        data = inb(CY82_DATA_PORT);
 
 #if CY82C693_DEBUG_INFO
         printk(KERN_INFO "%s: Peripheral Configuration Register: 0x%X\n",
                 name, data);
 #endif /* CY82C693_DEBUG_INFO */
 
-        /*
+        /*
          * for some reason sometimes the DMA controller
          * speed is set to ATCLK/2 ???? - we fix this here
-         * 
+         *
          * note: i don't know what causes this strange behaviour,
          *       but even changing the dma speed doesn't solve it :-(
-         *       the ide performance is still only half the normal speed 
-         * 
+         *       the ide performance is still only half the normal speed
+         *
          *       if anybody knows what goes wrong with my machine, please
          *       let me know - ASK
-         */
+         */
 
         data |= 0x03;
 
-        outb(CY82_INDEX_CTRLREG1, CY82_INDEX_PORT);
-        outb(data, CY82_DATA_PORT);
+        outb(CY82_INDEX_CTRLREG1, CY82_INDEX_PORT);
+        outb(data, CY82_DATA_PORT);
 
 #if CY82C693_DEBUG_INFO
-        printk (KERN_INFO "%s: New Peripheral Configuration Register: 0x%X\n",
+        printk(KERN_INFO "%s: New Peripheral Configuration Register: 0x%X\n",
                 name, data);
 #endif /* CY82C693_DEBUG_INFO */
 
@@ -382,15 +380,6 @@ static unsigned int __devinit init_chipset_cy82c693(struct pci_dev *dev, const c
         return 0;
 }
 
-/*
- * the init function - called for each ide channel once
- */
-static void __devinit init_hwif_cy82c693(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &cy82c693_set_pio_mode;
-        hwif->set_dma_mode = &cy82c693_set_dma_mode;
-}
-
 static void __devinit init_iops_cy82c693(ide_hwif_t *hwif)
 {
         static ide_hwif_t *primary;
@@ -404,14 +393,18 @@ static void __devinit init_iops_cy82c693(ide_hwif_t *hwif)
         }
 }
 
+static const struct ide_port_ops cy82c693_port_ops = {
+        .set_pio_mode           = cy82c693_set_pio_mode,
+        .set_dma_mode           = cy82c693_set_dma_mode,
+};
+
 static const struct ide_port_info cy82c693_chipset __devinitdata = {
         .name           = "CY82C693",
         .init_chipset   = init_chipset_cy82c693,
         .init_iops      = init_iops_cy82c693,
-        .init_hwif      = init_hwif_cy82c693,
+        .port_ops       = &cy82c693_port_ops,
         .chipset        = ide_cy82c693,
-        .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_CY82C693 |
-                          IDE_HFLAG_BOOTABLE,
+        .host_flags     = IDE_HFLAG_SINGLE,
         .pio_mask       = ATA_PIO4,
         .swdma_mask     = ATA_SWDMA2,
         .mwdma_mask     = ATA_MWDMA2,
@@ -424,7 +417,7 @@ static int __devinit cy82c693_init_one(struct pci_dev *dev, const struct pci_dev
 
         /* CY82C693 is more than only a IDE controller.
            Function 1 is primary IDE channel, function 2 - secondary. */
-        if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
+        if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
             PCI_FUNC(dev->devfn) == 1) {
                 dev2 = pci_get_slot(dev->bus, dev->devfn + 1);
                 ret = ide_setup_pci_devices(dev, dev2, &cy82c693_chipset);
diff --git a/drivers/ide/pci/delkin_cb.c b/drivers/ide/pci/delkin_cb.c
index 961698d655eb..b9e457996d0e 100644
--- a/drivers/ide/pci/delkin_cb.c
+++ b/drivers/ide/pci/delkin_cb.c
@@ -43,6 +43,10 @@ static const u8 setup[] = {
         0x00, 0x00, 0x00, 0x00, 0xa4, 0x83, 0x02, 0x13,
 };
 
+static const struct ide_port_ops delkin_cb_port_ops = {
+        .quirkproc              = ide_undecoded_slave,
+};
+
 static int __devinit
 delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
 {
@@ -71,26 +75,21 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
                 if (setup[i])
                         outb(setup[i], base + i);
         }
-        pci_release_regions(dev);       /* IDE layer handles regions itself */
 
         memset(&hw, 0, sizeof(hw));
         ide_std_init_ports(&hw, base + 0x10, base + 0x1e);
         hw.irq = dev->irq;
         hw.chipset = ide_pci;           /* this enables IRQ sharing */
 
-        hwif = ide_find_port(hw.io_ports[IDE_DATA_OFFSET]);
+        hwif = ide_find_port();
         if (hwif == NULL)
                 goto out_disable;
 
         i = hwif->index;
 
-        if (hwif->present)
-                ide_unregister(i);
-        else
-                ide_init_port_data(hwif, i);
-
+        ide_init_port_data(hwif, i);
         ide_init_port_hw(hwif, &hw);
-        hwif->quirkproc = &ide_undecoded_slave;
+        hwif->port_ops = &delkin_cb_port_ops;
 
         idx[0] = i;
 
@@ -110,6 +109,7 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
 
 out_disable:
         printk(KERN_ERR "delkin_cb: no IDE devices found\n");
+        pci_release_regions(dev);
         pci_disable_device(dev);
         return -ENODEV;
 }
@@ -119,9 +119,9 @@ delkin_cb_remove (struct pci_dev *dev)
 {
         ide_hwif_t *hwif = pci_get_drvdata(dev);
 
-        if (hwif)
-                ide_unregister(hwif->index);
+        ide_unregister(hwif);
 
+        pci_release_regions(dev);
         pci_disable_device(dev);
 }
 
diff --git a/drivers/ide/pci/generic.c b/drivers/ide/pci/generic.c
index 7fd83a9d4dee..041720e22762 100644
--- a/drivers/ide/pci/generic.c
+++ b/drivers/ide/pci/generic.c
@@ -38,8 +38,7 @@ MODULE_PARM_DESC(all_generic_ide, "IDE generic will claim all unknown PCI IDE st
         { \
                 .name           = name_str, \
                 .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA | \
-                                  extra_flags | \
-                                  IDE_HFLAG_BOOTABLE, \
+                                  extra_flags, \
                 .swdma_mask     = ATA_SWDMA2, \
                 .mwdma_mask     = ATA_MWDMA2, \
                 .udma_mask      = ATA_UDMA6, \
@@ -50,9 +49,8 @@ static const struct ide_port_info generic_chipsets[] __devinitdata = {
 
         {       /* 1 */
                 .name           = "NS87410",
-                .enablebits     = {{0x43,0x08,0x08}, {0x47,0x08,0x08}},
-                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA |
-                                  IDE_HFLAG_BOOTABLE,
+                .enablebits     = { {0x43, 0x08, 0x08}, {0x47, 0x08, 0x08} },
+                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA,
                 .swdma_mask     = ATA_SWDMA2,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
@@ -99,7 +97,7 @@ static const struct ide_port_info generic_chipsets[] __devinitdata = {
  *      Called when the PCI registration layer (or the IDE initialization)
  *      finds a device matching our IDE device tables.
  */
- 
+
 static int __devinit generic_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
         const struct ide_port_info *d = &generic_chipsets[id->driver_data];
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
index 9f01da46b016..84c36c117194 100644
--- a/drivers/ide/pci/hpt34x.c
+++ b/drivers/ide/pci/hpt34x.c
@@ -115,11 +115,10 @@ static unsigned int __devinit init_chipset_hpt34x(struct pci_dev *dev, const cha
         return dev->irq;
 }
 
-static void __devinit init_hwif_hpt34x(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &hpt34x_set_pio_mode;
-        hwif->set_dma_mode = &hpt34x_set_mode;
-}
+static const struct ide_port_ops hpt34x_port_ops = {
+        .set_pio_mode           = hpt34x_set_pio_mode,
+        .set_dma_mode           = hpt34x_set_mode,
+};
 
 #define IDE_HFLAGS_HPT34X \
         (IDE_HFLAG_NO_ATAPI_DMA | \
@@ -131,16 +130,14 @@ static const struct ide_port_info hpt34x_chipsets[] __devinitdata = {
         { /* 0 */
                 .name           = "HPT343",
                 .init_chipset   = init_chipset_hpt34x,
-                .init_hwif      = init_hwif_hpt34x,
-                .extra          = 16,
-                .host_flags     = IDE_HFLAGS_HPT34X,
+                .port_ops       = &hpt34x_port_ops,
+                .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_NON_BOOTABLE,
                 .pio_mask       = ATA_PIO5,
         },
         { /* 1 */
                 .name           = "HPT345",
                 .init_chipset   = init_chipset_hpt34x,
-                .init_hwif      = init_hwif_hpt34x,
-                .extra          = 16,
+                .port_ops       = &hpt34x_port_ops,
                 .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_OFF_BOARD,
                 .pio_mask       = ATA_PIO5,
 #ifdef CONFIG_HPT34X_AUTODMA
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 82d0e318a1fe..c929dadaaaff 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -760,7 +760,7 @@ static void hpt3xx_maskproc(ide_drive_t *drive, int mask)
                 }
         } else
                 outb(mask ? (drive->ctl | 2) : (drive->ctl & ~2),
-                     hwif->io_ports[IDE_CONTROL_OFFSET]);
+                     hwif->io_ports.ctl_addr);
 }
 
 /*
@@ -776,7 +776,7 @@ static void hpt366_dma_lost_irq(ide_drive_t *drive)
         pci_read_config_byte(dev, 0x52, &mcr3);
         pci_read_config_byte(dev, 0x5a, &scr1);
         printk("%s: (%s)  mcr1=0x%02x, mcr3=0x%02x, scr1=0x%02x\n",
-                drive->name, __FUNCTION__, mcr1, mcr3, scr1);
+                drive->name, __func__, mcr1, mcr3, scr1);
         if (scr1 & 0x10)
                 pci_write_config_byte(dev, 0x5a, scr1 & ~0x10);
         ide_dma_lost_irq(drive);
@@ -808,7 +808,7 @@ static void hpt370_irq_timeout(ide_drive_t *drive)
         hpt370_clear_engine(drive);
 }
 
-static void hpt370_ide_dma_start(ide_drive_t *drive)
+static void hpt370_dma_start(ide_drive_t *drive)
 {
 #ifdef HPT_RESET_STATE_ENGINE
         hpt370_clear_engine(drive);
@@ -816,7 +816,7 @@ static void hpt370_ide_dma_start(ide_drive_t *drive)
         ide_dma_start(drive);
 }
 
-static int hpt370_ide_dma_end(ide_drive_t *drive)
+static int hpt370_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         u8  dma_stat            = inb(hwif->dma_status);
@@ -838,7 +838,7 @@ static void hpt370_dma_timeout(ide_drive_t *drive)
 }
 
 /* returns 1 if DMA IRQ issued, 0 otherwise */
-static int hpt374_ide_dma_test_irq(ide_drive_t *drive)
+static int hpt374_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -858,11 +858,11 @@ static int hpt374_ide_dma_test_irq(ide_drive_t *drive)
 
         if (!drive->waiting_for_dma)
                 printk(KERN_WARNING "%s: (%s) called while not waiting\n",
-                                drive->name, __FUNCTION__);
+                                drive->name, __func__);
         return 0;
 }
 
-static int hpt374_ide_dma_end(ide_drive_t *drive)
+static int hpt374_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -1271,17 +1271,6 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
         /* Cache the channel's MISC. control registers' offset */
         hwif->select_data       = hwif->channel ? 0x54 : 0x50;
 
-        hwif->set_pio_mode      = &hpt3xx_set_pio_mode;
-        hwif->set_dma_mode      = &hpt3xx_set_mode;
-
-        hwif->quirkproc         = &hpt3xx_quirkproc;
-        hwif->maskproc          = &hpt3xx_maskproc;
-
-        hwif->udma_filter       = &hpt3xx_udma_filter;
-        hwif->mdma_filter       = &hpt3xx_mdma_filter;
-
-        hwif->cable_detect      = hpt3xx_cable_detect;
-
         /*
          * HPT3xxN chips have some complications:
          *
@@ -1323,29 +1312,19 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
 
         if (new_mcr != old_mcr)
                 pci_write_config_byte(dev, hwif->select_data + 1, new_mcr);
-
-        if (hwif->dma_base == 0)
-                return;
-
-        if (chip_type >= HPT374) {
-                hwif->ide_dma_test_irq  = &hpt374_ide_dma_test_irq;
-                hwif->ide_dma_end       = &hpt374_ide_dma_end;
-        } else if (chip_type >= HPT370) {
-                hwif->dma_start         = &hpt370_ide_dma_start;
-                hwif->ide_dma_end       = &hpt370_ide_dma_end;
-                hwif->dma_timeout       = &hpt370_dma_timeout;
-        } else
-                hwif->dma_lost_irq      = &hpt366_dma_lost_irq;
 }
 
-static void __devinit init_dma_hpt366(ide_hwif_t *hwif, unsigned long dmabase)
+static int __devinit init_dma_hpt366(ide_hwif_t *hwif,
+                                     const struct ide_port_info *d)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
-        u8 masterdma    = 0, slavedma   = 0;
-        u8 dma_new      = 0, dma_old    = 0;
-        unsigned long flags;
+        unsigned long flags, base = ide_pci_dma_base(hwif, d);
+        u8 dma_old, dma_new, masterdma = 0, slavedma = 0;
 
-        dma_old = inb(dmabase + 2);
+        if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
+                return -1;
+
+        dma_old = inb(base + 2);
 
         local_irq_save(flags);
 
@@ -1356,11 +1335,21 @@ static void __devinit init_dma_hpt366(ide_hwif_t *hwif, unsigned long dmabase)
         if (masterdma & 0x30)   dma_new |= 0x20;
         if ( slavedma & 0x30)   dma_new |= 0x40;
         if (dma_new != dma_old)
-                outb(dma_new, dmabase + 2);
+                outb(dma_new, base + 2);
 
         local_irq_restore(flags);
 
-        ide_setup_dma(hwif, dmabase);
+        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx\n",
+                         hwif->name, base, base + 7);
+
+        hwif->extra_base = base + (hwif->channel ? 8 : 16);
+
+        if (ide_allocate_dma_engine(hwif))
+                return -1;
+
+        ide_setup_dma(hwif, base);
+
+        return 0;
 }
 
 static void __devinit hpt374_init(struct pci_dev *dev, struct pci_dev *dev2)
@@ -1416,6 +1405,49 @@ static int __devinit hpt36x_init(struct pci_dev *dev, struct pci_dev *dev2)
          IDE_HFLAG_ABUSE_SET_DMA_MODE | \
          IDE_HFLAG_OFF_BOARD)
 
+static const struct ide_port_ops hpt3xx_port_ops = {
+        .set_pio_mode           = hpt3xx_set_pio_mode,
+        .set_dma_mode           = hpt3xx_set_mode,
+        .quirkproc              = hpt3xx_quirkproc,
+        .maskproc               = hpt3xx_maskproc,
+        .mdma_filter            = hpt3xx_mdma_filter,
+        .udma_filter            = hpt3xx_udma_filter,
+        .cable_detect           = hpt3xx_cable_detect,
+};
+
+static const struct ide_dma_ops hpt37x_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = hpt374_dma_end,
+        .dma_test_irq           = hpt374_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
+static const struct ide_dma_ops hpt370_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = hpt370_dma_start,
+        .dma_end                = hpt370_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = hpt370_dma_timeout,
+};
+
+static const struct ide_dma_ops hpt36x_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = hpt366_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "HPT36x",
@@ -1429,7 +1461,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                  * Bit 4 is for the primary channel, bit 5 for the secondary.
                  */
                 .enablebits     = {{0x50,0x10,0x10}, {0x54,0x04,0x04}},
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt36x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX | IDE_HFLAG_SINGLE,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1439,7 +1472,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt37x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1449,7 +1483,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt37x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1459,7 +1494,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt37x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1470,7 +1506,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_hpt366,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = ATA_UDMA5,
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt37x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1480,7 +1517,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
-                .extra          = 240,
+                .port_ops       = &hpt3xx_port_ops,
+                .dma_ops        = &hpt37x_dma_ops,
                 .host_flags     = IDE_HFLAGS_HPT3XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -1543,6 +1581,10 @@ static int __devinit hpt366_init_one(struct pci_dev *dev, const struct pci_devic
         d.name = info->chip_name;
         d.udma_mask = info->udma_mask;
 
+        /* fixup ->dma_ops for HPT370/HPT370A */
+        if (info == &hpt370 || info == &hpt370a)
+                d.dma_ops = &hpt370_dma_ops;
+
         pci_set_drvdata(dev, (void *)info);
 
         if (info == &hpt36x || info == &hpt374)
@@ -1557,7 +1599,7 @@ static int __devinit hpt366_init_one(struct pci_dev *dev, const struct pci_devic
                         hpt374_init(dev, dev2);
                 else {
                         if (hpt36x_init(dev, dev2))
-                                d.host_flags |= IDE_HFLAG_BOOTABLE;
+                                d.host_flags &= ~IDE_HFLAG_NON_BOOTABLE;
                 }
 
                 ret = ide_setup_pci_devices(dev, dev2, &d);
diff --git a/drivers/ide/pci/it8213.c b/drivers/ide/pci/it8213.c
index e3427eaab430..9053c8771e6e 100644
--- a/drivers/ide/pci/it8213.c
+++ b/drivers/ide/pci/it8213.c
@@ -35,7 +35,7 @@ static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
         static DEFINE_SPINLOCK(tune_lock);
         int control = 0;
 
-        static const u8 timings[][2]= {
+        static const u8 timings[][2] = {
                                         { 0, 0 },
                                         { 0, 0 },
                                         { 1, 0 },
@@ -105,11 +105,10 @@ static void it8213_set_dma_mode(ide_drive_t *drive, const u8 speed)
 
                 if (!(reg48 & u_flag))
                         pci_write_config_byte(dev, 0x48, reg48 | u_flag);
-                if (speed >= XFER_UDMA_5) {
+                if (speed >= XFER_UDMA_5)
                         pci_write_config_byte(dev, 0x55, (u8) reg55|w_flag);
-                } else {
+                else
                         pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
-                }
 
                 if ((reg4a & a_speed) != u_speed)
                         pci_write_config_word(dev, 0x4a, (reg4a & ~a_speed) | u_speed);
@@ -150,29 +149,18 @@ static u8 __devinit it8213_cable_detect(ide_hwif_t *hwif)
         return (reg42h & 0x02) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
 }
 
-/**
- *      init_hwif_it8213        -       set up hwif structs
- *      @hwif: interface to set up
- *
- *      We do the basic set up of the interface structure.
- */
-
-static void __devinit init_hwif_it8213(ide_hwif_t *hwif)
-{
-        hwif->set_dma_mode = &it8213_set_dma_mode;
-        hwif->set_pio_mode = &it8213_set_pio_mode;
-
-        hwif->cable_detect = it8213_cable_detect;
-}
-
+static const struct ide_port_ops it8213_port_ops = {
+        .set_pio_mode           = it8213_set_pio_mode,
+        .set_dma_mode           = it8213_set_dma_mode,
+        .cable_detect           = it8213_cable_detect,
+};
 
 #define DECLARE_ITE_DEV(name_str)                       \
         {                                               \
                 .name           = name_str,             \
-                .init_hwif      = init_hwif_it8213,     \
-                .enablebits     = {{0x41,0x80,0x80}}, \
-                .host_flags     = IDE_HFLAG_SINGLE |    \
-                                  IDE_HFLAG_BOOTABLE,   \
+                .enablebits     = { {0x41, 0x80, 0x80} }, \
+                .port_ops       = &it8213_port_ops,     \
+                .host_flags     = IDE_HFLAG_SINGLE,     \
                 .pio_mask       = ATA_PIO4,             \
                 .swdma_mask     = ATA_SWDMA2_ONLY,      \
                 .mwdma_mask     = ATA_MWDMA12_ONLY,     \
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index d8a167451fd6..6ab04115286b 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -418,7 +418,7 @@ static void it821x_set_dma_mode(ide_drive_t *drive, const u8 speed)
 }
 
 /**
- *      ata66_it821x    -       check for 80 pin cable
+ *      it821x_cable_detect     -       cable detection
  *      @hwif: interface to check
  *
  *      Check for the presence of an ATA66 capable cable on the
@@ -426,7 +426,7 @@ static void it821x_set_dma_mode(ide_drive_t *drive, const u8 speed)
  *      the needed logic onboard.
  */
 
-static u8 __devinit ata66_it821x(ide_hwif_t *hwif)
+static u8 __devinit it821x_cable_detect(ide_hwif_t *hwif)
 {
         /* The reference driver also only does disk side */
         return ATA_CBL_PATA80;
@@ -511,6 +511,11 @@ static void __devinit it821x_quirkproc(ide_drive_t *drive)
 
 }
 
+static struct ide_dma_ops it821x_pass_through_dma_ops = {
+        .dma_start              = it821x_dma_start,
+        .dma_end                = it821x_dma_end,
+};
+
 /**
  *      init_hwif_it821x        -       set up hwif structs
  *      @hwif: interface to set up
@@ -523,16 +528,10 @@ static void __devinit it821x_quirkproc(ide_drive_t *drive)
 static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
-        struct it821x_dev *idev = kzalloc(sizeof(struct it821x_dev), GFP_KERNEL);
+        struct it821x_dev **itdevs = (struct it821x_dev **)pci_get_drvdata(dev);
+        struct it821x_dev *idev = itdevs[hwif->channel];
         u8 conf;
 
-        hwif->quirkproc = &it821x_quirkproc;
-
-        if (idev == NULL) {
-                printk(KERN_ERR "it821x: out of memory, falling back to legacy behaviour.\n");
-                return;
-        }
-
         ide_set_hwifdata(hwif, idev);
 
         pci_read_config_byte(dev, 0x50, &conf);
@@ -567,17 +566,11 @@ static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
         }
 
         if (idev->smart == 0) {
-                hwif->set_pio_mode = &it821x_set_pio_mode;
-                hwif->set_dma_mode = &it821x_set_dma_mode;
-
                 /* MWDMA/PIO clock switching for pass through mode */
-                hwif->dma_start = &it821x_dma_start;
-                hwif->ide_dma_end = &it821x_dma_end;
+                hwif->dma_ops = &it821x_pass_through_dma_ops;
         } else
                 hwif->host_flags |= IDE_HFLAG_NO_SET_MODE;
 
-        hwif->cable_detect = ata66_it821x;
-
         if (hwif->dma_base == 0)
                 return;
 
@@ -617,13 +610,20 @@ static unsigned int __devinit init_chipset_it821x(struct pci_dev *dev, const cha
         return 0;
 }
 
+static const struct ide_port_ops it821x_port_ops = {
+        /* it821x_set_{pio,dma}_mode() are only used in pass-through mode */
+        .set_pio_mode           = it821x_set_pio_mode,
+        .set_dma_mode           = it821x_set_dma_mode,
+        .quirkproc              = it821x_quirkproc,
+        .cable_detect           = it821x_cable_detect,
+};
 
 #define DECLARE_ITE_DEV(name_str)                       \
         {                                               \
                 .name           = name_str,             \
                 .init_chipset   = init_chipset_it821x,  \
                 .init_hwif      = init_hwif_it821x,     \
-                .host_flags     = IDE_HFLAG_BOOTABLE,   \
+                .port_ops       = &it821x_port_ops,     \
                 .pio_mask       = ATA_PIO4,             \
         }
 
@@ -642,6 +642,22 @@ static const struct ide_port_info it821x_chipsets[] __devinitdata = {
 
 static int __devinit it821x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
+        struct it821x_dev *itdevs[2] = { NULL, NULL} , *itdev;
+        unsigned int i;
+
+        for (i = 0; i < 2; i++) {
+                itdev = kzalloc(sizeof(*itdev), GFP_KERNEL);
+                if (itdev == NULL) {
+                        kfree(itdevs[0]);
+                        printk(KERN_ERR "it821x: out of memory\n");
+                        return -ENOMEM;
+                }
+
+                itdevs[i] = itdev;
+        }
+
+        pci_set_drvdata(dev, itdevs);
+
         return ide_setup_pci_device(dev, &it821x_chipsets[id->driver_data]);
 }
 
diff --git a/drivers/ide/pci/jmicron.c b/drivers/ide/pci/jmicron.c
index a56bcb4f22f4..96ef7394f283 100644
--- a/drivers/ide/pci/jmicron.c
+++ b/drivers/ide/pci/jmicron.c
@@ -19,13 +19,13 @@ typedef enum {
 } port_type;
 
 /**
- *      ata66_jmicron           -       Cable check
+ *      jmicron_cable_detect    -       cable detection
  *      @hwif: IDE port
  *
  *      Returns the cable type.
  */
 
-static u8 __devinit ata66_jmicron(ide_hwif_t *hwif)
+static u8 __devinit jmicron_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *pdev = to_pci_dev(hwif->dev);
 
@@ -63,8 +63,7 @@ static u8 __devinit ata66_jmicron(ide_hwif_t *hwif)
          *      actually do our cable checking etc. Thankfully we don't need
          *      to do the plumbing for other cases.
          */
-        switch (port_map[port])
-        {
+        switch (port_map[port]) {
         case PORT_PATA0:
                 if (control & (1 << 3)) /* 40/80 pin primary */
                         return ATA_CBL_PATA40;
@@ -96,26 +95,16 @@ static void jmicron_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
 }
 
-/**
- *      init_hwif_jmicron       -       set up hwif structs
- *      @hwif: interface to set up
- *
- *      Minimal set up is required for the Jmicron hardware.
- */
-
-static void __devinit init_hwif_jmicron(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &jmicron_set_pio_mode;
-        hwif->set_dma_mode = &jmicron_set_dma_mode;
-
-        hwif->cable_detect = ata66_jmicron;
-}
+static const struct ide_port_ops jmicron_port_ops = {
+        .set_pio_mode           = jmicron_set_pio_mode,
+        .set_dma_mode           = jmicron_set_dma_mode,
+        .cable_detect           = jmicron_cable_detect,
+};
 
 static const struct ide_port_info jmicron_chipset __devinitdata = {
         .name           = "JMB",
-        .init_hwif      = init_hwif_jmicron,
-        .host_flags     = IDE_HFLAG_BOOTABLE,
         .enablebits     = { { 0x40, 0x01, 0x01 }, { 0x40, 0x10, 0x10 } },
+        .port_ops       = &jmicron_port_ops,
         .pio_mask       = ATA_PIO5,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ide/pci/ns87415.c b/drivers/ide/pci/ns87415.c
index 75513320aad9..c13e299077ec 100644
--- a/drivers/ide/pci/ns87415.c
+++ b/drivers/ide/pci/ns87415.c
@@ -72,8 +72,8 @@ static void __devinit superio_ide_init_iops (struct hwif_s *hwif)
         base = pci_resource_start(pdev, port * 2) & ~3;
         dmabase = pci_resource_start(pdev, 4) & ~3;
 
-        superio_ide_status[port] = base + IDE_STATUS_OFFSET;
-        superio_ide_select[port] = base + IDE_SELECT_OFFSET;
+        superio_ide_status[port] = base + 7;
+        superio_ide_select[port] = base + 6;
         superio_ide_dma_status[port] = dmabase + (!port ? 2 : 0xa);
 
         /* Clear error/interrupt, enable dma */
@@ -150,7 +150,7 @@ static void ns87415_selectproc (ide_drive_t *drive)
         ns87415_prepare_drive (drive, drive->using_dma);
 }
 
-static int ns87415_ide_dma_end (ide_drive_t *drive)
+static int ns87415_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t      *hwif = HWIF(drive);
         u8 dma_stat = 0, dma_cmd = 0;
@@ -170,7 +170,7 @@ static int ns87415_ide_dma_end (ide_drive_t *drive)
         return (dma_stat & 7) != 4;
 }
 
-static int ns87415_ide_dma_setup(ide_drive_t *drive)
+static int ns87415_dma_setup(ide_drive_t *drive)
 {
         /* select DMA xfer */
         ns87415_prepare_drive(drive, 1);
@@ -195,8 +195,6 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
         u8 stat;
 #endif
 
-        hwif->selectproc = &ns87415_selectproc;
-
         /*
          * We cannot probe for IRQ: both ports share common IRQ on INTA.
          * Also, leave IRQ masked during drive probing, to prevent infinite
@@ -233,12 +231,12 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
                  *      SELECT_DRIVE() properly during first ide_probe_port().
                  */
                 timeout = 10000;
-                outb(12, hwif->io_ports[IDE_CONTROL_OFFSET]);
+                outb(12, hwif->io_ports.ctl_addr);
                 udelay(10);
-                outb(8, hwif->io_ports[IDE_CONTROL_OFFSET]);
+                outb(8, hwif->io_ports.ctl_addr);
                 do {
                         udelay(50);
-                        stat = hwif->INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                        stat = hwif->INB(hwif->io_ports.status_addr);
                         if (stat == 0xff)
                                 break;
                 } while ((stat & BUSY_STAT) && --timeout);
@@ -246,7 +244,7 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
         }
 
         if (!using_inta)
-                hwif->irq = ide_default_irq(hwif->io_ports[IDE_DATA_OFFSET]);
+                hwif->irq = ide_default_irq(hwif->io_ports.data_addr);
         else if (!hwif->irq && hwif->mate && hwif->mate->irq)
                 hwif->irq = hwif->mate->irq;    /* share IRQ with mate */
 
@@ -254,19 +252,33 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
                 return;
 
         outb(0x60, hwif->dma_status);
-        hwif->dma_setup = &ns87415_ide_dma_setup;
-        hwif->ide_dma_end = &ns87415_ide_dma_end;
 }
 
+static const struct ide_port_ops ns87415_port_ops = {
+        .selectproc             = ns87415_selectproc,
+};
+
+static const struct ide_dma_ops ns87415_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ns87415_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = ns87415_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 static const struct ide_port_info ns87415_chipset __devinitdata = {
         .name           = "NS87415",
 #ifdef CONFIG_SUPERIO
         .init_iops      = init_iops_ns87415,
 #endif
         .init_hwif      = init_hwif_ns87415,
+        .port_ops       = &ns87415_port_ops,
+        .dma_ops        = &ns87415_dma_ops,
         .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA |
-                          IDE_HFLAG_NO_ATAPI_DMA |
-                          IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_NO_ATAPI_DMA,
 };
 
 static int __devinit ns87415_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/opti621.c b/drivers/ide/pci/opti621.c
index 46e8748f507e..6e99080497bf 100644
--- a/drivers/ide/pci/opti621.c
+++ b/drivers/ide/pci/opti621.c
@@ -53,13 +53,12 @@
  * If you then set the second drive to another PIO, the old value
  * (automatically selected) will be overrided by yours.
  * There is a 25/33MHz switch in configuration
- * register, but driver is written for use at any frequency which get
- * (use idebus=xx to select PCI bus speed).
+ * register, but driver is written for use at any frequency.
  *
  * Version 0.1, Nov 8, 1996
- * by Jaromir Koutek, for 2.1.8. 
+ * by Jaromir Koutek, for 2.1.8.
  * Initial version of driver.
- * 
+ *
  * Version 0.2
  * Number 0.2 skipped.
  *
@@ -75,7 +74,7 @@
  * by Jaromir Koutek
  * Updates for use with (again) new IDE block driver.
  * Update of documentation.
- * 
+ *
  * Version 0.6, Jan 2, 1999
  * by Jaromir Koutek
  * Reversed to version 0.3 of the driver, because
@@ -208,29 +207,34 @@ typedef struct pio_clocks_s {
 
 static void compute_clocks(int pio, pio_clocks_t *clks)
 {
-        if (pio != PIO_NOT_EXIST) {
-                int adr_setup, data_pls;
-                int bus_speed = system_bus_clock();
-
-                adr_setup = ide_pio_timings[pio].setup_time;
-                data_pls = ide_pio_timings[pio].active_time;
-                clks->address_time = cmpt_clk(adr_setup, bus_speed);
-                clks->data_time = cmpt_clk(data_pls, bus_speed);
-                clks->recovery_time = cmpt_clk(ide_pio_timings[pio].cycle_time
-                        - adr_setup-data_pls, bus_speed);
-                if (clks->address_time<1) clks->address_time = 1;
-                if (clks->address_time>4) clks->address_time = 4;
-                if (clks->data_time<1) clks->data_time = 1;
-                if (clks->data_time>16) clks->data_time = 16;
-                if (clks->recovery_time<2) clks->recovery_time = 2;
-                if (clks->recovery_time>17) clks->recovery_time = 17;
+        if (pio != PIO_NOT_EXIST) {
+                int adr_setup, data_pls;
+                int bus_speed = ide_pci_clk ? ide_pci_clk : system_bus_clock();
+
+                adr_setup = ide_pio_timings[pio].setup_time;
+                data_pls = ide_pio_timings[pio].active_time;
+                clks->address_time = cmpt_clk(adr_setup, bus_speed);
+                clks->data_time = cmpt_clk(data_pls, bus_speed);
+                clks->recovery_time = cmpt_clk(ide_pio_timings[pio].cycle_time
+                        - adr_setup-data_pls, bus_speed);
+                if (clks->address_time < 1)
+                        clks->address_time = 1;
+                if (clks->address_time > 4)
+                        clks->address_time = 4;
+                if (clks->data_time < 1)
+                        clks->data_time = 1;
+                if (clks->data_time > 16)
+                        clks->data_time = 16;
+                if (clks->recovery_time < 2)
+                        clks->recovery_time = 2;
+                if (clks->recovery_time > 17)
+                        clks->recovery_time = 17;
         } else {
                 clks->address_time = 1;
                 clks->data_time = 1;
                 clks->recovery_time = 2;
                 /* minimal values */
         }
- 
 }
 
 static void opti621_set_pio_mode(ide_drive_t *drive, const u8 pio)
@@ -247,8 +251,8 @@ static void opti621_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
         /* sets drive->drive_data for both drives */
         compute_pios(drive, pio);
-        pio1 = hwif->drives[0].drive_data;
-        pio2 = hwif->drives[1].drive_data;
+        pio1 = hwif->drives[0].drive_data;
+        pio2 = hwif->drives[1].drive_data;
 
         compute_clocks(pio1, &first);
         compute_clocks(pio2, &second);
@@ -275,7 +279,7 @@ static void opti621_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
         spin_lock_irqsave(&opti621_lock, flags);
 
-        reg_base = hwif->io_ports[IDE_DATA_OFFSET];
+        reg_base = hwif->io_ports.data_addr;
 
         /* allow Register-B */
         outb(0xc0, reg_base + CNTRL_REG);
@@ -321,31 +325,25 @@ static void __devinit opti621_port_init_devs(ide_hwif_t *hwif)
         hwif->drives[1].drive_data = PIO_DONT_KNOW;
 }
 
-/*
- * init_hwif_opti621() is called once for each hwif found at boot.
- */
-static void __devinit init_hwif_opti621 (ide_hwif_t *hwif)
-{
-        hwif->port_init_devs = opti621_port_init_devs;
-        hwif->set_pio_mode = &opti621_set_pio_mode;
-}
+static const struct ide_port_ops opti621_port_ops = {
+        .port_init_devs         = opti621_port_init_devs,
+        .set_pio_mode           = opti621_set_pio_mode,
+};
 
 static const struct ide_port_info opti621_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "OPTI621",
-                .init_hwif      = init_hwif_opti621,
-                .enablebits     = {{0x45,0x80,0x00}, {0x40,0x08,0x00}},
-                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA |
-                                  IDE_HFLAG_BOOTABLE,
+                .enablebits     = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} },
+                .port_ops       = &opti621_port_ops,
+                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA,
                 .pio_mask       = ATA_PIO3,
                 .swdma_mask     = ATA_SWDMA2,
                 .mwdma_mask     = ATA_MWDMA2,
-        },{     /* 1 */
+        }, {    /* 1 */
                 .name           = "OPTI621X",
-                .init_hwif      = init_hwif_opti621,
-                .enablebits     = {{0x45,0x80,0x00}, {0x40,0x08,0x00}},
-                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA |
-                                  IDE_HFLAG_BOOTABLE,
+                .enablebits     = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} },
+                .port_ops       = &opti621_port_ops,
+                .host_flags     = IDE_HFLAG_TRUST_BIOS_FOR_DMA,
                 .pio_mask       = ATA_PIO3,
                 .swdma_mask     = ATA_SWDMA2,
                 .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index 1c8cb7797a4a..ec9bd7b352fc 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -34,7 +34,7 @@
 #undef DEBUG
 
 #ifdef DEBUG
-#define DBG(fmt, args...) printk("%s: " fmt, __FUNCTION__, ## args)
+#define DBG(fmt, args...) printk("%s: " fmt, __func__, ## args)
 #else
 #define DBG(fmt, args...)
 #endif
@@ -442,17 +442,6 @@ static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const cha
         return dev->irq;
 }
 
-static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &pdcnew_set_pio_mode;
-        hwif->set_dma_mode = &pdcnew_set_dma_mode;
-
-        hwif->quirkproc = &pdcnew_quirkproc;
-        hwif->resetproc = &pdcnew_reset;
-
-        hwif->cable_detect = pdcnew_cable_detect;
-}
-
 static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
 {
         struct pci_dev *dev2;
@@ -476,11 +465,19 @@ static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
         return NULL;
 }
 
+static const struct ide_port_ops pdcnew_port_ops = {
+        .set_pio_mode           = pdcnew_set_pio_mode,
+        .set_dma_mode           = pdcnew_set_dma_mode,
+        .quirkproc              = pdcnew_quirkproc,
+        .resetproc              = pdcnew_reset,
+        .cable_detect           = pdcnew_cable_detect,
+};
+
 #define DECLARE_PDCNEW_DEV(name_str, udma) \
         { \
                 .name           = name_str, \
                 .init_chipset   = init_chipset_pdcnew, \
-                .init_hwif      = init_hwif_pdc202new, \
+                .port_ops       = &pdcnew_port_ops, \
                 .host_flags     = IDE_HFLAG_POST_SET_MODE | \
                                   IDE_HFLAG_ERROR_STOPS_FIFO | \
                                   IDE_HFLAG_OFF_BOARD, \
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index 150422ec3cfa..fca89eda5c02 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -115,7 +115,7 @@ static void pdc202xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
         pdc202xx_set_mode(drive, XFER_PIO_0 + pio);
 }
 
-static u8 __devinit pdc2026x_old_cable_detect(ide_hwif_t *hwif)
+static u8 __devinit pdc2026x_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         u16 CIS, mask = hwif->channel ? (1 << 11) : (1 << 10);
@@ -163,7 +163,7 @@ static void pdc202xx_quirkproc(ide_drive_t *drive)
         drive->quirk_list = 0;
 }
 
-static void pdc202xx_old_ide_dma_start(ide_drive_t *drive)
+static void pdc202xx_dma_start(ide_drive_t *drive)
 {
         if (drive->current_speed > XFER_UDMA_2)
                 pdc_old_enable_66MHz_clock(drive->hwif);
@@ -185,7 +185,7 @@ static void pdc202xx_old_ide_dma_start(ide_drive_t *drive)
         ide_dma_start(drive);
 }
 
-static int pdc202xx_old_ide_dma_end(ide_drive_t *drive)
+static int pdc202xx_dma_end(ide_drive_t *drive)
 {
         if (drive->media != ide_disk || drive->addressing == 1) {
                 ide_hwif_t *hwif        = HWIF(drive);
@@ -202,7 +202,7 @@ static int pdc202xx_old_ide_dma_end(ide_drive_t *drive)
         return __ide_dma_end(drive);
 }
 
-static int pdc202xx_old_ide_dma_test_irq(ide_drive_t *drive)
+static int pdc202xx_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long high_16   = hwif->extra_base - 16;
@@ -226,26 +226,6 @@ somebody_else:
         return (dma_stat & 4) == 4;     /* return 1 if INTR asserted */
 }
 
-static void pdc202xx_dma_lost_irq(ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = HWIF(drive);
-
-        if (hwif->resetproc != NULL)
-                hwif->resetproc(drive);
-
-        ide_dma_lost_irq(drive);
-}
-
-static void pdc202xx_dma_timeout(ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = HWIF(drive);
-
-        if (hwif->resetproc != NULL)
-                hwif->resetproc(drive);
-
-        ide_dma_timeout(drive);
-}
-
 static void pdc202xx_reset_host (ide_hwif_t *hwif)
 {
         unsigned long high_16   = hwif->extra_base - 16;
@@ -271,68 +251,46 @@ static void pdc202xx_reset (ide_drive_t *drive)
         ide_set_max_pio(drive);
 }
 
-static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
-                                                        const char *name)
+static void pdc202xx_dma_lost_irq(ide_drive_t *drive)
 {
-        return dev->irq;
+        pdc202xx_reset(drive);
+        ide_dma_lost_irq(drive);
 }
 
-static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif)
+static void pdc202xx_dma_timeout(ide_drive_t *drive)
 {
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-
-        hwif->set_pio_mode = &pdc202xx_set_pio_mode;
-        hwif->set_dma_mode = &pdc202xx_set_mode;
-
-        hwif->quirkproc = &pdc202xx_quirkproc;
-
-        if (dev->device != PCI_DEVICE_ID_PROMISE_20246) {
-                hwif->resetproc = &pdc202xx_reset;
-
-                hwif->cable_detect = pdc2026x_old_cable_detect;
-        }
-
-        if (hwif->dma_base == 0)
-                return;
-
-        hwif->dma_lost_irq = &pdc202xx_dma_lost_irq;
-        hwif->dma_timeout = &pdc202xx_dma_timeout;
-
-        if (dev->device != PCI_DEVICE_ID_PROMISE_20246) {
-                hwif->dma_start = &pdc202xx_old_ide_dma_start;
-                hwif->ide_dma_end = &pdc202xx_old_ide_dma_end;
-        } 
-        hwif->ide_dma_test_irq = &pdc202xx_old_ide_dma_test_irq;
+        pdc202xx_reset(drive);
+        ide_dma_timeout(drive);
 }
 
-static void __devinit init_dma_pdc202xx(ide_hwif_t *hwif, unsigned long dmabase)
+static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
+                                                    const char *name)
 {
+        unsigned long dmabase = pci_resource_start(dev, 4);
         u8 udma_speed_flag = 0, primary_mode = 0, secondary_mode = 0;
 
-        if (hwif->channel) {
-                ide_setup_dma(hwif, dmabase);
-                return;
-        }
+        if (dmabase == 0)
+                goto out;
 
         udma_speed_flag = inb(dmabase | 0x1f);
         primary_mode    = inb(dmabase | 0x1a);
         secondary_mode  = inb(dmabase | 0x1b);
         printk(KERN_INFO "%s: (U)DMA Burst Bit %sABLED " \
                 "Primary %s Mode " \
-                "Secondary %s Mode.\n", hwif->cds->name,
+                "Secondary %s Mode.\n", pci_name(dev),
                 (udma_speed_flag & 1) ? "EN" : "DIS",
                 (primary_mode & 1) ? "MASTER" : "PCI",
                 (secondary_mode & 1) ? "MASTER" : "PCI" );
 
         if (!(udma_speed_flag & 1)) {
                 printk(KERN_INFO "%s: FORCING BURST BIT 0x%02x->0x%02x ",
-                        hwif->cds->name, udma_speed_flag,
+                        pci_name(dev), udma_speed_flag,
                         (udma_speed_flag|1));
                 outb(udma_speed_flag | 1, dmabase | 0x1f);
                 printk("%sACTIVE\n", (inb(dmabase | 0x1f) & 1) ? "" : "IN");
         }
-
-        ide_setup_dma(hwif, dmabase);
+out:
+        return dev->irq;
 }
 
 static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev,
@@ -357,13 +315,48 @@ static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev,
          IDE_HFLAG_ABUSE_SET_DMA_MODE | \
          IDE_HFLAG_OFF_BOARD)
 
+static const struct ide_port_ops pdc20246_port_ops = {
+        .set_pio_mode           = pdc202xx_set_pio_mode,
+        .set_dma_mode           = pdc202xx_set_mode,
+        .quirkproc              = pdc202xx_quirkproc,
+};
+
+static const struct ide_port_ops pdc2026x_port_ops = {
+        .set_pio_mode           = pdc202xx_set_pio_mode,
+        .set_dma_mode           = pdc202xx_set_mode,
+        .quirkproc              = pdc202xx_quirkproc,
+        .resetproc              = pdc202xx_reset,
+        .cable_detect           = pdc2026x_cable_detect,
+};
+
+static const struct ide_dma_ops pdc20246_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = pdc202xx_dma_test_irq,
+        .dma_lost_irq           = pdc202xx_dma_lost_irq,
+        .dma_timeout            = pdc202xx_dma_timeout,
+};
+
+static const struct ide_dma_ops pdc2026x_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = pdc202xx_dma_start,
+        .dma_end                = pdc202xx_dma_end,
+        .dma_test_irq           = pdc202xx_dma_test_irq,
+        .dma_lost_irq           = pdc202xx_dma_lost_irq,
+        .dma_timeout            = pdc202xx_dma_timeout,
+};
+
 #define DECLARE_PDC2026X_DEV(name_str, udma, extra_flags) \
         { \
                 .name           = name_str, \
                 .init_chipset   = init_chipset_pdc202xx, \
-                .init_hwif      = init_hwif_pdc202xx, \
-                .init_dma       = init_dma_pdc202xx, \
-                .extra          = 48, \
+                .port_ops       = &pdc2026x_port_ops, \
+                .dma_ops        = &pdc2026x_dma_ops, \
                 .host_flags     = IDE_HFLAGS_PDC202XX | extra_flags, \
                 .pio_mask       = ATA_PIO4, \
                 .mwdma_mask     = ATA_MWDMA2, \
@@ -374,9 +367,8 @@ static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "PDC20246",
                 .init_chipset   = init_chipset_pdc202xx,
-                .init_hwif      = init_hwif_pdc202xx,
-                .init_dma       = init_dma_pdc202xx,
-                .extra          = 16,
+                .port_ops       = &pdc20246_port_ops,
+                .dma_ops        = &pdc20246_dma_ops,
                 .host_flags     = IDE_HFLAGS_PDC202XX,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ide/pci/piix.c b/drivers/ide/pci/piix.c
index decef0f47674..21c5dd23f928 100644
--- a/drivers/ide/pci/piix.c
+++ b/drivers/ide/pci/piix.c
@@ -285,11 +285,6 @@ static u8 __devinit piix_cable_detect(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_piix(ide_hwif_t *hwif)
 {
-        hwif->set_pio_mode = &piix_set_pio_mode;
-        hwif->set_dma_mode = &piix_set_dma_mode;
-
-        hwif->cable_detect = piix_cable_detect;
-
         if (!hwif->dma_base)
                 return;
 
@@ -306,10 +301,16 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
                 hwif->ide_dma_clear_irq = &piix_dma_clear_irq;
 }
 
+static const struct ide_port_ops piix_port_ops = {
+        .set_pio_mode           = piix_set_pio_mode,
+        .set_dma_mode           = piix_set_dma_mode,
+        .cable_detect           = piix_cable_detect,
+};
+
 #ifndef CONFIG_IA64
- #define IDE_HFLAGS_PIIX (IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_BOOTABLE)
+ #define IDE_HFLAGS_PIIX IDE_HFLAG_LEGACY_IRQS
 #else
- #define IDE_HFLAGS_PIIX IDE_HFLAG_BOOTABLE
+ #define IDE_HFLAGS_PIIX 0
 #endif
 
 #define DECLARE_PIIX_DEV(name_str, udma) \
@@ -317,6 +318,7 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
                 .name           = name_str,             \
                 .init_hwif      = init_hwif_piix,       \
                 .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
+                .port_ops       = &piix_port_ops,       \
                 .host_flags     = IDE_HFLAGS_PIIX,      \
                 .pio_mask       = ATA_PIO4,             \
                 .swdma_mask     = ATA_SWDMA2_ONLY,      \
@@ -330,6 +332,7 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
                 .init_chipset   = init_chipset_ich, \
                 .init_hwif      = init_hwif_ich, \
                 .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
+                .port_ops       = &piix_port_ops, \
                 .host_flags     = IDE_HFLAGS_PIIX, \
                 .pio_mask       = ATA_PIO4, \
                 .swdma_mask     = ATA_SWDMA2_ONLY, \
diff --git a/drivers/ide/pci/rz1000.c b/drivers/ide/pci/rz1000.c
index 51676612f78f..532154adba29 100644
--- a/drivers/ide/pci/rz1000.c
+++ b/drivers/ide/pci/rz1000.c
@@ -43,7 +43,7 @@ static const struct ide_port_info rz1000_chipset __devinitdata = {
         .name           = "RZ100x",
         .init_hwif      = init_hwif_rz1000,
         .chipset        = ide_rz1000,
-        .host_flags     = IDE_HFLAG_NO_DMA | IDE_HFLAG_BOOTABLE,
+        .host_flags     = IDE_HFLAG_NO_DMA,
 };
 
 static int __devinit rz1000_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/sc1200.c b/drivers/ide/pci/sc1200.c
index 561aa47c7720..14c787b5d95f 100644
--- a/drivers/ide/pci/sc1200.c
+++ b/drivers/ide/pci/sc1200.c
@@ -165,7 +165,7 @@ static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
  *
  *  returns 1 on error, 0 otherwise
  */
-static int sc1200_ide_dma_end (ide_drive_t *drive)
+static int sc1200_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
         unsigned long dma_base = hwif->dma_base;
@@ -214,7 +214,7 @@ static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 printk("SC1200: %s: changing (U)DMA mode\n", drive->name);
                 ide_dma_off_quietly(drive);
                 if (ide_set_dma_mode(drive, mode) == 0 && drive->using_dma)
-                        hwif->dma_host_set(drive, 1);
+                        hwif->dma_ops->dma_host_set(drive, 1);
                 return;
         }
 
@@ -286,29 +286,30 @@ static int sc1200_resume (struct pci_dev *dev)
 }
 #endif
 
-/*
- * This gets invoked by the IDE driver once for each channel,
- * and performs channel-specific pre-initialization before drive probing.
- */
-static void __devinit init_hwif_sc1200 (ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &sc1200_set_pio_mode;
-        hwif->set_dma_mode = &sc1200_set_dma_mode;
-
-        if (hwif->dma_base == 0)
-                return;
+static const struct ide_port_ops sc1200_port_ops = {
+        .set_pio_mode           = sc1200_set_pio_mode,
+        .set_dma_mode           = sc1200_set_dma_mode,
+        .udma_filter            = sc1200_udma_filter,
+};
 
-        hwif->udma_filter = sc1200_udma_filter;
-        hwif->ide_dma_end   = &sc1200_ide_dma_end;
-}
+static const struct ide_dma_ops sc1200_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = sc1200_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
 static const struct ide_port_info sc1200_chipset __devinitdata = {
         .name           = "SC1200",
-        .init_hwif      = init_hwif_sc1200,
+        .port_ops       = &sc1200_port_ops,
+        .dma_ops        = &sc1200_dma_ops,
         .host_flags     = IDE_HFLAG_SERIALIZE |
                           IDE_HFLAG_POST_SET_MODE |
-                          IDE_HFLAG_ABUSE_DMA_MODES |
-                          IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_ABUSE_DMA_MODES,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA2,
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index ef07c7a8b97a..ad7cdf9060ca 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -65,7 +65,7 @@
 
 static struct scc_ports {
         unsigned long ctl, dma;
-        unsigned char hwif_id;  /* for removing hwif from system */
+        ide_hwif_t *hwif;  /* for removing port from system */
 } scc_ports[MAX_HWIFS];
 
 /* PIO transfer mode  table */
@@ -317,14 +317,14 @@ static int scc_dma_setup(ide_drive_t *drive)
 
 
 /**
- *      scc_ide_dma_end -       Stop DMA
+ *      scc_dma_end     -       Stop DMA
  *      @drive: IDE drive
  *
  *      Check and clear INT Status register.
  *      Then call __ide_dma_end().
  */
 
-static int scc_ide_dma_end(ide_drive_t * drive)
+static int scc_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
         unsigned long intsts_port = hwif->dma_base + 0x014;
@@ -334,7 +334,7 @@ static int scc_ide_dma_end(ide_drive_t * drive)
 
         /* errata A308 workaround: Step5 (check data loss) */
         /* We don't check non ide_disk because it is limited to UDMA4 */
-        if (!(in_be32((void __iomem *)hwif->io_ports[IDE_ALTSTATUS_OFFSET])
+        if (!(in_be32((void __iomem *)hwif->io_ports.ctl_addr)
               & ERR_STAT) &&
             drive->media == ide_disk && drive->current_speed > XFER_UDMA_4) {
                 reg = in_be32((void __iomem *)intsts_port);
@@ -438,7 +438,7 @@ static int scc_dma_test_irq(ide_drive_t *drive)
         u32 int_stat = in_be32((void __iomem *)hwif->dma_base + 0x014);
 
         /* SCC errata A252,A308 workaround: Step4 */
-        if ((in_be32((void __iomem *)hwif->io_ports[IDE_ALTSTATUS_OFFSET])
+        if ((in_be32((void __iomem *)hwif->io_ports.ctl_addr)
              & ERR_STAT) &&
             (int_stat & INTSTS_INTRQ))
                 return 1;
@@ -449,7 +449,7 @@ static int scc_dma_test_irq(ide_drive_t *drive)
 
         if (!drive->waiting_for_dma)
                 printk(KERN_WARNING "%s: (%s) called while not waiting\n",
-                        drive->name, __FUNCTION__);
+                        drive->name, __func__);
         return 0;
 }
 
@@ -483,7 +483,7 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
         unsigned long dma_size = pci_resource_len(dev, 1);
         void __iomem *ctl_addr;
         void __iomem *dma_addr;
-        int i;
+        int i, ret;
 
         for (i = 0; i < MAX_HWIFS; i++) {
                 if (scc_ports[i].ctl == 0)
@@ -492,21 +492,17 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
         if (i >= MAX_HWIFS)
                 return -ENOMEM;
 
-        if (!request_mem_region(ctl_base, ctl_size, name)) {
-                printk(KERN_WARNING "%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME);
-                goto fail_0;
-        }
-
-        if (!request_mem_region(dma_base, dma_size, name)) {
-                printk(KERN_WARNING "%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME);
-                goto fail_1;
+        ret = pci_request_selected_regions(dev, (1 << 2) - 1, name);
+        if (ret < 0) {
+                printk(KERN_ERR "%s: can't reserve resources\n", name);
+                return ret;
         }
 
         if ((ctl_addr = ioremap(ctl_base, ctl_size)) == NULL)
-                goto fail_2;
+                goto fail_0;
 
         if ((dma_addr = ioremap(dma_base, dma_size)) == NULL)
-                goto fail_3;
+                goto fail_1;
 
         pci_set_master(dev);
         scc_ports[i].ctl = (unsigned long)ctl_addr;
@@ -515,12 +511,8 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
 
         return 1;
 
- fail_3:
-        iounmap(ctl_addr);
- fail_2:
-        release_mem_region(dma_base, dma_size);
  fail_1:
-        release_mem_region(ctl_base, ctl_size);
+        iounmap(ctl_addr);
  fail_0:
         return -ENOMEM;
 }
@@ -534,26 +526,21 @@ static int scc_ide_setup_pci_device(struct pci_dev *dev,
         u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
         int i;
 
-        for (i = 0; i < MAX_HWIFS; i++) {
-                hwif = &ide_hwifs[i];
-                if (hwif->chipset == ide_unknown)
-                        break; /* pick an unused entry */
-        }
-        if (i == MAX_HWIFS) {
+        hwif = ide_find_port();
+        if (hwif == NULL) {
                 printk(KERN_ERR "%s: too many IDE interfaces, "
                                 "no room in table\n", SCC_PATA_NAME);
                 return -ENOMEM;
         }
 
         memset(&hw, 0, sizeof(hw));
-        for (i = IDE_DATA_OFFSET; i <= IDE_CONTROL_OFFSET; i++)
-                hw.io_ports[i] = ports->dma + 0x20 + i * 4;
+        for (i = 0; i <= 8; i++)
+                hw.io_ports_array[i] = ports->dma + 0x20 + i * 4;
         hw.irq = dev->irq;
         hw.dev = &dev->dev;
         hw.chipset = ide_pci;
         ide_init_port_hw(hwif, &hw);
         hwif->dev = &dev->dev;
-        hwif->cds = d;
 
         idx[0] = hwif->index;
 
@@ -696,7 +683,7 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
 {
         struct scc_ports *ports = ide_get_hwifdata(hwif);
 
-        ports->hwif_id = hwif->index;
+        ports->hwif = hwif;
 
         hwif->dma_command = hwif->dma_base;
         hwif->dma_status = hwif->dma_base + 0x04;
@@ -705,28 +692,38 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
         /* PTERADD */
         out_be32((void __iomem *)(hwif->dma_base + 0x018), hwif->dmatable_dma);
 
-        hwif->dma_setup = scc_dma_setup;
-        hwif->ide_dma_end = scc_ide_dma_end;
-        hwif->set_pio_mode = scc_set_pio_mode;
-        hwif->set_dma_mode = scc_set_dma_mode;
-        hwif->ide_dma_test_irq = scc_dma_test_irq;
-        hwif->udma_filter = scc_udma_filter;
-
         if (in_be32((void __iomem *)(hwif->config_data + 0xff0)) & CCKCTRL_ATACLKOEN)
                 hwif->ultra_mask = ATA_UDMA6; /* 133MHz */
         else
                 hwif->ultra_mask = ATA_UDMA5; /* 100MHz */
-
-        hwif->cable_detect = scc_cable_detect;
 }
 
+static const struct ide_port_ops scc_port_ops = {
+        .set_pio_mode           = scc_set_pio_mode,
+        .set_dma_mode           = scc_set_dma_mode,
+        .udma_filter            = scc_udma_filter,
+        .cable_detect           = scc_cable_detect,
+};
+
+static const struct ide_dma_ops scc_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = scc_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = scc_dma_end,
+        .dma_test_irq           = scc_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 #define DECLARE_SCC_DEV(name_str)                       \
   {                                                     \
       .name             = name_str,                     \
       .init_iops        = init_iops_scc,                \
       .init_hwif        = init_hwif_scc,                \
-      .host_flags       = IDE_HFLAG_SINGLE |            \
-                          IDE_HFLAG_BOOTABLE,           \
+      .port_ops         = &scc_port_ops,                \
+      .dma_ops          = &scc_dma_ops,                 \
+      .host_flags       = IDE_HFLAG_SINGLE,             \
       .pio_mask         = ATA_PIO4,                     \
   }
 
@@ -758,11 +755,7 @@ static int __devinit scc_init_one(struct pci_dev *dev, const struct pci_device_i
 static void __devexit scc_remove(struct pci_dev *dev)
 {
         struct scc_ports *ports = pci_get_drvdata(dev);
-        ide_hwif_t *hwif = &ide_hwifs[ports->hwif_id];
-        unsigned long ctl_base = pci_resource_start(dev, 0);
-        unsigned long dma_base = pci_resource_start(dev, 1);
-        unsigned long ctl_size = pci_resource_len(dev, 0);
-        unsigned long dma_size = pci_resource_len(dev, 1);
+        ide_hwif_t *hwif = ports->hwif;
 
         if (hwif->dmatable_cpu) {
                 pci_free_consistent(dev, PRD_ENTRIES * PRD_BYTES,
@@ -770,13 +763,11 @@ static void __devexit scc_remove(struct pci_dev *dev)
                 hwif->dmatable_cpu = NULL;
         }
 
-        ide_unregister(hwif->index);
+        ide_unregister(hwif);
 
-        hwif->chipset = ide_unknown;
         iounmap((void*)ports->dma);
         iounmap((void*)ports->ctl);
-        release_mem_region(dma_base, dma_size);
-        release_mem_region(ctl_base, ctl_size);
+        pci_release_selected_regions(dev, (1 << 2) - 1);
         memset(ports, 0, sizeof(*ports));
 }
 
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index c11880b0709f..a1fb20826a5b 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -312,7 +312,7 @@ static u8 __devinit ata66_svwks_cobalt(ide_hwif_t *hwif)
         return ATA_CBL_PATA40;
 }
 
-static u8 __devinit ata66_svwks(ide_hwif_t *hwif)
+static u8 __devinit svwks_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
 
@@ -336,28 +336,28 @@ static u8 __devinit ata66_svwks(ide_hwif_t *hwif)
         return ATA_CBL_PATA40;
 }
 
-static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
-{
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-
-        hwif->set_pio_mode = &svwks_set_pio_mode;
-        hwif->set_dma_mode = &svwks_set_dma_mode;
-        hwif->udma_filter = &svwks_udma_filter;
+static const struct ide_port_ops osb4_port_ops = {
+        .set_pio_mode           = svwks_set_pio_mode,
+        .set_dma_mode           = svwks_set_dma_mode,
+        .udma_filter            = svwks_udma_filter,
+};
 
-        if (dev->device != PCI_DEVICE_ID_SERVERWORKS_OSB4IDE)
-                hwif->cable_detect = ata66_svwks;
-}
+static const struct ide_port_ops svwks_port_ops = {
+        .set_pio_mode           = svwks_set_pio_mode,
+        .set_dma_mode           = svwks_set_dma_mode,
+        .udma_filter            = svwks_udma_filter,
+        .cable_detect           = svwks_cable_detect,
+};
 
 #define IDE_HFLAGS_SVWKS \
         (IDE_HFLAG_LEGACY_IRQS | \
-         IDE_HFLAG_ABUSE_SET_DMA_MODE | \
-         IDE_HFLAG_BOOTABLE)
+         IDE_HFLAG_ABUSE_SET_DMA_MODE)
 
 static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "SvrWks OSB4",
                 .init_chipset   = init_chipset_svwks,
-                .init_hwif      = init_hwif_svwks,
+                .port_ops       = &osb4_port_ops,
                 .host_flags     = IDE_HFLAGS_SVWKS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -365,7 +365,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
         },{     /* 1 */
                 .name           = "SvrWks CSB5",
                 .init_chipset   = init_chipset_svwks,
-                .init_hwif      = init_hwif_svwks,
+                .port_ops       = &svwks_port_ops,
                 .host_flags     = IDE_HFLAGS_SVWKS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -373,7 +373,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
         },{     /* 2 */
                 .name           = "SvrWks CSB6",
                 .init_chipset   = init_chipset_svwks,
-                .init_hwif      = init_hwif_svwks,
+                .port_ops       = &svwks_port_ops,
                 .host_flags     = IDE_HFLAGS_SVWKS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -381,7 +381,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
         },{     /* 3 */
                 .name           = "SvrWks CSB6",
                 .init_chipset   = init_chipset_svwks,
-                .init_hwif      = init_hwif_svwks,
+                .port_ops       = &svwks_port_ops,
                 .host_flags     = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -389,7 +389,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
         },{     /* 4 */
                 .name           = "SvrWks HT1000",
                 .init_chipset   = init_chipset_svwks,
-                .init_hwif      = init_hwif_svwks,
+                .port_ops       = &svwks_port_ops,
                 .host_flags     = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -418,7 +418,7 @@ static int __devinit svwks_init_one(struct pci_dev *dev, const struct pci_device
         else if (idx == 2 || idx == 3) {
                 if ((PCI_FUNC(dev->devfn) & 1) == 0) {
                         if (pci_resource_start(dev, 0) != 0x01f1)
-                                d.host_flags &= ~IDE_HFLAG_BOOTABLE;
+                                d.host_flags |= IDE_HFLAG_NON_BOOTABLE;
                         d.host_flags |= IDE_HFLAG_SINGLE;
                 } else
                         d.host_flags &= ~IDE_HFLAG_SINGLE;
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index 9d1a3038af9b..63e28f4e6d3b 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -98,28 +98,28 @@ sgiioc4_init_hwif_ports(hw_regs_t * hw, unsigned long data_port,
         int i;
 
         /* Registers are word (32 bit) aligned */
-        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
-                hw->io_ports[i] = reg + i * 4;
+        for (i = 0; i <= 7; i++)
+                hw->io_ports_array[i] = reg + i * 4;
 
         if (ctrl_port)
-                hw->io_ports[IDE_CONTROL_OFFSET] = ctrl_port;
+                hw->io_ports.ctl_addr = ctrl_port;
 
         if (irq_port)
-                hw->io_ports[IDE_IRQ_OFFSET] = irq_port;
+                hw->io_ports.irq_addr = irq_port;
 }
 
 static void
 sgiioc4_maskproc(ide_drive_t * drive, int mask)
 {
         writeb(mask ? (drive->ctl | 2) : (drive->ctl & ~2),
-               (void __iomem *)drive->hwif->io_ports[IDE_CONTROL_OFFSET]);
+               (void __iomem *)drive->hwif->io_ports.ctl_addr);
 }
 
 static int
 sgiioc4_checkirq(ide_hwif_t * hwif)
 {
         unsigned long intr_addr =
-                hwif->io_ports[IDE_IRQ_OFFSET] + IOC4_INTR_REG * 4;
+                hwif->io_ports.irq_addr + IOC4_INTR_REG * 4;
 
         if ((u8)readl((void __iomem *)intr_addr) & 0x03)
                 return 1;
@@ -134,8 +134,8 @@ sgiioc4_clearirq(ide_drive_t * drive)
 {
         u32 intr_reg;
         ide_hwif_t *hwif = HWIF(drive);
-        unsigned long other_ir =
-            hwif->io_ports[IDE_IRQ_OFFSET] + (IOC4_INTR_REG << 2);
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        unsigned long other_ir = io_ports->irq_addr + (IOC4_INTR_REG << 2);
 
         /* Code to check for PCI error conditions */
         intr_reg = readl((void __iomem *)other_ir);
@@ -147,12 +147,12 @@ sgiioc4_clearirq(ide_drive_t * drive)
                  * a "clear" status if it got cleared.  If not, then spin
                  * for a bit trying to clear it.
                  */
-                u8 stat = sgiioc4_INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                u8 stat = sgiioc4_INB(io_ports->status_addr);
                 int count = 0;
-                stat = sgiioc4_INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                stat = sgiioc4_INB(io_ports->status_addr);
                 while ((stat & 0x80) && (count++ < 100)) {
                         udelay(1);
-                        stat = sgiioc4_INB(hwif->io_ports[IDE_STATUS_OFFSET]);
+                        stat = sgiioc4_INB(io_ports->status_addr);
                 }
 
                 if (intr_reg & 0x02) {
@@ -162,18 +162,18 @@ sgiioc4_clearirq(ide_drive_t * drive)
                             pci_stat_cmd_reg;
 
                         pci_err_addr_low =
-                                readl((void __iomem *)hwif->io_ports[IDE_IRQ_OFFSET]);
+                                readl((void __iomem *)io_ports->irq_addr);
                         pci_err_addr_high =
-                                readl((void __iomem *)(hwif->io_ports[IDE_IRQ_OFFSET] + 4));
+                                readl((void __iomem *)(io_ports->irq_addr + 4));
                         pci_read_config_dword(dev, PCI_COMMAND,
                                               &pci_stat_cmd_reg);
                         printk(KERN_ERR
                                "%s(%s) : PCI Bus Error when doing DMA:"
                                    " status-cmd reg is 0x%x\n",
-                               __FUNCTION__, drive->name, pci_stat_cmd_reg);
+                               __func__, drive->name, pci_stat_cmd_reg);
                         printk(KERN_ERR
                                "%s(%s) : PCI Error Address is 0x%x%x\n",
-                               __FUNCTION__, drive->name,
+                               __func__, drive->name,
                                pci_err_addr_high, pci_err_addr_low);
                         /* Clear the PCI Error indicator */
                         pci_write_config_dword(dev, PCI_COMMAND, 0x00000146);
@@ -188,7 +188,7 @@ sgiioc4_clearirq(ide_drive_t * drive)
         return intr_reg & 3;
 }
 
-static void sgiioc4_ide_dma_start(ide_drive_t * drive)
+static void sgiioc4_dma_start(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
         unsigned long ioc4_dma_addr = hwif->dma_base + IOC4_DMA_CTRL * 4;
@@ -215,8 +215,7 @@ sgiioc4_ide_dma_stop(ide_hwif_t *hwif, u64 dma_base)
 }
 
 /* Stops the IOC4 DMA Engine */
-static int
-sgiioc4_ide_dma_end(ide_drive_t * drive)
+static int sgiioc4_dma_end(ide_drive_t *drive)
 {
         u32 ioc4_dma, bc_dev, bc_mem, num, valid = 0, cnt = 0;
         ide_hwif_t *hwif = HWIF(drive);
@@ -232,7 +231,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
                 printk(KERN_ERR
                        "%s(%s): IOC4 DMA STOP bit is still 1 :"
                        "ioc4_dma_reg 0x%x\n",
-                       __FUNCTION__, drive->name, ioc4_dma);
+                       __func__, drive->name, ioc4_dma);
                 dma_stat = 1;
         }
 
@@ -251,7 +250,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
                 udelay(1);
         }
         if (!valid) {
-                printk(KERN_ERR "%s(%s) : DMA incomplete\n", __FUNCTION__,
+                printk(KERN_ERR "%s(%s) : DMA incomplete\n", __func__,
                        drive->name);
                 dma_stat = 1;
         }
@@ -264,7 +263,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
                         printk(KERN_ERR
                                "%s(%s): WARNING!! byte_count_dev %d "
                                "!= byte_count_mem %d\n",
-                               __FUNCTION__, drive->name, bc_dev, bc_mem);
+                               __func__, drive->name, bc_dev, bc_mem);
                 }
         }
 
@@ -279,8 +278,7 @@ static void sgiioc4_set_dma_mode(ide_drive_t *drive, const u8 speed)
 }
 
 /* returns 1 if dma irq issued, 0 otherwise */
-static int
-sgiioc4_ide_dma_test_irq(ide_drive_t * drive)
+static int sgiioc4_dma_test_irq(ide_drive_t *drive)
 {
         return sgiioc4_checkirq(HWIF(drive));
 }
@@ -294,7 +292,7 @@ static void sgiioc4_dma_host_set(ide_drive_t *drive, int on)
 static void
 sgiioc4_resetproc(ide_drive_t * drive)
 {
-        sgiioc4_ide_dma_end(drive);
+        sgiioc4_dma_end(drive);
         sgiioc4_clearirq(drive);
 }
 
@@ -329,13 +327,17 @@ sgiioc4_INB(unsigned long port)
 
 /* Creates a dma map for the scatter-gather list entries */
 static int __devinit
-ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
+ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
+        unsigned long dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
         void __iomem *virt_dma_base;
         int num_ports = sizeof (ioc4_dma_regs_t);
         void *pad;
 
+        if (dma_base == 0)
+                return -1;
+
         printk(KERN_INFO "%s: BM-DMA at 0x%04lx-0x%04lx\n", hwif->name,
                dma_base, dma_base + num_ports - 1);
 
@@ -343,7 +345,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
                 printk(KERN_ERR
                        "%s(%s) -- ERROR, Addresses 0x%p to 0x%p "
                        "ALREADY in use\n",
-                       __FUNCTION__, hwif->name, (void *) dma_base,
+                       __func__, hwif->name, (void *) dma_base,
                        (void *) dma_base + num_ports - 1);
                 return -1;
         }
@@ -352,7 +354,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
         if (virt_dma_base == NULL) {
                 printk(KERN_ERR
                        "%s(%s) -- ERROR, Unable to map addresses 0x%lx to 0x%lx\n",
-                       __FUNCTION__, hwif->name, dma_base, dma_base + num_ports - 1);
+                       __func__, hwif->name, dma_base, dma_base + num_ports - 1);
                 goto dma_remap_failure;
         }
         hwif->dma_base = (unsigned long) virt_dma_base;
@@ -378,7 +380,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
                             hwif->dmatable_cpu, hwif->dmatable_dma);
         printk(KERN_INFO
                "%s() -- Error! Unable to allocate DMA Maps for drive %s\n",
-               __FUNCTION__, hwif->name);
+               __func__, hwif->name);
         printk(KERN_INFO
                "Changing from DMA to PIO mode for Drive %s\n", hwif->name);
 
@@ -406,14 +408,14 @@ sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
         if (ioc4_dma & IOC4_S_DMA_ACTIVE) {
                 printk(KERN_WARNING
                         "%s(%s):Warning!! DMA from previous transfer was still active\n",
-                       __FUNCTION__, drive->name);
+                       __func__, drive->name);
                 writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
                 ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);
 
                 if (ioc4_dma & IOC4_S_DMA_STOP)
                         printk(KERN_ERR
                                "%s(%s) : IOC4 Dma STOP bit is still 1\n",
-                               __FUNCTION__, drive->name);
+                               __func__, drive->name);
         }
 
         ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
@@ -421,14 +423,14 @@ sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
                 printk(KERN_WARNING
                        "%s(%s) : Warning!! - DMA Error during Previous"
                        " transfer | status 0x%x\n",
-                       __FUNCTION__, drive->name, ioc4_dma);
+                       __func__, drive->name, ioc4_dma);
                 writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
                 ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);
 
                 if (ioc4_dma & IOC4_S_DMA_STOP)
                         printk(KERN_ERR
                                "%s(%s) : IOC4 DMA STOP bit is still 1\n",
-                               __FUNCTION__, drive->name);
+                               __func__, drive->name);
         }
 
         /* Address of the Scatter Gather List */
@@ -519,7 +521,7 @@ use_pio_instead:
         return 0;               /* revert to PIO for this request */
 }
 
-static int sgiioc4_ide_dma_setup(ide_drive_t *drive)
+static int sgiioc4_dma_setup(ide_drive_t *drive)
 {
         struct request *rq = HWGROUP(drive)->rq;
         unsigned int count = 0;
@@ -548,62 +550,45 @@ static int sgiioc4_ide_dma_setup(ide_drive_t *drive)
         return 0;
 }
 
-static void __devinit
-ide_init_sgiioc4(ide_hwif_t * hwif)
-{
-        hwif->mmio = 1;
-        hwif->set_pio_mode = NULL; /* Sets timing for PIO mode */
-        hwif->set_dma_mode = &sgiioc4_set_dma_mode;
-        hwif->selectproc = NULL;/* Use the default routine to select drive */
-        hwif->reset_poll = NULL;/* No HBA specific reset_poll needed */
-        hwif->pre_reset = NULL; /* No HBA specific pre_set needed */
-        hwif->resetproc = &sgiioc4_resetproc;/* Reset DMA engine,
-                                                clear interrupts */
-        hwif->maskproc = &sgiioc4_maskproc;     /* Mask on/off NIEN register */
-        hwif->quirkproc = NULL;
-
-        hwif->INB = &sgiioc4_INB;
-
-        if (hwif->dma_base == 0)
-                return;
+static const struct ide_port_ops sgiioc4_port_ops = {
+        .set_dma_mode           = sgiioc4_set_dma_mode,
+        /* reset DMA engine, clear IRQs */
+        .resetproc              = sgiioc4_resetproc,
+        /* mask on/off NIEN register */
+        .maskproc               = sgiioc4_maskproc,
+};
 
-        hwif->dma_host_set = &sgiioc4_dma_host_set;
-        hwif->dma_setup = &sgiioc4_ide_dma_setup;
-        hwif->dma_start = &sgiioc4_ide_dma_start;
-        hwif->ide_dma_end = &sgiioc4_ide_dma_end;
-        hwif->ide_dma_test_irq = &sgiioc4_ide_dma_test_irq;
-        hwif->dma_lost_irq = &sgiioc4_dma_lost_irq;
-        hwif->dma_timeout = &ide_dma_timeout;
-}
+static const struct ide_dma_ops sgiioc4_dma_ops = {
+        .dma_host_set           = sgiioc4_dma_host_set,
+        .dma_setup              = sgiioc4_dma_setup,
+        .dma_start              = sgiioc4_dma_start,
+        .dma_end                = sgiioc4_dma_end,
+        .dma_test_irq           = sgiioc4_dma_test_irq,
+        .dma_lost_irq           = sgiioc4_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
 
 static const struct ide_port_info sgiioc4_port_info __devinitdata = {
         .chipset                = ide_pci,
-        .host_flags             = IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
-                                  IDE_HFLAG_NO_AUTOTUNE,
+        .init_dma               = ide_dma_sgiioc4,
+        .port_ops               = &sgiioc4_port_ops,
+        .dma_ops                = &sgiioc4_dma_ops,
         .mwdma_mask             = ATA_MWDMA2_ONLY,
 };
 
 static int __devinit
 sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
 {
-        unsigned long cmd_base, dma_base, irqport;
+        unsigned long cmd_base, irqport;
         unsigned long bar0, cmd_phys_base, ctl;
         void __iomem *virt_base;
         ide_hwif_t *hwif;
-        int h;
         u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
         hw_regs_t hw;
         struct ide_port_info d = sgiioc4_port_info;
 
-        /*
-         * Find an empty HWIF; if none available, return -ENOMEM.
-         */
-        for (h = 0; h < MAX_HWIFS; ++h) {
-                hwif = &ide_hwifs[h];
-                if (hwif->chipset == ide_unknown)
-                        break;
-        }
-        if (h == MAX_HWIFS) {
+        hwif = ide_find_port();
+        if (hwif == NULL) {
                 printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n",
                                 DRV_NAME);
                 return -ENOMEM;
@@ -620,7 +605,6 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
         cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET;
         ctl = (unsigned long) virt_base + IOC4_CTRL_OFFSET;
         irqport = (unsigned long) virt_base + IOC4_INTR_OFFSET;
-        dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
 
         cmd_phys_base = bar0 + IOC4_CMD_OFFSET;
         if (!request_mem_region(cmd_phys_base, IOC4_CMD_CTL_BLK_SIZE,
@@ -628,7 +612,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
                 printk(KERN_ERR
                         "%s : %s -- ERROR, Addresses "
                         "0x%p to 0x%p ALREADY in use\n",
-                       __FUNCTION__, hwif->name, (void *) cmd_phys_base,
+                       __func__, hwif->name, (void *) cmd_phys_base,
                        (void *) cmd_phys_base + IOC4_CMD_CTL_BLK_SIZE);
                 return -ENOMEM;
         }
@@ -649,13 +633,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
         /* Initializing chipset IRQ Registers */
         writel(0x03, (void __iomem *)(irqport + IOC4_INTR_SET * 4));
 
-        if (dma_base == 0 || ide_dma_sgiioc4(hwif, dma_base)) {
-                printk(KERN_INFO "%s: %s Bus-Master DMA disabled\n",
-                                 hwif->name, DRV_NAME);
-                d.mwdma_mask = 0;
-        }
-
-        ide_init_sgiioc4(hwif);
+        hwif->INB = &sgiioc4_INB;
 
         idx[0] = hwif->index;
 
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index b6be1b45f329..c2040a017f47 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -301,7 +301,7 @@ static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
 }
 
 /* returns 1 if dma irq issued, 0 otherwise */
-static int siimage_io_ide_dma_test_irq (ide_drive_t *drive)
+static int siimage_io_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -320,14 +320,14 @@ static int siimage_io_ide_dma_test_irq (ide_drive_t *drive)
 }
 
 /**
- *      siimage_mmio_ide_dma_test_irq   -       check we caused an IRQ
+ *      siimage_mmio_dma_test_irq       -       check we caused an IRQ
  *      @drive: drive we are testing
  *
  *      Check if we caused an IDE DMA interrupt. We may also have caused
  *      SATA status interrupts, if so we clean them up and continue.
  */
- 
-static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
+
+static int siimage_mmio_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long addr      = siimage_selreg(hwif, 0x1);
@@ -347,7 +347,7 @@ static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
                         printk(KERN_WARNING "%s: sata_error = 0x%08x, "
                                 "watchdog = %d, %s\n",
                                 drive->name, sata_error, watchdog,
-                                __FUNCTION__);
+                                __func__);
 
                 } else {
                         watchdog = (ext_stat & 0x8000) ? 1 : 0;
@@ -369,6 +369,14 @@ static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
         return 0;
 }
 
+static int siimage_dma_test_irq(ide_drive_t *drive)
+{
+        if (drive->hwif->mmio)
+                return siimage_mmio_dma_test_irq(drive);
+        else
+                return siimage_io_dma_test_irq(drive);
+}
+
 /**
  *      sil_sata_reset_poll     -       wait for SATA reset
  *      @drive: drive we are resetting
@@ -614,9 +622,10 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         void *addr              = pci_get_drvdata(dev);
         u8 ch                   = hwif->channel;
-        hw_regs_t               hw;
         unsigned long           base;
 
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+
         /*
          *      Fill in the basic HWIF bits
          */
@@ -630,7 +639,7 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
          *      based I/O
          */
 
-        memset(&hw, 0, sizeof(hw_regs_t));
+        memset(io_ports, 0, sizeof(*io_ports));
 
         base = (unsigned long)addr;
         if (ch)
@@ -643,17 +652,15 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
          *      so we can't currently use it sanely since we want to
          *      use LBA48 mode.
          */     
-        hw.io_ports[IDE_DATA_OFFSET]    = base;
-        hw.io_ports[IDE_ERROR_OFFSET]   = base + 1;
-        hw.io_ports[IDE_NSECTOR_OFFSET] = base + 2;
-        hw.io_ports[IDE_SECTOR_OFFSET]  = base + 3;
-        hw.io_ports[IDE_LCYL_OFFSET]    = base + 4;
-        hw.io_ports[IDE_HCYL_OFFSET]    = base + 5;
-        hw.io_ports[IDE_SELECT_OFFSET]  = base + 6;
-        hw.io_ports[IDE_STATUS_OFFSET]  = base + 7;
-        hw.io_ports[IDE_CONTROL_OFFSET] = base + 10;
-
-        hw.io_ports[IDE_IRQ_OFFSET]     = 0;
+        io_ports->data_addr     = base;
+        io_ports->error_addr    = base + 1;
+        io_ports->nsect_addr    = base + 2;
+        io_ports->lbal_addr     = base + 3;
+        io_ports->lbam_addr     = base + 4;
+        io_ports->lbah_addr     = base + 5;
+        io_ports->device_addr   = base + 6;
+        io_ports->status_addr   = base + 7;
+        io_ports->ctl_addr      = base + 10;
 
         if (pdev_is_sata(dev)) {
                 base = (unsigned long)addr;
@@ -664,8 +671,6 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
                 hwif->sata_scr[SATA_CONTROL_OFFSET]     = base + 0x100;
         }
 
-        memcpy(hwif->io_ports, hw.io_ports, sizeof(hwif->io_ports));
-
         hwif->irq = dev->irq;
 
         hwif->dma_base = (unsigned long)addr + (ch ? 0x08 : 0x00);
@@ -735,14 +740,14 @@ static void __devinit init_iops_siimage(ide_hwif_t *hwif)
 }
 
 /**
- *      ata66_siimage   -       check for 80 pin cable
+ *      sil_cable_detect        -       cable detection
  *      @hwif: interface to check
  *
  *      Check for the presence of an ATA66 capable cable on the
  *      interface.
  */
 
-static u8 __devinit ata66_siimage(ide_hwif_t *hwif)
+static u8 __devinit sil_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         unsigned long addr = siimage_selreg(hwif, 0);
@@ -756,68 +761,44 @@ static u8 __devinit ata66_siimage(ide_hwif_t *hwif)
         return (ata66 & 0x01) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
 }
 
-/**
- *      init_hwif_siimage       -       set up hwif structs
- *      @hwif: interface to set up
- *
- *      We do the basic set up of the interface structure. The SIIMAGE
- *      requires several custom handlers so we override the default
- *      ide DMA handlers appropriately
- */
-
-static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
-{
-        u8 sata = is_sata(hwif);
-
-        hwif->set_pio_mode = &sil_set_pio_mode;
-        hwif->set_dma_mode = &sil_set_dma_mode;
-        hwif->quirkproc = &sil_quirkproc;
-
-        if (sata) {
-                static int first = 1;
-
-                hwif->reset_poll = &sil_sata_reset_poll;
-                hwif->pre_reset = &sil_sata_pre_reset;
-                hwif->udma_filter = &sil_sata_udma_filter;
-
-                if (first) {
-                        printk(KERN_INFO "siimage: For full SATA support you should use the libata sata_sil module.\n");
-                        first = 0;
-                }
-        } else
-                hwif->udma_filter = &sil_pata_udma_filter;
-
-        hwif->cable_detect = ata66_siimage;
-
-        if (hwif->dma_base == 0)
-                return;
+static const struct ide_port_ops sil_pata_port_ops = {
+        .set_pio_mode           = sil_set_pio_mode,
+        .set_dma_mode           = sil_set_dma_mode,
+        .quirkproc              = sil_quirkproc,
+        .udma_filter            = sil_pata_udma_filter,
+        .cable_detect           = sil_cable_detect,
+};
 
-        if (sata)
-                hwif->host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
+static const struct ide_port_ops sil_sata_port_ops = {
+        .set_pio_mode           = sil_set_pio_mode,
+        .set_dma_mode           = sil_set_dma_mode,
+        .reset_poll             = sil_sata_reset_poll,
+        .pre_reset              = sil_sata_pre_reset,
+        .quirkproc              = sil_quirkproc,
+        .udma_filter            = sil_sata_udma_filter,
+        .cable_detect           = sil_cable_detect,
+};
 
-        if (hwif->mmio) {
-                hwif->ide_dma_test_irq = &siimage_mmio_ide_dma_test_irq;
-        } else {
-                hwif->ide_dma_test_irq = & siimage_io_ide_dma_test_irq;
-        }
-}
+static struct ide_dma_ops sil_dma_ops = {
+        .dma_test_irq           = siimage_dma_test_irq,
+};
 
-#define DECLARE_SII_DEV(name_str)                       \
+#define DECLARE_SII_DEV(name_str, p_ops)                \
         {                                               \
                 .name           = name_str,             \
                 .init_chipset   = init_chipset_siimage, \
                 .init_iops      = init_iops_siimage,    \
-                .init_hwif      = init_hwif_siimage,    \
-                .host_flags     = IDE_HFLAG_BOOTABLE,   \
+                .port_ops       = p_ops,                \
+                .dma_ops        = &sil_dma_ops,         \
                 .pio_mask       = ATA_PIO4,             \
                 .mwdma_mask     = ATA_MWDMA2,           \
                 .udma_mask      = ATA_UDMA6,            \
         }
 
 static const struct ide_port_info siimage_chipsets[] __devinitdata = {
-        /* 0 */ DECLARE_SII_DEV("SiI680"),
-        /* 1 */ DECLARE_SII_DEV("SiI3112 Serial ATA"),
-        /* 2 */ DECLARE_SII_DEV("Adaptec AAR-1210SA")
+        /* 0 */ DECLARE_SII_DEV("SiI680",               &sil_pata_port_ops),
+        /* 1 */ DECLARE_SII_DEV("SiI3112 Serial ATA",   &sil_sata_port_ops),
+        /* 2 */ DECLARE_SII_DEV("Adaptec AAR-1210SA",   &sil_sata_port_ops)
 };
 
 /**
@@ -831,7 +812,24 @@ static const struct ide_port_info siimage_chipsets[] __devinitdata = {
  
 static int __devinit siimage_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        return ide_setup_pci_device(dev, &siimage_chipsets[id->driver_data]);
+        struct ide_port_info d;
+        u8 idx = id->driver_data;
+
+        d = siimage_chipsets[idx];
+
+        if (idx) {
+                static int first = 1;
+
+                if (first) {
+                        printk(KERN_INFO "siimage: For full SATA support you "
+                                "should use the libata sata_sil module.\n");
+                        first = 0;
+                }
+
+                d.host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
+        }
+
+        return ide_setup_pci_device(dev, &d);
 }
 
 static const struct pci_device_id siimage_pci_tbl[] = {
diff --git a/drivers/ide/pci/sis5513.c b/drivers/ide/pci/sis5513.c
index 512bb4c1fd5c..4b0b85d8faf5 100644
--- a/drivers/ide/pci/sis5513.c
+++ b/drivers/ide/pci/sis5513.c
@@ -59,10 +59,10 @@
 #define ATA_16          0x01
 #define ATA_33          0x02
 #define ATA_66          0x03
-#define ATA_100a        0x04 // SiS730/SiS550 is ATA100 with ATA66 layout
+#define ATA_100a        0x04 /* SiS730/SiS550 is ATA100 with ATA66 layout */
 #define ATA_100         0x05
-#define ATA_133a        0x06 // SiS961b with 133 support
-#define ATA_133         0x07 // SiS962/963
+#define ATA_133a        0x06 /* SiS961b with 133 support */
+#define ATA_133         0x07 /* SiS962/963 */
 
 static u8 chipset_family;
 
@@ -111,69 +111,70 @@ static const struct {
    Indexed by chipset_family and (dma_mode - XFER_UDMA_0) */
 
 /* {0, ATA_16, ATA_33, ATA_66, ATA_100a, ATA_100, ATA_133} */
-static u8 cycle_time_offset[] = {0,0,5,4,4,0,0};
-static u8 cycle_time_range[] = {0,0,2,3,3,4,4};
+static u8 cycle_time_offset[] = { 0, 0, 5, 4, 4, 0, 0 };
+static u8 cycle_time_range[]  = { 0, 0, 2, 3, 3, 4, 4 };
 static u8 cycle_time_value[][XFER_UDMA_6 - XFER_UDMA_0 + 1] = {
-        {0,0,0,0,0,0,0}, /* no udma */
-        {0,0,0,0,0,0,0}, /* no udma */
-        {3,2,1,0,0,0,0}, /* ATA_33 */
-        {7,5,3,2,1,0,0}, /* ATA_66 */
-        {7,5,3,2,1,0,0}, /* ATA_100a (730 specific), differences are on cycle_time range and offset */
-        {11,7,5,4,2,1,0}, /* ATA_100 */
-        {15,10,7,5,3,2,1}, /* ATA_133a (earliest 691 southbridges) */
-        {15,10,7,5,3,2,1}, /* ATA_133 */
+        {  0,  0, 0, 0, 0, 0, 0 }, /* no UDMA */
+        {  0,  0, 0, 0, 0, 0, 0 }, /* no UDMA */
+        {  3,  2, 1, 0, 0, 0, 0 }, /* ATA_33 */
+        {  7,  5, 3, 2, 1, 0, 0 }, /* ATA_66 */
+        {  7,  5, 3, 2, 1, 0, 0 }, /* ATA_100a (730 specific),
+                                      different cycle_time range and offset */
+        { 11,  7, 5, 4, 2, 1, 0 }, /* ATA_100 */
+        { 15, 10, 7, 5, 3, 2, 1 }, /* ATA_133a (earliest 691 southbridges) */
+        { 15, 10, 7, 5, 3, 2, 1 }, /* ATA_133 */
 };
 /* CRC Valid Setup Time vary across IDE clock setting 33/66/100/133
    See SiS962 data sheet for more detail */
 static u8 cvs_time_value[][XFER_UDMA_6 - XFER_UDMA_0 + 1] = {
-        {0,0,0,0,0,0,0}, /* no udma */
-        {0,0,0,0,0,0,0}, /* no udma */
-        {2,1,1,0,0,0,0},
-        {4,3,2,1,0,0,0},
-        {4,3,2,1,0,0,0},
-        {6,4,3,1,1,1,0},
-        {9,6,4,2,2,2,2},
-        {9,6,4,2,2,2,2},
+        { 0, 0, 0, 0, 0, 0, 0 }, /* no UDMA */
+        { 0, 0, 0, 0, 0, 0, 0 }, /* no UDMA */
+        { 2, 1, 1, 0, 0, 0, 0 },
+        { 4, 3, 2, 1, 0, 0, 0 },
+        { 4, 3, 2, 1, 0, 0, 0 },
+        { 6, 4, 3, 1, 1, 1, 0 },
+        { 9, 6, 4, 2, 2, 2, 2 },
+        { 9, 6, 4, 2, 2, 2, 2 },
 };
 /* Initialize time, Active time, Recovery time vary across
    IDE clock settings. These 3 arrays hold the register value
    for PIO0/1/2/3/4 and DMA0/1/2 mode in order */
 static u8 ini_time_value[][8] = {
-        {0,0,0,0,0,0,0,0},
-        {0,0,0,0,0,0,0,0},
-        {2,1,0,0,0,1,0,0},
-        {4,3,1,1,1,3,1,1},
-        {4,3,1,1,1,3,1,1},
-        {6,4,2,2,2,4,2,2},
-        {9,6,3,3,3,6,3,3},
-        {9,6,3,3,3,6,3,3},
+        { 0, 0, 0, 0, 0, 0, 0, 0 },
+        { 0, 0, 0, 0, 0, 0, 0, 0 },
+        { 2, 1, 0, 0, 0, 1, 0, 0 },
+        { 4, 3, 1, 1, 1, 3, 1, 1 },
+        { 4, 3, 1, 1, 1, 3, 1, 1 },
+        { 6, 4, 2, 2, 2, 4, 2, 2 },
+        { 9, 6, 3, 3, 3, 6, 3, 3 },
+        { 9, 6, 3, 3, 3, 6, 3, 3 },
 };
 static u8 act_time_value[][8] = {
-        {0,0,0,0,0,0,0,0},
-        {0,0,0,0,0,0,0,0},
-        {9,9,9,2,2,7,2,2},
-        {19,19,19,5,4,14,5,4},
-        {19,19,19,5,4,14,5,4},
-        {28,28,28,7,6,21,7,6},
-        {38,38,38,10,9,28,10,9},
-        {38,38,38,10,9,28,10,9},
+        {  0,  0,  0,  0, 0,  0,  0, 0 },
+        {  0,  0,  0,  0, 0,  0,  0, 0 },
+        {  9,  9,  9,  2, 2,  7,  2, 2 },
+        { 19, 19, 19,  5, 4, 14,  5, 4 },
+        { 19, 19, 19,  5, 4, 14,  5, 4 },
+        { 28, 28, 28,  7, 6, 21,  7, 6 },
+        { 38, 38, 38, 10, 9, 28, 10, 9 },
+        { 38, 38, 38, 10, 9, 28, 10, 9 },
 };
 static u8 rco_time_value[][8] = {
-        {0,0,0,0,0,0,0,0},
-        {0,0,0,0,0,0,0,0},
-        {9,2,0,2,0,7,1,1},
-        {19,5,1,5,2,16,3,2},
-        {19,5,1,5,2,16,3,2},
-        {30,9,3,9,4,25,6,4},
-        {40,12,4,12,5,34,12,5},
-        {40,12,4,12,5,34,12,5},
+        {  0,  0, 0,  0, 0,  0,  0, 0 },
+        {  0,  0, 0,  0, 0,  0,  0, 0 },
+        {  9,  2, 0,  2, 0,  7,  1, 1 },
+        { 19,  5, 1,  5, 2, 16,  3, 2 },
+        { 19,  5, 1,  5, 2, 16,  3, 2 },
+        { 30,  9, 3,  9, 4, 25,  6, 4 },
+        { 40, 12, 4, 12, 5, 34, 12, 5 },
+        { 40, 12, 4, 12, 5, 34, 12, 5 },
 };
 
 /*
  * Printing configuration
  */
 /* Used for chipset type printing at boot time */
-static char* chipset_capability[] = {
+static char *chipset_capability[] = {
         "ATA", "ATA 16",
         "ATA 33", "ATA 66",
         "ATA 100 (1st gen)", "ATA 100 (2nd gen)",
@@ -272,7 +273,7 @@ static void sis_program_timings(ide_drive_t *drive, const u8 mode)
                 sis_ata133_program_timings(drive, mode);
 }
 
-static void config_drive_art_rwp (ide_drive_t *drive)
+static void config_drive_art_rwp(ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
@@ -346,7 +347,7 @@ static void sis_set_dma_mode(ide_drive_t *drive, const u8 speed)
                 sis_program_timings(drive, speed);
 }
 
-static u8 sis5513_ata133_udma_filter(ide_drive_t *drive)
+static u8 sis_ata133_udma_filter(ide_drive_t *drive)
 {
         struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
         u32 regdw = 0;
@@ -358,8 +359,7 @@ static u8 sis5513_ata133_udma_filter(ide_drive_t *drive)
         return (regdw & 0x08) ? ATA_UDMA6 : ATA_UDMA5;
 }
 
-/* Chip detection and general config */
-static unsigned int __devinit init_chipset_sis5513 (struct pci_dev *dev, const char *name)
+static int __devinit sis_find_family(struct pci_dev *dev)
 {
         struct pci_dev *host;
         int i = 0;
@@ -381,7 +381,7 @@ static unsigned int __devinit init_chipset_sis5513 (struct pci_dev *dev, const c
                                 chipset_family = ATA_100a;
                 }
                 pci_dev_put(host);
-        
+
                 printk(KERN_INFO "SIS5513: %s %s controller\n",
                          SiSHostChipInfo[i].name, chipset_capability[chipset_family]);
         }
@@ -440,63 +440,60 @@ static unsigned int __devinit init_chipset_sis5513 (struct pci_dev *dev, const c
                         }
         }
 
-        if (!chipset_family)
-                return -1;
+        return chipset_family;
+}
 
+static unsigned int __devinit init_chipset_sis5513(struct pci_dev *dev,
+                                                   const char *name)
+{
         /* Make general config ops here
            1/ tell IDE channels to operate in Compatibility mode only
            2/ tell old chips to allow per drive IDE timings */
 
-        {
-                u8 reg;
-                u16 regw;
-
-                switch(chipset_family) {
-                        case ATA_133:
-                                /* SiS962 operation mode */
-                                pci_read_config_word(dev, 0x50, &regw);
-                                if (regw & 0x08)
-                                        pci_write_config_word(dev, 0x50, regw&0xfff7);
-                                pci_read_config_word(dev, 0x52, &regw);
-                                if (regw & 0x08)
-                                        pci_write_config_word(dev, 0x52, regw&0xfff7);
-                                break;
-                        case ATA_133a:
-                        case ATA_100:
-                                /* Fixup latency */
-                                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x80);
-                                /* Set compatibility bit */
-                                pci_read_config_byte(dev, 0x49, &reg);
-                                if (!(reg & 0x01)) {
-                                        pci_write_config_byte(dev, 0x49, reg|0x01);
-                                }
-                                break;
-                        case ATA_100a:
-                        case ATA_66:
-                                /* Fixup latency */
-                                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x10);
-
-                                /* On ATA_66 chips the bit was elsewhere */
-                                pci_read_config_byte(dev, 0x52, &reg);
-                                if (!(reg & 0x04)) {
-                                        pci_write_config_byte(dev, 0x52, reg|0x04);
-                                }
-                                break;
-                        case ATA_33:
-                                /* On ATA_33 we didn't have a single bit to set */
-                                pci_read_config_byte(dev, 0x09, &reg);
-                                if ((reg & 0x0f) != 0x00) {
-                                        pci_write_config_byte(dev, 0x09, reg&0xf0);
-                                }
-                        case ATA_16:
-                                /* force per drive recovery and active timings
-                                   needed on ATA_33 and below chips */
-                                pci_read_config_byte(dev, 0x52, &reg);
-                                if (!(reg & 0x08)) {
-                                        pci_write_config_byte(dev, 0x52, reg|0x08);
-                                }
-                                break;
-                }
+        u8 reg;
+        u16 regw;
+
+        switch (chipset_family) {
+        case ATA_133:
+                /* SiS962 operation mode */
+                pci_read_config_word(dev, 0x50, &regw);
+                if (regw & 0x08)
+                        pci_write_config_word(dev, 0x50, regw&0xfff7);
+                pci_read_config_word(dev, 0x52, &regw);
+                if (regw & 0x08)
+                        pci_write_config_word(dev, 0x52, regw&0xfff7);
+                break;
+        case ATA_133a:
+        case ATA_100:
+                /* Fixup latency */
+                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x80);
+                /* Set compatibility bit */
+                pci_read_config_byte(dev, 0x49, &reg);
+                if (!(reg & 0x01))
+                        pci_write_config_byte(dev, 0x49, reg|0x01);
+                break;
+        case ATA_100a:
+        case ATA_66:
+                /* Fixup latency */
+                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x10);
+
+                /* On ATA_66 chips the bit was elsewhere */
+                pci_read_config_byte(dev, 0x52, &reg);
+                if (!(reg & 0x04))
+                        pci_write_config_byte(dev, 0x52, reg|0x04);
+                break;
+        case ATA_33:
+                /* On ATA_33 we didn't have a single bit to set */
+                pci_read_config_byte(dev, 0x09, &reg);
+                if ((reg & 0x0f) != 0x00)
+                        pci_write_config_byte(dev, 0x09, reg&0xf0);
+        case ATA_16:
+                /* force per drive recovery and active timings
+                   needed on ATA_33 and below chips */
+                pci_read_config_byte(dev, 0x52, &reg);
+                if (!(reg & 0x08))
+                        pci_write_config_byte(dev, 0x52, reg|0x08);
+                break;
         }
 
         return 0;
@@ -517,7 +514,7 @@ static const struct sis_laptop sis_laptop[] = {
         { 0, }
 };
 
-static u8 __devinit ata66_sis5513(ide_hwif_t *hwif)
+static u8 __devinit sis_cable_detect(ide_hwif_t *hwif)
 {
         struct pci_dev *pdev = to_pci_dev(hwif->dev);
         const struct sis_laptop *lap = &sis_laptop[0];
@@ -546,38 +543,44 @@ static u8 __devinit ata66_sis5513(ide_hwif_t *hwif)
         return ata66 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
 }
 
-static void __devinit init_hwif_sis5513 (ide_hwif_t *hwif)
-{
-        u8 udma_rates[] = { 0x00, 0x00, 0x07, 0x1f, 0x3f, 0x3f, 0x7f, 0x7f };
-
-        hwif->set_pio_mode = &sis_set_pio_mode;
-        hwif->set_dma_mode = &sis_set_dma_mode;
-
-        if (chipset_family >= ATA_133)
-                hwif->udma_filter = sis5513_ata133_udma_filter;
-
-        hwif->cable_detect = ata66_sis5513;
-
-        if (hwif->dma_base == 0)
-                return;
+static const struct ide_port_ops sis_port_ops = {
+        .set_pio_mode           = sis_set_pio_mode,
+        .set_dma_mode           = sis_set_dma_mode,
+        .cable_detect           = sis_cable_detect,
+};
 
-        hwif->ultra_mask = udma_rates[chipset_family];
-}
+static const struct ide_port_ops sis_ata133_port_ops = {
+        .set_pio_mode           = sis_set_pio_mode,
+        .set_dma_mode           = sis_set_dma_mode,
+        .udma_filter            = sis_ata133_udma_filter,
+        .cable_detect           = sis_cable_detect,
+};
 
 static const struct ide_port_info sis5513_chipset __devinitdata = {
         .name           = "SIS5513",
         .init_chipset   = init_chipset_sis5513,
-        .init_hwif      = init_hwif_sis5513,
-        .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
-        .host_flags     = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_NO_AUTODMA |
-                          IDE_HFLAG_BOOTABLE,
+        .enablebits     = { {0x4a, 0x02, 0x02}, {0x4a, 0x04, 0x04} },
+        .host_flags     = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_NO_AUTODMA,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
 };
 
 static int __devinit sis5513_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        return ide_setup_pci_device(dev, &sis5513_chipset);
+        struct ide_port_info d = sis5513_chipset;
+        u8 udma_rates[] = { 0x00, 0x00, 0x07, 0x1f, 0x3f, 0x3f, 0x7f, 0x7f };
+
+        if (sis_find_family(dev) == 0)
+                return -ENOTSUPP;
+
+        if (chipset_family >= ATA_133)
+                d.port_ops = &sis_ata133_port_ops;
+        else
+                d.port_ops = &sis_port_ops;
+
+        d.udma_mask = udma_rates[chipset_family];
+
+        return ide_setup_pci_device(dev, &d);
 }
 
 static const struct pci_device_id sis5513_pci_tbl[] = {
diff --git a/drivers/ide/pci/sl82c105.c b/drivers/ide/pci/sl82c105.c
index 1f00251a4a87..ce84fa045d39 100644
--- a/drivers/ide/pci/sl82c105.c
+++ b/drivers/ide/pci/sl82c105.c
@@ -179,7 +179,7 @@ static void sl82c105_dma_start(ide_drive_t *drive)
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int reg                 = 0x44 + drive->dn * 4;
 
-        DBG(("%s(drive:%s)\n", __FUNCTION__, drive->name));
+        DBG(("%s(drive:%s)\n", __func__, drive->name));
 
         pci_write_config_word(dev, reg, drive->drive_data >> 16);
 
@@ -203,7 +203,7 @@ static int sl82c105_dma_end(ide_drive_t *drive)
         int reg                 = 0x44 + drive->dn * 4;
         int ret;
 
-        DBG(("%s(drive:%s)\n", __FUNCTION__, drive->name));
+        DBG(("%s(drive:%s)\n", __func__, drive->name));
 
         ret = __ide_dma_end(drive);
 
@@ -232,7 +232,7 @@ static void sl82c105_resetproc(ide_drive_t *drive)
  * Return the revision of the Winbond bridge
  * which this function is part of.
  */
-static unsigned int sl82c105_bridge_revision(struct pci_dev *dev)
+static u8 sl82c105_bridge_revision(struct pci_dev *dev)
 {
         struct pci_dev *bridge;
 
@@ -282,64 +282,59 @@ static unsigned int __devinit init_chipset_sl82c105(struct pci_dev *dev, const c
         return dev->irq;
 }
 
-/*
- * Initialise IDE channel
- */
-static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif)
-{
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-        unsigned int rev;
-
-        DBG(("init_hwif_sl82c105(hwif: ide%d)\n", hwif->index));
-
-        hwif->set_pio_mode      = &sl82c105_set_pio_mode;
-        hwif->set_dma_mode      = &sl82c105_set_dma_mode;
-        hwif->resetproc         = &sl82c105_resetproc;
-
-        if (!hwif->dma_base)
-                return;
-
-        rev = sl82c105_bridge_revision(dev);
-        if (rev <= 5) {
-                /*
-                 * Never ever EVER under any circumstances enable
-                 * DMA when the bridge is this old.
-                 */
-                printk("    %s: Winbond W83C553 bridge revision %d, "
-                       "BM-DMA disabled\n", hwif->name, rev);
-                return;
-        }
-
-        hwif->mwdma_mask = ATA_MWDMA2;
-
-        hwif->dma_lost_irq              = &sl82c105_dma_lost_irq;
-        hwif->dma_start                 = &sl82c105_dma_start;
-        hwif->ide_dma_end               = &sl82c105_dma_end;
-        hwif->dma_timeout               = &sl82c105_dma_timeout;
+static const struct ide_port_ops sl82c105_port_ops = {
+        .set_pio_mode           = sl82c105_set_pio_mode,
+        .set_dma_mode           = sl82c105_set_dma_mode,
+        .resetproc              = sl82c105_resetproc,
+};
 
-        if (hwif->mate)
-                hwif->serialized = hwif->mate->serialized = 1;
-}
+static const struct ide_dma_ops sl82c105_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = sl82c105_dma_start,
+        .dma_end                = sl82c105_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = sl82c105_dma_lost_irq,
+        .dma_timeout            = sl82c105_dma_timeout,
+};
 
 static const struct ide_port_info sl82c105_chipset __devinitdata = {
         .name           = "W82C105",
         .init_chipset   = init_chipset_sl82c105,
-        .init_hwif      = init_hwif_sl82c105,
         .enablebits     = {{0x40,0x01,0x01}, {0x40,0x10,0x10}},
+        .port_ops       = &sl82c105_port_ops,
+        .dma_ops        = &sl82c105_dma_ops,
         .host_flags     = IDE_HFLAG_IO_32BIT |
                           IDE_HFLAG_UNMASK_IRQS |
 /* FIXME: check for Compatibility mode in generic IDE PCI code */
 #if defined(CONFIG_LOPEC) || defined(CONFIG_SANDPOINT)
                           IDE_HFLAG_FORCE_LEGACY_IRQS |
 #endif
-                          IDE_HFLAG_NO_AUTODMA |
-                          IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_SERIALIZE_DMA |
+                          IDE_HFLAG_NO_AUTODMA,
         .pio_mask       = ATA_PIO5,
+        .mwdma_mask     = ATA_MWDMA2,
 };
 
 static int __devinit sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        return ide_setup_pci_device(dev, &sl82c105_chipset);
+        struct ide_port_info d = sl82c105_chipset;
+        u8 rev = sl82c105_bridge_revision(dev);
+
+        if (rev <= 5) {
+                /*
+                 * Never ever EVER under any circumstances enable
+                 * DMA when the bridge is this old.
+                 */
+                printk(KERN_INFO "W82C105_IDE: Winbond W83C553 bridge "
+                                 "revision %d, BM-DMA disabled\n", rev);
+                d.dma_ops = NULL;
+                d.mwdma_mask = 0;
+                d.host_flags &= ~IDE_HFLAG_SERIALIZE_DMA;
+        }
+
+        return ide_setup_pci_device(dev, &d);
 }
 
 static const struct pci_device_id sl82c105_pci_tbl[] = {
diff --git a/drivers/ide/pci/slc90e66.c b/drivers/ide/pci/slc90e66.c
index 65f4c2ffaa59..dae6e2c94d86 100644
--- a/drivers/ide/pci/slc90e66.c
+++ b/drivers/ide/pci/slc90e66.c
@@ -27,9 +27,9 @@ static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
         unsigned long flags;
         u16 master_data;
         u8 slave_data;
-        int control = 0;
+        int control = 0;
                                      /* ISP  RTC */
-        static const u8 timings[][2]= {
+        static const u8 timings[][2] = {
                                         { 0, 0 },
                                         { 0, 0 },
                                         { 1, 0 },
@@ -125,19 +125,17 @@ static u8 __devinit slc90e66_cable_detect(ide_hwif_t *hwif)
         return (reg47 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
 }
 
-static void __devinit init_hwif_slc90e66(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &slc90e66_set_pio_mode;
-        hwif->set_dma_mode = &slc90e66_set_dma_mode;
-
-        hwif->cable_detect = slc90e66_cable_detect;
-}
+static const struct ide_port_ops slc90e66_port_ops = {
+        .set_pio_mode           = slc90e66_set_pio_mode,
+        .set_dma_mode           = slc90e66_set_dma_mode,
+        .cable_detect           = slc90e66_cable_detect,
+};
 
 static const struct ide_port_info slc90e66_chipset __devinitdata = {
         .name           = "SLC90E66",
-        .init_hwif      = init_hwif_slc90e66,
-        .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}},
-        .host_flags     = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_BOOTABLE,
+        .enablebits     = { {0x41, 0x80, 0x80}, {0x43, 0x80, 0x80} },
+        .port_ops       = &slc90e66_port_ops,
+        .host_flags     = IDE_HFLAG_LEGACY_IRQS,
         .pio_mask       = ATA_PIO4,
         .swdma_mask     = ATA_SWDMA2_ONLY,
         .mwdma_mask     = ATA_MWDMA12_ONLY,
diff --git a/drivers/ide/pci/tc86c001.c b/drivers/ide/pci/tc86c001.c
index 1e4a6262bcef..9b4b27a4c711 100644
--- a/drivers/ide/pci/tc86c001.c
+++ b/drivers/ide/pci/tc86c001.c
@@ -18,20 +18,20 @@ static void tc86c001_set_mode(ide_drive_t *drive, const u8 speed)
         u16 mode, scr           = inw(scr_port);
 
         switch (speed) {
-                case XFER_UDMA_4:       mode = 0x00c0; break;
-                case XFER_UDMA_3:       mode = 0x00b0; break;
-                case XFER_UDMA_2:       mode = 0x00a0; break;
-                case XFER_UDMA_1:       mode = 0x0090; break;
-                case XFER_UDMA_0:       mode = 0x0080; break;
-                case XFER_MW_DMA_2:     mode = 0x0070; break;
-                case XFER_MW_DMA_1:     mode = 0x0060; break;
-                case XFER_MW_DMA_0:     mode = 0x0050; break;
-                case XFER_PIO_4:        mode = 0x0400; break;
-                case XFER_PIO_3:        mode = 0x0300; break;
-                case XFER_PIO_2:        mode = 0x0200; break;
-                case XFER_PIO_1:        mode = 0x0100; break;
-                case XFER_PIO_0:
-                default:                mode = 0x0000; break;
+        case XFER_UDMA_4:       mode = 0x00c0; break;
+        case XFER_UDMA_3:       mode = 0x00b0; break;
+        case XFER_UDMA_2:       mode = 0x00a0; break;
+        case XFER_UDMA_1:       mode = 0x0090; break;
+        case XFER_UDMA_0:       mode = 0x0080; break;
+        case XFER_MW_DMA_2:     mode = 0x0070; break;
+        case XFER_MW_DMA_1:     mode = 0x0060; break;
+        case XFER_MW_DMA_0:     mode = 0x0050; break;
+        case XFER_PIO_4:        mode = 0x0400; break;
+        case XFER_PIO_3:        mode = 0x0300; break;
+        case XFER_PIO_2:        mode = 0x0200; break;
+        case XFER_PIO_1:        mode = 0x0100; break;
+        case XFER_PIO_0:
+        default:                mode = 0x0000; break;
         }
 
         scr &= (speed < XFER_MW_DMA_0) ? 0xf8ff : 0xff0f;
@@ -157,11 +157,6 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
         /* Store the system control register base for convenience... */
         hwif->config_data = sc_base;
 
-        hwif->set_pio_mode = &tc86c001_set_pio_mode;
-        hwif->set_dma_mode = &tc86c001_set_mode;
-
-        hwif->cable_detect = tc86c001_cable_detect;
-
         if (!hwif->dma_base)
                 return;
 
@@ -173,8 +168,6 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
 
         /* Sector Count Register limit */
         hwif->rqsize     = 0xffff;
-
-        hwif->dma_start         = &tc86c001_dma_start;
 }
 
 static unsigned int __devinit init_chipset_tc86c001(struct pci_dev *dev,
@@ -187,10 +180,29 @@ static unsigned int __devinit init_chipset_tc86c001(struct pci_dev *dev,
         return err;
 }
 
+static const struct ide_port_ops tc86c001_port_ops = {
+        .set_pio_mode           = tc86c001_set_pio_mode,
+        .set_dma_mode           = tc86c001_set_mode,
+        .cable_detect           = tc86c001_cable_detect,
+};
+
+static const struct ide_dma_ops tc86c001_dma_ops = {
+        .dma_host_set           = ide_dma_host_set,
+        .dma_setup              = ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = tc86c001_dma_start,
+        .dma_end                = __ide_dma_end,
+        .dma_test_irq           = ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 static const struct ide_port_info tc86c001_chipset __devinitdata = {
         .name           = "TC86C001",
         .init_chipset   = init_chipset_tc86c001,
         .init_hwif      = init_hwif_tc86c001,
+        .port_ops       = &tc86c001_port_ops,
+        .dma_ops        = &tc86c001_dma_ops,
         .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_OFF_BOARD |
                           IDE_HFLAG_ABUSE_SET_DMA_MODE,
         .pio_mask       = ATA_PIO4,
diff --git a/drivers/ide/pci/triflex.c b/drivers/ide/pci/triflex.c
index a67d02a3f96e..db65a558d4ec 100644
--- a/drivers/ide/pci/triflex.c
+++ b/drivers/ide/pci/triflex.c
@@ -87,17 +87,15 @@ static void triflex_set_pio_mode(ide_drive_t *drive, const u8 pio)
         triflex_set_mode(drive, XFER_PIO_0 + pio);
 }
 
-static void __devinit init_hwif_triflex(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &triflex_set_pio_mode;
-        hwif->set_dma_mode = &triflex_set_mode;
-}
+static const struct ide_port_ops triflex_port_ops = {
+        .set_pio_mode           = triflex_set_pio_mode,
+        .set_dma_mode           = triflex_set_mode,
+};
 
 static const struct ide_port_info triflex_device __devinitdata = {
         .name           = "TRIFLEX",
-        .init_hwif      = init_hwif_triflex,
         .enablebits     = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}},
-        .host_flags     = IDE_HFLAG_BOOTABLE,
+        .port_ops       = &triflex_port_ops,
         .pio_mask       = ATA_PIO4,
         .swdma_mask     = ATA_SWDMA2,
         .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ide/pci/trm290.c b/drivers/ide/pci/trm290.c
index de750f7a43e9..a8a3138682ef 100644
--- a/drivers/ide/pci/trm290.c
+++ b/drivers/ide/pci/trm290.c
@@ -214,7 +214,7 @@ static void trm290_dma_start(ide_drive_t *drive)
 {
 }
 
-static int trm290_ide_dma_end (ide_drive_t *drive)
+static int trm290_dma_end(ide_drive_t *drive)
 {
         u16 status;
 
@@ -225,7 +225,7 @@ static int trm290_ide_dma_end (ide_drive_t *drive)
         return status != 0x00ff;
 }
 
-static int trm290_ide_dma_test_irq (ide_drive_t *drive)
+static int trm290_dma_test_irq(ide_drive_t *drive)
 {
         u16 status;
 
@@ -254,22 +254,11 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
         hwif->config_data = cfg_base;
         hwif->dma_base = (cfg_base + 4) ^ (hwif->channel ? 0x80 : 0);
 
-        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx",
+        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx\n",
                hwif->name, hwif->dma_base, hwif->dma_base + 3);
 
-        if (!request_region(hwif->dma_base, 4, hwif->name)) {
-                printk(KERN_CONT " -- Error, ports in use.\n");
+        if (ide_allocate_dma_engine(hwif))
                 return;
-        }
-
-        hwif->dmatable_cpu = pci_alloc_consistent(dev, PRD_ENTRIES * PRD_BYTES,
-                                                  &hwif->dmatable_dma);
-        if (!hwif->dmatable_cpu) {
-                printk(KERN_CONT " -- Error, unable to allocate DMA table.\n");
-                release_region(hwif->dma_base, 4);
-                return;
-        }
-        printk(KERN_CONT "\n");
 
         local_irq_save(flags);
         /* put config reg into first byte of hwif->select_data */
@@ -291,14 +280,6 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
                 /* sharing IRQ with mate */
                 hwif->irq = hwif->mate->irq;
 
-        hwif->dma_host_set      = &trm290_dma_host_set;
-        hwif->dma_setup         = &trm290_dma_setup;
-        hwif->dma_exec_cmd      = &trm290_dma_exec_cmd;
-        hwif->dma_start         = &trm290_dma_start;
-        hwif->ide_dma_end       = &trm290_ide_dma_end;
-        hwif->ide_dma_test_irq  = &trm290_ide_dma_test_irq;
-
-        hwif->selectproc = &trm290_selectproc;
 #if 1
         {
         /*
@@ -317,7 +298,7 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
                 if (old != compat && old_mask == 0xff) {
                         /* leave lower 10 bits untouched */
                         compat += (next_offset += 0x400);
-                        hwif->io_ports[IDE_CONTROL_OFFSET] = compat + 2;
+                        hwif->io_ports.ctl_addr = compat + 2;
                         outw(compat | 1, hwif->config_data);
                         new = inw(hwif->config_data);
                         printk(KERN_INFO "%s: control basereg workaround: "
@@ -328,16 +309,32 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
 #endif
 }
 
+static const struct ide_port_ops trm290_port_ops = {
+        .selectproc             = trm290_selectproc,
+};
+
+static struct ide_dma_ops trm290_dma_ops = {
+        .dma_host_set           = trm290_dma_host_set,
+        .dma_setup              = trm290_dma_setup,
+        .dma_exec_cmd           = trm290_dma_exec_cmd,
+        .dma_start              = trm290_dma_start,
+        .dma_end                = trm290_dma_end,
+        .dma_test_irq           = trm290_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+};
+
 static const struct ide_port_info trm290_chipset __devinitdata = {
         .name           = "TRM290",
         .init_hwif      = init_hwif_trm290,
         .chipset        = ide_trm290,
+        .port_ops       = &trm290_port_ops,
+        .dma_ops        = &trm290_dma_ops,
         .host_flags     = IDE_HFLAG_NO_ATAPI_DMA |
 #if 0 /* play it safe for now */
                           IDE_HFLAG_TRUST_BIOS_FOR_DMA |
 #endif
                           IDE_HFLAG_NO_AUTODMA |
-                          IDE_HFLAG_BOOTABLE |
                           IDE_HFLAG_NO_LBA48,
 };
 
diff --git a/drivers/ide/pci/via82cxxx.c b/drivers/ide/pci/via82cxxx.c
index 9004e7521889..566e0ecb8db1 100644
--- a/drivers/ide/pci/via82cxxx.c
+++ b/drivers/ide/pci/via82cxxx.c
@@ -340,7 +340,7 @@ static unsigned int __devinit init_chipset_via82cxxx(struct pci_dev *dev, const
          * Determine system bus clock.
          */
 
-        via_clock = system_bus_clock() * 1000;
+        via_clock = (ide_pci_clk ? ide_pci_clk : system_bus_clock()) * 1000;
 
         switch (via_clock) {
                 case 33000: via_clock = 33333; break;
@@ -415,25 +415,21 @@ static u8 __devinit via82cxxx_cable_detect(ide_hwif_t *hwif)
                 return ATA_CBL_PATA40;
 }
 
-static void __devinit init_hwif_via82cxxx(ide_hwif_t *hwif)
-{
-        hwif->set_pio_mode = &via_set_pio_mode;
-        hwif->set_dma_mode = &via_set_drive;
-
-        hwif->cable_detect = via82cxxx_cable_detect;
-}
+static const struct ide_port_ops via_port_ops = {
+        .set_pio_mode           = via_set_pio_mode,
+        .set_dma_mode           = via_set_drive,
+        .cable_detect           = via82cxxx_cable_detect,
+};
 
 static const struct ide_port_info via82cxxx_chipset __devinitdata = {
         .name           = "VP_IDE",
         .init_chipset   = init_chipset_via82cxxx,
-        .init_hwif      = init_hwif_via82cxxx,
         .enablebits     = { { 0x40, 0x02, 0x02 }, { 0x40, 0x01, 0x01 } },
+        .port_ops       = &via_port_ops,
         .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST |
-                          IDE_HFLAG_PIO_NO_DOWNGRADE |
                           IDE_HFLAG_ABUSE_SET_DMA_MODE |
                           IDE_HFLAG_POST_SET_MODE |
-                          IDE_HFLAG_IO_32BIT |
-                          IDE_HFLAG_BOOTABLE,
+                          IDE_HFLAG_IO_32BIT,
         .pio_mask       = ATA_PIO5,
         .swdma_mask     = ATA_SWDMA2,
         .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ide/ppc/mpc8xx.c b/drivers/ide/ppc/mpc8xx.c
index a784a97ca7ec..f0e638dcc3ab 100644
--- a/drivers/ide/ppc/mpc8xx.c
+++ b/drivers/ide/ppc/mpc8xx.c
@@ -36,6 +36,8 @@
 #include <asm/machdep.h>
 #include <asm/irq.h>
 
+#define DRV_NAME "ide-mpc8xx"
+
 static int identify  (volatile u8 *p);
 static void print_fixed (volatile u8 *p);
 static void print_funcid (int func);
@@ -127,9 +129,9 @@ static int pcmcia_schlvl = PCMCIA_SCHLVL;
  * MPC8xx's internal PCMCIA interface
  */
 #if defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_DIRECT)
-static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
+static int __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
 {
-        unsigned long *p = hw->io_ports;
+        unsigned long *p = hw->io_ports_array;
         int i;
 
         typedef struct {
@@ -182,6 +184,13 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
                         pcmcia_phy_base, pcmcia_phy_end,
                         pcmcia_phy_end - pcmcia_phy_base);
 
+                if (!request_mem_region(pcmcia_phy_base,
+                                        pcmcia_phy_end - pcmcia_phy_base,
+                                        DRV_NAME)) {
+                        printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
+                        return -EBUSY;
+                }
+
                 pcmcia_base=(unsigned long)ioremap(pcmcia_phy_base,
                                                    pcmcia_phy_end-pcmcia_phy_base);
 
@@ -236,7 +245,7 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
         if (pcmp->pcmc_pipr & (M8XX_PCMCIA_CD1(_slot_)|M8XX_PCMCIA_CD2(_slot_))) {
                 printk ("No card in slot %c: PIPR=%08x\n",
                         'A' + _slot_, (u32) pcmp->pcmc_pipr);
-                return;         /* No card in slot */
+                return -ENODEV;         /* No card in slot */
         }
 
         check_ide_device (pcmcia_base);
@@ -279,9 +288,6 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
         }
 #endif  /* CONFIG_IDE_8xx_PCCARD */
 
-        ide_hwifs[data_port].pio_mask = ATA_PIO4;
-        ide_hwifs[data_port].set_pio_mode = m8xx_ide_set_pio_mode;
-
         /* Enable Harddisk Interrupt,
          * and make it edge sensitive
          */
@@ -296,6 +302,8 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
         /* Enable falling edge irq */
         pcmp->pcmc_per = 0x100000 >> (16 * _slot_);
 #endif  /* CONFIG_IDE_8xx_PCCARD */
+
+        return 0;
 }
 #endif /* CONFIG_IDE_8xx_PCCARD || CONFIG_IDE_8xx_DIRECT */
 
@@ -304,9 +312,9 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
  * MPC8xx's internal PCMCIA interface
  */
 #if defined(CONFIG_IDE_EXT_DIRECT)
-static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
+static int __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
 {
-        unsigned long *p = hw->io_ports;
+        unsigned long *p = hw->io_ports_array;
         int i;
 
         u32 ide_phy_base;
@@ -327,7 +335,12 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
                 printk ("IDE phys mem : %08x...%08x (size %08x)\n",
                         ide_phy_base, ide_phy_end,
                         ide_phy_end - ide_phy_base);
-                
+
+                if (!request_mem_region(ide_phy_base, 0x200, DRV_NAME)) {
+                        printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
+                        return -EBUSY;
+                }
+
                 ide_base=(unsigned long)ioremap(ide_phy_base,
                                                 ide_phy_end-ide_phy_base);
 
@@ -357,15 +370,14 @@ static void __init m8xx_ide_init_ports(hw_regs_t *hw, unsigned long data_port)
         hw->irq = ioport_dsc[data_port].irq;
         hw->ack_intr = (ide_ack_intr_t *)ide_interrupt_ack;
 
-        ide_hwifs[data_port].pio_mask = ATA_PIO4;
-        ide_hwifs[data_port].set_pio_mode = m8xx_ide_set_pio_mode;
-
         /* Enable Harddisk Interrupt,
          * and make it edge sensitive
          */
         /* (11-18) Set edge detect for irq, no wakeup from low power mode */
         ((immap_t *) IMAP_ADDR)->im_siu_conf.sc_siel |=
                         (0x80000000 >> ioport_dsc[data_port].irq);
+
+        return 0;
 }
 #endif  /* CONFIG_IDE_8xx_DIRECT */
 
@@ -426,10 +438,14 @@ static void m8xx_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
 #elif defined(CONFIG_IDE_EXT_DIRECT)
 
         printk("%s[%d] %s: not implemented yet!\n",
-                __FILE__,__LINE__,__FUNCTION__);
+                __FILE__, __LINE__, __func__);
 #endif /* defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_PCMCIA */
 }
 
+static const struct ide_port_ops m8xx_port_ops = {
+        .set_pio_mode           = m8xx_ide_set_pio_mode,
+};
+
 static void
 ide_interrupt_ack (void *dev)
 {
@@ -794,14 +810,30 @@ static int __init mpc8xx_ide_probe(void)
 
 #ifdef IDE0_BASE_OFFSET
         memset(&hw, 0, sizeof(hw));
-        m8xx_ide_init_ports(&hw, 0);
-        ide_init_port_hw(&ide_hwifs[0], &hw);
-        idx[0] = 0;
+        if (!m8xx_ide_init_ports(&hw, 0)) {
+                ide_hwif_t *hwif = ide_find_port();
+
+                if (hwif) {
+                        ide_init_port_hw(hwif, &hw);
+                        hwif->pio_mask = ATA_PIO4;
+                        hwif->port_ops = &m8xx_port_ops;
+
+                        idx[0] = hwif->index;
+                }
+        }
 #ifdef IDE1_BASE_OFFSET
         memset(&hw, 0, sizeof(hw));
-        m8xx_ide_init_ports(&hw, 1);
-        ide_init_port_hw(&ide_hwifs[1], &hw);
-        idx[1] = 1;
+        if (!m8xx_ide_init_ports(&hw, 1)) {
+                ide_hwif_t *mate = ide_find_port();
+
+                if (mate) {
+                        ide_init_port_hw(mate, &hw);
+                        mate->pio_mask = ATA_PIO4;
+                        mate->port_ops = &m8xx_port_ops;
+
+                        idx[1] = mate->index;
+                }
+        }
 #endif
 #endif
 
diff --git a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c
index 88619b50d9ef..3cac6b2790dd 100644
--- a/drivers/ide/ppc/pmac.c
+++ b/drivers/ide/ppc/pmac.c
@@ -79,8 +79,6 @@ typedef struct pmac_ide_hwif {
         
 } pmac_ide_hwif_t;
 
-static pmac_ide_hwif_t pmac_ide[MAX_HWIFS];
-
 enum {
         controller_ohare,       /* OHare based */
         controller_heathrow,    /* Heathrow/Paddington */
@@ -411,7 +409,7 @@ kauai_lookup_timing(struct kauai_timing* table, int cycle_time)
  */
 #define IDE_WAKEUP_DELAY        (1*HZ)
 
-static int pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif);
+static int pmac_ide_init_dma(ide_hwif_t *, const struct ide_port_info *);
 static int pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq);
 static void pmac_ide_selectproc(ide_drive_t *drive);
 static void pmac_ide_kauai_selectproc(ide_drive_t *drive);
@@ -419,7 +417,7 @@ static void pmac_ide_kauai_selectproc(ide_drive_t *drive);
 #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
 
 #define PMAC_IDE_REG(x) \
-        ((void __iomem *)((drive)->hwif->io_ports[IDE_DATA_OFFSET] + (x)))
+        ((void __iomem *)((drive)->hwif->io_ports.data_addr + (x)))
 
 /*
  * Apply the timings of the proper unit (master/slave) to the shared
@@ -920,12 +918,29 @@ pmac_ide_do_resume(ide_hwif_t *hwif)
         return 0;
 }
 
+static const struct ide_port_ops pmac_ide_ata6_port_ops = {
+        .set_pio_mode           = pmac_ide_set_pio_mode,
+        .set_dma_mode           = pmac_ide_set_dma_mode,
+        .selectproc             = pmac_ide_kauai_selectproc,
+};
+
+static const struct ide_port_ops pmac_ide_port_ops = {
+        .set_pio_mode           = pmac_ide_set_pio_mode,
+        .set_dma_mode           = pmac_ide_set_dma_mode,
+        .selectproc             = pmac_ide_selectproc,
+};
+
+static const struct ide_dma_ops pmac_dma_ops;
+
 static const struct ide_port_info pmac_port_info = {
+        .init_dma               = pmac_ide_init_dma,
         .chipset                = ide_pmac,
+#ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
+        .dma_ops                = &pmac_dma_ops,
+#endif
+        .port_ops               = &pmac_ide_port_ops,
         .host_flags             = IDE_HFLAG_SET_PIO_MODE_KEEP_DMA |
-                                  IDE_HFLAG_PIO_NO_DOWNGRADE |
                                   IDE_HFLAG_POST_SET_MODE |
-                                  IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
                                   IDE_HFLAG_UNMASK_IRQS,
         .pio_mask               = ATA_PIO4,
         .mwdma_mask             = ATA_MWDMA2,
@@ -950,12 +965,15 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif, hw_regs_t *hw)
         pmif->broken_dma = pmif->broken_dma_warn = 0;
         if (of_device_is_compatible(np, "shasta-ata")) {
                 pmif->kind = controller_sh_ata6;
+                d.port_ops = &pmac_ide_ata6_port_ops;
                 d.udma_mask = ATA_UDMA6;
         } else if (of_device_is_compatible(np, "kauai-ata")) {
                 pmif->kind = controller_un_ata6;
+                d.port_ops = &pmac_ide_ata6_port_ops;
                 d.udma_mask = ATA_UDMA5;
         } else if (of_device_is_compatible(np, "K2-UATA")) {
                 pmif->kind = controller_k2_ata6;
+                d.port_ops = &pmac_ide_ata6_port_ops;
                 d.udma_mask = ATA_UDMA5;
         } else if (of_device_is_compatible(np, "keylargo-ata")) {
                 if (strcmp(np->name, "ata-4") == 0) {
@@ -1032,37 +1050,29 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif, hw_regs_t *hw)
         default_hwif_mmiops(hwif);
         hwif->OUTBSYNC = pmac_outbsync;
 
-        /* Tell common code _not_ to mess with resources */
-        hwif->mmio = 1;
         hwif->hwif_data = pmif;
         ide_init_port_hw(hwif, hw);
-        hwif->noprobe = pmif->mediabay;
         hwif->cbl = pmif->cable_80 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
-        hwif->set_pio_mode = pmac_ide_set_pio_mode;
-        if (pmif->kind == controller_un_ata6
-            || pmif->kind == controller_k2_ata6
-            || pmif->kind == controller_sh_ata6)
-                hwif->selectproc = pmac_ide_kauai_selectproc;
-        else
-                hwif->selectproc = pmac_ide_selectproc;
-        hwif->set_dma_mode = pmac_ide_set_dma_mode;
 
         printk(KERN_INFO "ide%d: Found Apple %s controller, bus ID %d%s, irq %d\n",
                hwif->index, model_name[pmif->kind], pmif->aapl_bus_id,
                pmif->mediabay ? " (mediabay)" : "", hwif->irq);
-                        
+
+        if (pmif->mediabay) {
 #ifdef CONFIG_PMAC_MEDIABAY
-        if (pmif->mediabay && check_media_bay_by_base(pmif->regbase, MB_CD) == 0)
-                hwif->noprobe = 0;
-#endif /* CONFIG_PMAC_MEDIABAY */
+                if (check_media_bay_by_base(pmif->regbase, MB_CD)) {
+#else
+                if (1) {
+#endif
+                        hwif->drives[0].noprobe = 1;
+                        hwif->drives[1].noprobe = 1;
+                }
+        }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
         if (pmif->cable_80 == 0)
                 d.udma_mask &= ATA_UDMA2;
-        /* has a DBDMA controller channel */
-        if (pmif->dma_regs == 0 || pmac_ide_setup_dma(pmif, hwif) < 0)
 #endif
-                d.udma_mask = d.mwdma_mask = 0;
 
         idx[0] = hwif->index;
 
@@ -1076,8 +1086,9 @@ static void __devinit pmac_ide_init_ports(hw_regs_t *hw, unsigned long base)
         int i;
 
         for (i = 0; i < 8; ++i)
-                hw->io_ports[i] = base + i * 0x10;
-        hw->io_ports[8] = base + 0x160;
+                hw->io_ports_array[i] = base + i * 0x10;
+
+        hw->io_ports.ctl_addr = base + 0x160;
 }
 
 /*
@@ -1088,35 +1099,36 @@ pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_device_id *match)
 {
         void __iomem *base;
         unsigned long regbase;
-        int irq;
         ide_hwif_t *hwif;
         pmac_ide_hwif_t *pmif;
-        int i, rc;
+        int irq, rc;
         hw_regs_t hw;
 
-        i = 0;
-        while (i < MAX_HWIFS && (ide_hwifs[i].io_ports[IDE_DATA_OFFSET] != 0
-            || pmac_ide[i].node != NULL))
-                ++i;
-        if (i >= MAX_HWIFS) {
+        pmif = kzalloc(sizeof(*pmif), GFP_KERNEL);
+        if (pmif == NULL)
+                return -ENOMEM;
+
+        hwif = ide_find_port();
+        if (hwif == NULL) {
                 printk(KERN_ERR "ide-pmac: MacIO interface attach with no slot\n");
                 printk(KERN_ERR "          %s\n", mdev->ofdev.node->full_name);
-                return -ENODEV;
+                rc = -ENODEV;
+                goto out_free_pmif;
         }
 
-        pmif = &pmac_ide[i];
-        hwif = &ide_hwifs[i];
-
         if (macio_resource_count(mdev) == 0) {
-                printk(KERN_WARNING "ide%d: no address for %s\n",
-                       i, mdev->ofdev.node->full_name);
-                return -ENXIO;
+                printk(KERN_WARNING "ide-pmac: no address for %s\n",
+                                    mdev->ofdev.node->full_name);
+                rc = -ENXIO;
+                goto out_free_pmif;
         }
 
         /* Request memory resource for IO ports */
         if (macio_request_resource(mdev, 0, "ide-pmac (ports)")) {
-                printk(KERN_ERR "ide%d: can't request mmio resource !\n", i);
-                return -EBUSY;
+                printk(KERN_ERR "ide-pmac: can't request MMIO resource for "
+                                "%s!\n", mdev->ofdev.node->full_name);
+                rc = -EBUSY;
+                goto out_free_pmif;
         }
                         
         /* XXX This is bogus. Should be fixed in the registry by checking
@@ -1125,8 +1137,8 @@ pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_device_id *match)
          * where that happens though...
          */
         if (macio_irq_count(mdev) == 0) {
-                printk(KERN_WARNING "ide%d: no intrs for device %s, using 13\n",
-                        i, mdev->ofdev.node->full_name);
+                printk(KERN_WARNING "ide-pmac: no intrs for device %s, using "
+                                    "13\n", mdev->ofdev.node->full_name);
                 irq = irq_create_mapping(NULL, 13);
         } else
                 irq = macio_irq(mdev, 0);
@@ -1144,7 +1156,9 @@ pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_device_id *match)
 #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
         if (macio_resource_count(mdev) >= 2) {
                 if (macio_request_resource(mdev, 1, "ide-pmac (dma)"))
-                        printk(KERN_WARNING "ide%d: can't request DMA resource !\n", i);
+                        printk(KERN_WARNING "ide-pmac: can't request DMA "
+                                            "resource for %s!\n",
+                                            mdev->ofdev.node->full_name);
                 else
                         pmif->dma_regs = ioremap(macio_resource_start(mdev, 1), 0x1000);
         } else
@@ -1166,11 +1180,15 @@ pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_device_id *match)
                         iounmap(pmif->dma_regs);
                         macio_release_resource(mdev, 1);
                 }
-                memset(pmif, 0, sizeof(*pmif));
                 macio_release_resource(mdev, 0);
+                kfree(pmif);
         }
 
         return rc;
+
+out_free_pmif:
+        kfree(pmif);
+        return rc;
 }
 
 static int
@@ -1215,7 +1233,7 @@ pmac_ide_pci_attach(struct pci_dev *pdev, const struct pci_device_id *id)
         pmac_ide_hwif_t *pmif;
         void __iomem *base;
         unsigned long rbase, rlen;
-        int i, rc;
+        int rc;
         hw_regs_t hw;
 
         np = pci_device_to_OF_node(pdev);
@@ -1223,30 +1241,32 @@ pmac_ide_pci_attach(struct pci_dev *pdev, const struct pci_device_id *id)
                 printk(KERN_ERR "ide-pmac: cannot find MacIO node for Kauai ATA interface\n");
                 return -ENODEV;
         }
-        i = 0;
-        while (i < MAX_HWIFS && (ide_hwifs[i].io_ports[IDE_DATA_OFFSET] != 0
-            || pmac_ide[i].node != NULL))
-                ++i;
-        if (i >= MAX_HWIFS) {
+
+        pmif = kzalloc(sizeof(*pmif), GFP_KERNEL);
+        if (pmif == NULL)
+                return -ENOMEM;
+
+        hwif = ide_find_port();
+        if (hwif == NULL) {
                 printk(KERN_ERR "ide-pmac: PCI interface attach with no slot\n");
                 printk(KERN_ERR "          %s\n", np->full_name);
-                return -ENODEV;
+                rc = -ENODEV;
+                goto out_free_pmif;
         }
 
-        pmif = &pmac_ide[i];
-        hwif = &ide_hwifs[i];
-
         if (pci_enable_device(pdev)) {
-                printk(KERN_WARNING "ide%i: Can't enable PCI device for %s\n",
-                        i, np->full_name);
-                return -ENXIO;
+                printk(KERN_WARNING "ide-pmac: Can't enable PCI device for "
+                                    "%s\n", np->full_name);
+                rc = -ENXIO;
+                goto out_free_pmif;
         }
         pci_set_master(pdev);
                         
         if (pci_request_regions(pdev, "Kauai ATA")) {
-                printk(KERN_ERR "ide%d: Cannot obtain PCI resources for %s\n",
-                        i, np->full_name);
-                return -ENXIO;
+                printk(KERN_ERR "ide-pmac: Cannot obtain PCI resources for "
+                                "%s\n", np->full_name);
+                rc = -ENXIO;
+                goto out_free_pmif;
         }
 
         hwif->dev = &pdev->dev;
@@ -1276,11 +1296,15 @@ pmac_ide_pci_attach(struct pci_dev *pdev, const struct pci_device_id *id)
                 /* The inteface is released to the common IDE layer */
                 pci_set_drvdata(pdev, NULL);
                 iounmap(base);
-                memset(pmif, 0, sizeof(*pmif));
                 pci_release_regions(pdev);
+                kfree(pmif);
         }
 
         return rc;
+
+out_free_pmif:
+        kfree(pmif);
+        return rc;
 }
 
 static int
@@ -1652,18 +1676,31 @@ pmac_ide_dma_lost_irq (ide_drive_t *drive)
         printk(KERN_ERR "ide-pmac lost interrupt, dma status: %lx\n", status);
 }
 
+static const struct ide_dma_ops pmac_dma_ops = {
+        .dma_host_set           = pmac_ide_dma_host_set,
+        .dma_setup              = pmac_ide_dma_setup,
+        .dma_exec_cmd           = pmac_ide_dma_exec_cmd,
+        .dma_start              = pmac_ide_dma_start,
+        .dma_end                = pmac_ide_dma_end,
+        .dma_test_irq           = pmac_ide_dma_test_irq,
+        .dma_timeout            = ide_dma_timeout,
+        .dma_lost_irq           = pmac_ide_dma_lost_irq,
+};
+
 /*
  * Allocate the data structures needed for using DMA with an interface
  * and fill the proper list of functions pointers
  */
-static int __devinit pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
+static int __devinit pmac_ide_init_dma(ide_hwif_t *hwif,
+                                       const struct ide_port_info *d)
 {
+        pmac_ide_hwif_t *pmif = (pmac_ide_hwif_t *)hwif->hwif_data;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
 
         /* We won't need pci_dev if we switch to generic consistent
          * DMA routines ...
          */
-        if (dev == NULL)
+        if (dev == NULL || pmif->dma_regs == 0)
                 return -ENODEV;
         /*
          * Allocate space for the DBDMA commands.
@@ -1682,18 +1719,14 @@ static int __devinit pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
 
         hwif->sg_max_nents = MAX_DCMDS;
 
-        hwif->dma_host_set = &pmac_ide_dma_host_set;
-        hwif->dma_setup = &pmac_ide_dma_setup;
-        hwif->dma_exec_cmd = &pmac_ide_dma_exec_cmd;
-        hwif->dma_start = &pmac_ide_dma_start;
-        hwif->ide_dma_end = &pmac_ide_dma_end;
-        hwif->ide_dma_test_irq = &pmac_ide_dma_test_irq;
-        hwif->dma_timeout = &ide_dma_timeout;
-        hwif->dma_lost_irq = &pmac_ide_dma_lost_irq;
-
         return 0;
 }
-
+#else
+static int __devinit pmac_ide_init_dma(ide_hwif_t *hwif,
+                                       const struct ide_port_info *d)
+{
+        return -EOPNOTSUPP;
+}
 #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
 
 module_init(pmac_ide_probe);
diff --git a/drivers/ide/setup-pci.c b/drivers/ide/setup-pci.c
index f7ede0e42881..5171601fb255 100644
--- a/drivers/ide/setup-pci.c
+++ b/drivers/ide/setup-pci.c
@@ -20,73 +20,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 
-
-/**
- *      ide_match_hwif  -       match a PCI IDE against an ide_hwif
- *      @io_base: I/O base of device
- *      @bootable: set if its bootable
- *      @name: name of device
- *
- *      Match a PCI IDE port against an entry in ide_hwifs[],
- *      based on io_base port if possible. Return the matching hwif,
- *      or a new hwif. If we find an error (clashing, out of devices, etc)
- *      return NULL
- *
- *      FIXME: we need to handle mmio matches here too
- */
-
-static ide_hwif_t *ide_match_hwif(unsigned long io_base, u8 bootable, const char *name)
-{
-        int h;
-        ide_hwif_t *hwif;
-
-        /*
-         * Look for a hwif with matching io_base default value.
-         * If chipset is "ide_unknown", then claim that hwif slot.
-         * Otherwise, some other chipset has already claimed it..  :(
-         */
-        for (h = 0; h < MAX_HWIFS; ++h) {
-                hwif = &ide_hwifs[h];
-                if (hwif->io_ports[IDE_DATA_OFFSET] == io_base) {
-                        if (hwif->chipset == ide_unknown)
-                                return hwif; /* match */
-                        printk(KERN_ERR "%s: port 0x%04lx already claimed by %s\n",
-                                name, io_base, hwif->name);
-                        return NULL;    /* already claimed */
-                }
-        }
-        /*
-         * Okay, there is no hwif matching our io_base,
-         * so we'll just claim an unassigned slot.
-         * Give preference to claiming other slots before claiming ide0/ide1,
-         * just in case there's another interface yet-to-be-scanned
-         * which uses ports 1f0/170 (the ide0/ide1 defaults).
-         *
-         * Unless there is a bootable card that does not use the standard
-         * ports 1f0/170 (the ide0/ide1 defaults). The (bootable) flag.
-         */
-        if (bootable) {
-                for (h = 0; h < MAX_HWIFS; ++h) {
-                        hwif = &ide_hwifs[h];
-                        if (hwif->chipset == ide_unknown)
-                                return hwif;    /* pick an unused entry */
-                }
-        } else {
-                for (h = 2; h < MAX_HWIFS; ++h) {
-                        hwif = ide_hwifs + h;
-                        if (hwif->chipset == ide_unknown)
-                                return hwif;    /* pick an unused entry */
-                }
-        }
-        for (h = 0; h < 2 && h < MAX_HWIFS; ++h) {
-                hwif = ide_hwifs + h;
-                if (hwif->chipset == ide_unknown)
-                        return hwif;    /* pick an unused entry */
-        }
-        printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n", name);
-        return NULL;
-}
-
 /**
  *      ide_setup_pci_baseregs  -       place a PCI IDE controller native
  *      @dev: PCI device of interface to switch native
@@ -94,13 +27,13 @@ static ide_hwif_t *ide_match_hwif(unsigned long io_base, u8 bootable, const char
  *
  *      We attempt to place the PCI interface into PCI native mode. If
  *      we succeed the BARs are ok and the controller is in PCI mode.
- *      Returns 0 on success or an errno code. 
+ *      Returns 0 on success or an errno code.
  *
  *      FIXME: if we program the interface and then fail to set the BARS
  *      we don't switch it back to legacy mode. Do we actually care ??
  */
- 
-static int ide_setup_pci_baseregs (struct pci_dev *dev, const char *name)
+
+static int ide_setup_pci_baseregs(struct pci_dev *dev, const char *name)
 {
         u8 progif = 0;
 
@@ -139,16 +72,16 @@ static void ide_pci_clear_simplex(unsigned long dma_base, const char *name)
 }
 
 /**
- *      ide_get_or_set_dma_base         -       setup BMIBA
- *      @d: IDE port info
+ *      ide_pci_dma_base        -       setup BMIBA
  *      @hwif: IDE interface
+ *      @d: IDE port info
  *
  *      Fetch the DMA Bus-Master-I/O-Base-Address (BMIBA) from PCI space.
  *      Where a device has a partner that is already in DMA mode we check
  *      and enforce IDE simplex rules.
  */
 
-static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_hwif_t *hwif)
+unsigned long ide_pci_dma_base(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         unsigned long dma_base = 0;
@@ -199,6 +132,31 @@ static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_
 out:
         return dma_base;
 }
+EXPORT_SYMBOL_GPL(ide_pci_dma_base);
+
+/*
+ * Set up BM-DMA capability (PnP BIOS should have done this)
+ */
+int ide_pci_set_master(struct pci_dev *dev, const char *name)
+{
+        u16 pcicmd;
+
+        pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
+
+        if ((pcicmd & PCI_COMMAND_MASTER) == 0) {
+                pci_set_master(dev);
+
+                if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) ||
+                    (pcicmd & PCI_COMMAND_MASTER) == 0) {
+                        printk(KERN_ERR "%s: error updating PCICMD on %s\n",
+                                        name, pci_name(dev));
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ide_pci_set_master);
 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
 
 void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
@@ -207,7 +165,6 @@ void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
                          " PCI slot %s\n", d->name, dev->vendor, dev->device,
                          dev->revision, pci_name(dev));
 }
-
 EXPORT_SYMBOL_GPL(ide_setup_pci_noise);
 
 
@@ -220,13 +177,13 @@ EXPORT_SYMBOL_GPL(ide_setup_pci_noise);
  *      but if that fails then we only need IO space. The PCI code should
  *      have setup the proper resources for us already for controllers in
  *      legacy mode.
- *      
+ *
  *      Returns zero on success or an error code
  */
 
 static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
 {
-        int ret;
+        int ret, bars;
 
         if (pci_enable_device(dev)) {
                 ret = pci_enable_device_io(dev);
@@ -249,13 +206,21 @@ static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
                 goto out;
         }
 
-        /* FIXME: Temporary - until we put in the hotplug interface logic
-           Check that the bits we want are not in use by someone else. */
-        ret = pci_request_region(dev, 4, "ide_tmp");
-        if (ret < 0)
-                goto out;
+        if (d->host_flags & IDE_HFLAG_SINGLE)
+                bars = (1 << 2) - 1;
+        else
+                bars = (1 << 4) - 1;
+
+        if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
+                if (d->host_flags & IDE_HFLAG_CS5520)
+                        bars |= (1 << 2);
+                else
+                        bars |= (1 << 4);
+        }
 
-        pci_release_region(dev, 4);
+        ret = pci_request_selected_regions(dev, bars, d->name);
+        if (ret < 0)
+                printk(KERN_ERR "%s: can't reserve resources\n", d->name);
 out:
         return ret;
 }
@@ -279,8 +244,8 @@ static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
          * Maybe the user deliberately *disabled* the device,
          * but we'll eventually ignore it again if no drives respond.
          */
-        if (ide_setup_pci_baseregs(dev, d->name) || pci_write_config_word(dev, PCI_COMMAND, pcicmd|PCI_COMMAND_IO)) 
-        {
+        if (ide_setup_pci_baseregs(dev, d->name) ||
+            pci_write_config_word(dev, PCI_COMMAND, pcicmd | PCI_COMMAND_IO)) {
                 printk(KERN_INFO "%s: device disabled (BIOS)\n", d->name);
                 return -ENODEV;
         }
@@ -301,26 +266,24 @@ static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
  *      @d: IDE port info
  *      @bar: BAR number
  *
- *      Checks if a BAR is configured and points to MMIO space. If so
- *      print an error and return an error code. Otherwise return 0
+ *      Checks if a BAR is configured and points to MMIO space. If so,
+ *      return an error code. Otherwise return 0
  */
 
-static int ide_pci_check_iomem(struct pci_dev *dev, const struct ide_port_info *d, int bar)
+static int ide_pci_check_iomem(struct pci_dev *dev, const struct ide_port_info *d,
+                               int bar)
 {
         ulong flags = pci_resource_flags(dev, bar);
-        
+
         /* Unconfigured ? */
         if (!flags || pci_resource_len(dev, bar) == 0)
                 return 0;
 
-        /* I/O space */         
-        if(flags & PCI_BASE_ADDRESS_IO_MASK)
+        /* I/O space */
+        if (flags & IORESOURCE_IO)
                 return 0;
-                
+
         /* Bad */
-        printk(KERN_ERR "%s: IO baseregs (BIOS) are reported "
-                        "as MEM, report to "
-                        "<andre@linux-ide.org>.\n", d->name);
         return -EINVAL;
 }
 
@@ -344,14 +307,16 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
 {
         unsigned long ctl = 0, base = 0;
         ide_hwif_t *hwif;
-        u8 bootable = (d->host_flags & IDE_HFLAG_BOOTABLE) ? 1 : 0;
         struct hw_regs_s hw;
 
         if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
-                /*  Possibly we should fail if these checks report true */
-                ide_pci_check_iomem(dev, d, 2*port);
-                ide_pci_check_iomem(dev, d, 2*port+1);
- 
+                if (ide_pci_check_iomem(dev, d, 2 * port) ||
+                    ide_pci_check_iomem(dev, d, 2 * port + 1)) {
+                        printk(KERN_ERR "%s: I/O baseregs (BIOS) are reported "
+                                        "as MEM for port %d!\n", d->name, port);
+                        return NULL;
+                }
+
                 ctl  = pci_resource_start(dev, 2*port+1);
                 base = pci_resource_start(dev, 2*port);
                 if ((ctl && !base) || (base && !ctl)) {
@@ -360,14 +325,18 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
                         return NULL;
                 }
         }
-        if (!ctl)
-        {
+        if (!ctl) {
                 /* Use default values */
                 ctl = port ? 0x374 : 0x3f4;
                 base = port ? 0x170 : 0x1f0;
         }
-        if ((hwif = ide_match_hwif(base, bootable, d->name)) == NULL)
-                return NULL;    /* no room in ide_hwifs[] */
+
+        hwif = ide_find_port_slot(d);
+        if (hwif == NULL) {
+                printk(KERN_ERR "%s: too many IDE interfaces, no room in "
+                                "table\n", d->name);
+                return NULL;
+        }
 
         memset(&hw, 0, sizeof(hw));
         hw.irq = irq;
@@ -378,7 +347,6 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
         ide_init_port_hw(hwif, &hw);
 
         hwif->dev = &dev->dev;
-        hwif->cds = d;
 
         return hwif;
 }
@@ -394,40 +362,33 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
  *      state
  */
 
-void ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
+int ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
-        u16 pcicmd;
-
-        pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
 
         if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
             ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
              (dev->class & 0x80))) {
-                unsigned long dma_base = ide_get_or_set_dma_base(d, hwif);
-                if (dma_base && !(pcicmd & PCI_COMMAND_MASTER)) {
-                        /*
-                         * Set up BM-DMA capability
-                         * (PnP BIOS should have done this)
-                         */
-                        pci_set_master(dev);
-                        if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) || !(pcicmd & PCI_COMMAND_MASTER)) {
-                                printk(KERN_ERR "%s: %s error updating PCICMD\n",
-                                        hwif->name, d->name);
-                                dma_base = 0;
-                        }
-                }
-                if (dma_base) {
-                        if (d->init_dma) {
-                                d->init_dma(hwif, dma_base);
-                        } else {
-                                ide_setup_dma(hwif, dma_base);
-                        }
-                } else {
-                        printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
-                                "(BIOS)\n", hwif->name, d->name);
-                }
+                unsigned long base = ide_pci_dma_base(hwif, d);
+
+                if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
+                        return -1;
+
+                if (hwif->mmio)
+                        printk(KERN_INFO "    %s: MMIO-DMA\n", hwif->name);
+                else
+                        printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx\n",
+                                         hwif->name, base, base + 7);
+
+                hwif->extra_base = base + (hwif->channel ? 8 : 16);
+
+                if (ide_allocate_dma_engine(hwif))
+                        return -1;
+
+                ide_setup_dma(hwif, base);
         }
+
+        return 0;
 }
 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
 
@@ -514,7 +475,6 @@ void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d, int
                 *(idx + port) = hwif->index;
         }
 }
-
 EXPORT_SYMBOL_GPL(ide_pci_setup_ports);
 
 /*
@@ -597,7 +557,6 @@ int ide_setup_pci_device(struct pci_dev *dev, const struct ide_port_info *d)
 
         return ret;
 }
-
 EXPORT_SYMBOL_GPL(ide_setup_pci_device);
 
 int ide_setup_pci_devices(struct pci_dev *dev1, struct pci_dev *dev2,
@@ -621,5 +580,4 @@ int ide_setup_pci_devices(struct pci_dev *dev1, struct pci_dev *dev2,
 out:
         return ret;
 }
-
 EXPORT_SYMBOL_GPL(ide_setup_pci_devices);
diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 0d13fe0a260b..3d6d9461c31d 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -160,6 +160,7 @@ struct ehca_qp {
         };
         u32 qp_type;
         enum ehca_ext_qp_type ext_type;
+        enum ib_qp_state state;
         struct ipz_queue ipz_squeue;
         struct ipz_queue ipz_rqueue;
         struct h_galpas galpas;
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index b5ca94c6b8d9..ca5eb0cb628c 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -633,7 +633,7 @@ static inline int find_next_online_cpu(struct ehca_comp_pool *pool)
         unsigned long flags;
 
         WARN_ON_ONCE(!in_interrupt());
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 3)
                 ehca_dmp(&cpu_online_map, sizeof(cpumask_t), "");
 
         spin_lock_irqsave(&pool->last_cpu_lock, flags);
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index 65b3362cdb9b..65048976198c 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -50,7 +50,7 @@
 #include "ehca_tools.h"
 #include "hcp_if.h"
 
-#define HCAD_VERSION "0025"
+#define HCAD_VERSION "0026"
 
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
@@ -60,7 +60,6 @@ MODULE_VERSION(HCAD_VERSION);
 static int ehca_open_aqp1     = 0;
 static int ehca_hw_level      = 0;
 static int ehca_poll_all_eqs  = 1;
-static int ehca_mr_largepage  = 1;
 
 int ehca_debug_level   = 0;
 int ehca_nr_ports      = 2;
@@ -70,45 +69,40 @@ int ehca_static_rate   = -1;
 int ehca_scaling_code  = 0;
 int ehca_lock_hcalls   = -1;
 
-module_param_named(open_aqp1,     ehca_open_aqp1,     int, S_IRUGO);
-module_param_named(debug_level,   ehca_debug_level,   int, S_IRUGO);
-module_param_named(hw_level,      ehca_hw_level,      int, S_IRUGO);
-module_param_named(nr_ports,      ehca_nr_ports,      int, S_IRUGO);
-module_param_named(use_hp_mr,     ehca_use_hp_mr,     int, S_IRUGO);
-module_param_named(port_act_time, ehca_port_act_time, int, S_IRUGO);
-module_param_named(poll_all_eqs,  ehca_poll_all_eqs,  int, S_IRUGO);
-module_param_named(static_rate,   ehca_static_rate,   int, S_IRUGO);
-module_param_named(scaling_code,  ehca_scaling_code,  int, S_IRUGO);
-module_param_named(mr_largepage,  ehca_mr_largepage,  int, S_IRUGO);
+module_param_named(open_aqp1,     ehca_open_aqp1,     bool, S_IRUGO);
+module_param_named(debug_level,   ehca_debug_level,   int,  S_IRUGO);
+module_param_named(hw_level,      ehca_hw_level,      int,  S_IRUGO);
+module_param_named(nr_ports,      ehca_nr_ports,      int,  S_IRUGO);
+module_param_named(use_hp_mr,     ehca_use_hp_mr,     bool, S_IRUGO);
+module_param_named(port_act_time, ehca_port_act_time, int,  S_IRUGO);
+module_param_named(poll_all_eqs,  ehca_poll_all_eqs,  bool, S_IRUGO);
+module_param_named(static_rate,   ehca_static_rate,   int,  S_IRUGO);
+module_param_named(scaling_code,  ehca_scaling_code,  bool, S_IRUGO);
 module_param_named(lock_hcalls,   ehca_lock_hcalls,   bool, S_IRUGO);
 
 MODULE_PARM_DESC(open_aqp1,
-                 "AQP1 on startup (0: no (default), 1: yes)");
+                 "Open AQP1 on startup (default: no)");
 MODULE_PARM_DESC(debug_level,
-                 "debug level"
-                 " (0: no debug traces (default), 1: with debug traces)");
+                 "Amount of debug output (0: none (default), 1: traces, "
+                 "2: some dumps, 3: lots)");
 MODULE_PARM_DESC(hw_level,
-                 "hardware level"
-                 " (0: autosensing (default), 1: v. 0.20, 2: v. 0.21)");
+                 "Hardware level (0: autosensing (default), "
+                 "0x10..0x14: eHCA, 0x20..0x23: eHCA2)");
 MODULE_PARM_DESC(nr_ports,
                  "number of connected ports (-1: autodetect, 1: port one only, "
                  "2: two ports (default)");
 MODULE_PARM_DESC(use_hp_mr,
-                 "high performance MRs (0: no (default), 1: yes)");
+                 "Use high performance MRs (default: no)");
 MODULE_PARM_DESC(port_act_time,
-                 "time to wait for port activation (default: 30 sec)");
+                 "Time to wait for port activation (default: 30 sec)");
 MODULE_PARM_DESC(poll_all_eqs,
-                 "polls all event queues periodically"
-                 " (0: no, 1: yes (default))");
+                 "Poll all event queues periodically (default: yes)");
 MODULE_PARM_DESC(static_rate,
-                 "set permanent static rate (default: disabled)");
+                 "Set permanent static rate (default: no static rate)");
 MODULE_PARM_DESC(scaling_code,
-                 "set scaling code (0: disabled/default, 1: enabled)");
-MODULE_PARM_DESC(mr_largepage,
-                 "use large page for MR (0: use PAGE_SIZE (default), "
-                 "1: use large page depending on MR size");
+                 "Enable scaling code (default: no)");
 MODULE_PARM_DESC(lock_hcalls,
-                 "serialize all hCalls made by the driver "
+                 "Serialize all hCalls made by the driver "
                  "(default: autodetect)");
 
 DEFINE_RWLOCK(ehca_qp_idr_lock);
@@ -275,6 +269,7 @@ static int ehca_sense_attributes(struct ehca_shca *shca)
         u64 h_ret;
         struct hipz_query_hca *rblock;
         struct hipz_query_port *port;
+        const char *loc_code;
 
         static const u32 pgsize_map[] = {
                 HCA_CAP_MR_PGSIZE_4K,  0x1000,
@@ -283,6 +278,12 @@ static int ehca_sense_attributes(struct ehca_shca *shca)
                 HCA_CAP_MR_PGSIZE_16M, 0x1000000,
         };
 
+        ehca_gen_dbg("Probing adapter %s...",
+                     shca->ofdev->node->full_name);
+        loc_code = of_get_property(shca->ofdev->node, "ibm,loc-code", NULL);
+        if (loc_code)
+                ehca_gen_dbg(" ... location lode=%s", loc_code);
+
         rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
         if (!rblock) {
                 ehca_gen_err("Cannot allocate rblock memory.");
@@ -350,11 +351,9 @@ static int ehca_sense_attributes(struct ehca_shca *shca)
 
         /* translate supported MR page sizes; always support 4K */
         shca->hca_cap_mr_pgsize = EHCA_PAGESIZE;
-        if (ehca_mr_largepage) { /* support extra sizes only if enabled */
-                for (i = 0; i < ARRAY_SIZE(pgsize_map); i += 2)
-                        if (rblock->memory_page_size_supported & pgsize_map[i])
-                                shca->hca_cap_mr_pgsize |= pgsize_map[i + 1];
-        }
+        for (i = 0; i < ARRAY_SIZE(pgsize_map); i += 2)
+                if (rblock->memory_page_size_supported & pgsize_map[i])
+                        shca->hca_cap_mr_pgsize |= pgsize_map[i + 1];
 
         /* query max MTU from first port -- it's the same for all ports */
         port = (struct hipz_query_port *)rblock;
@@ -567,8 +566,7 @@ static int ehca_destroy_aqp1(struct ehca_sport *sport)
 
 static ssize_t ehca_show_debug_level(struct device_driver *ddp, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%d\n",
-                        ehca_debug_level);
+        return snprintf(buf, PAGE_SIZE, "%d\n", ehca_debug_level);
 }
 
 static ssize_t ehca_store_debug_level(struct device_driver *ddp,
@@ -657,14 +655,6 @@ static ssize_t ehca_show_adapter_handle(struct device *dev,
 }
 static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL);
 
-static ssize_t ehca_show_mr_largepage(struct device *dev,
-                                      struct device_attribute *attr,
-                                      char *buf)
-{
-        return sprintf(buf, "%d\n", ehca_mr_largepage);
-}
-static DEVICE_ATTR(mr_largepage, S_IRUGO, ehca_show_mr_largepage, NULL);
-
 static struct attribute *ehca_dev_attrs[] = {
         &dev_attr_adapter_handle.attr,
         &dev_attr_num_ports.attr,
@@ -681,7 +671,6 @@ static struct attribute *ehca_dev_attrs[] = {
         &dev_attr_cur_mw.attr,
         &dev_attr_max_pd.attr,
         &dev_attr_max_ah.attr,
-        &dev_attr_mr_largepage.attr,
         NULL
 };
 
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index f26997fc00f8..46ae4eb2c4e1 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -1794,8 +1794,9 @@ static int ehca_check_kpages_per_ate(struct scatterlist *page_list,
         int t;
         for (t = start_idx; t <= end_idx; t++) {
                 u64 pgaddr = page_to_pfn(sg_page(&page_list[t])) << PAGE_SHIFT;
-                ehca_gen_dbg("chunk_page=%lx value=%016lx", pgaddr,
-                             *(u64 *)abs_to_virt(phys_to_abs(pgaddr)));
+                if (ehca_debug_level >= 3)
+                        ehca_gen_dbg("chunk_page=%lx value=%016lx", pgaddr,
+                                     *(u64 *)abs_to_virt(phys_to_abs(pgaddr)));
                 if (pgaddr - PAGE_SIZE != *prev_pgaddr) {
                         ehca_gen_err("uncontiguous page found pgaddr=%lx "
                                      "prev_pgaddr=%lx page_list_i=%x",
@@ -1862,10 +1863,13 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                                                 pgaddr &
                                                 ~(pginfo->hwpage_size - 1));
                                 }
-                                ehca_gen_dbg("kpage=%lx chunk_page=%lx "
-                                             "value=%016lx", *kpage, pgaddr,
-                                             *(u64 *)abs_to_virt(
-                                                     phys_to_abs(pgaddr)));
+                                if (ehca_debug_level >= 3) {
+                                        u64 val = *(u64 *)abs_to_virt(
+                                                phys_to_abs(pgaddr));
+                                        ehca_gen_dbg("kpage=%lx chunk_page=%lx "
+                                                     "value=%016lx",
+                                                     *kpage, pgaddr, val);
+                                }
                                 prev_pgaddr = pgaddr;
                                 i++;
                                 pginfo->kpage_cnt++;
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 3eb14a52cbf2..57bef1152cc2 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -550,6 +550,7 @@ static struct ehca_qp *internal_create_qp(
         spin_lock_init(&my_qp->spinlock_r);
         my_qp->qp_type = qp_type;
         my_qp->ext_type = parms.ext_type;
+        my_qp->state = IB_QPS_RESET;
 
         if (init_attr->recv_cq)
                 my_qp->recv_cq =
@@ -965,7 +966,7 @@ static int prepare_sqe_rts(struct ehca_qp *my_qp, struct ehca_shca *shca,
                  qp_num, bad_send_wqe_p);
         /* convert wqe pointer to vadr */
         bad_send_wqe_v = abs_to_virt((u64)bad_send_wqe_p);
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(bad_send_wqe_v, 32, "qp_num=%x bad_wqe", qp_num);
         squeue = &my_qp->ipz_squeue;
         if (ipz_queue_abs_to_offset(squeue, (u64)bad_send_wqe_p, &q_ofs)) {
@@ -978,7 +979,7 @@ static int prepare_sqe_rts(struct ehca_qp *my_qp, struct ehca_shca *shca,
         wqe = (struct ehca_wqe *)ipz_qeit_calc(squeue, q_ofs);
         *bad_wqe_cnt = 0;
         while (wqe->optype != 0xff && wqe->wqef != 0xff) {
-                if (ehca_debug_level)
+                if (ehca_debug_level >= 2)
                         ehca_dmp(wqe, 32, "qp_num=%x wqe", qp_num);
                 wqe->nr_of_data_seg = 0; /* suppress data access */
                 wqe->wqef = WQEF_PURGE; /* WQE to be purged */
@@ -1450,7 +1451,7 @@ static int internal_modify_qp(struct ib_qp *ibqp,
                 /* no support for max_send/recv_sge yet */
         }
 
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(mqpcb, 4*70, "qp_num=%x", ibqp->qp_num);
 
         h_ret = hipz_h_modify_qp(shca->ipz_hca_handle,
@@ -1508,6 +1509,8 @@ static int internal_modify_qp(struct ib_qp *ibqp,
         if (attr_mask & IB_QP_QKEY)
                 my_qp->qkey = attr->qkey;
 
+        my_qp->state = qp_new_state;
+
 modify_qp_exit2:
         if (squeue_locked) { /* this means: sqe -> rts */
                 spin_unlock_irqrestore(&my_qp->spinlock_s, flags);
@@ -1763,7 +1766,7 @@ int ehca_query_qp(struct ib_qp *qp,
         if (qp_init_attr)
                 *qp_init_attr = my_qp->init_attr;
 
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(qpcb, 4*70, "qp_num=%x", qp->qp_num);
 
 query_qp_exit1:
@@ -1811,7 +1814,7 @@ int ehca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
                 goto modify_srq_exit0;
         }
 
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(mqpcb, 4*70, "qp_num=%x", my_qp->real_qp_num);
 
         h_ret = hipz_h_modify_qp(shca->ipz_hca_handle, my_qp->ipz_qp_handle,
@@ -1864,7 +1867,7 @@ int ehca_query_srq(struct ib_srq *srq, struct ib_srq_attr *srq_attr)
         srq_attr->srq_limit = EHCA_BMASK_GET(
                 MQPCB_CURR_SRQ_LIMIT, qpcb->curr_srq_limit);
 
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(qpcb, 4*70, "qp_num=%x", my_qp->real_qp_num);
 
 query_srq_exit1:
diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index a20bbf466188..bbe0436f4f75 100644
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -81,7 +81,7 @@ static inline int ehca_write_rwqe(struct ipz_queue *ipz_rqueue,
                         recv_wr->sg_list[cnt_ds].length;
         }
 
-        if (ehca_debug_level) {
+        if (ehca_debug_level >= 3) {
                 ehca_gen_dbg("RECEIVE WQE written into ipz_rqueue=%p",
                              ipz_rqueue);
                 ehca_dmp(wqe_p, 16*(6 + wqe_p->nr_of_data_seg), "recv wqe");
@@ -281,7 +281,7 @@ static inline int ehca_write_swqe(struct ehca_qp *qp,
                 return -EINVAL;
         }
 
-        if (ehca_debug_level) {
+        if (ehca_debug_level >= 3) {
                 ehca_gen_dbg("SEND WQE written into queue qp=%p ", qp);
                 ehca_dmp( wqe_p, 16*(6 + wqe_p->nr_of_data_seg), "send wqe");
         }
@@ -421,6 +421,11 @@ int ehca_post_send(struct ib_qp *qp,
         int ret = 0;
         unsigned long flags;
 
+        if (unlikely(my_qp->state != IB_QPS_RTS)) {
+                ehca_err(qp->device, "QP not in RTS state  qpn=%x", qp->qp_num);
+                return -EINVAL;
+        }
+
         /* LOCK the QUEUE */
         spin_lock_irqsave(&my_qp->spinlock_s, flags);
 
@@ -454,13 +459,14 @@ int ehca_post_send(struct ib_qp *qp,
                         goto post_send_exit0;
                 }
                 wqe_cnt++;
-                ehca_dbg(qp->device, "ehca_qp=%p qp_num=%x wqe_cnt=%d",
-                         my_qp, qp->qp_num, wqe_cnt);
         } /* eof for cur_send_wr */
 
 post_send_exit0:
         iosync(); /* serialize GAL register access */
         hipz_update_sqa(my_qp, wqe_cnt);
+        if (unlikely(ret || ehca_debug_level >= 2))
+                ehca_dbg(qp->device, "ehca_qp=%p qp_num=%x wqe_cnt=%d ret=%i",
+                         my_qp, qp->qp_num, wqe_cnt, ret);
         my_qp->message_count += wqe_cnt;
         spin_unlock_irqrestore(&my_qp->spinlock_s, flags);
         return ret;
@@ -520,13 +526,14 @@ static int internal_post_recv(struct ehca_qp *my_qp,
                         goto post_recv_exit0;
                 }
                 wqe_cnt++;
-                ehca_dbg(dev, "ehca_qp=%p qp_num=%x wqe_cnt=%d",
-                         my_qp, my_qp->real_qp_num, wqe_cnt);
         } /* eof for cur_recv_wr */
 
 post_recv_exit0:
         iosync(); /* serialize GAL register access */
         hipz_update_rqa(my_qp, wqe_cnt);
+        if (unlikely(ret || ehca_debug_level >= 2))
+            ehca_dbg(dev, "ehca_qp=%p qp_num=%x wqe_cnt=%d ret=%i",
+                     my_qp, my_qp->real_qp_num, wqe_cnt, ret);
         spin_unlock_irqrestore(&my_qp->spinlock_r, flags);
         return ret;
 }
@@ -570,16 +577,17 @@ static inline int ehca_poll_cq_one(struct ib_cq *cq, struct ib_wc *wc)
         struct ehca_cq *my_cq = container_of(cq, struct ehca_cq, ib_cq);
         struct ehca_cqe *cqe;
         struct ehca_qp *my_qp;
-        int cqe_count = 0;
+        int cqe_count = 0, is_error;
 
 poll_cq_one_read_cqe:
         cqe = (struct ehca_cqe *)
                 ipz_qeit_get_inc_valid(&my_cq->ipz_queue);
         if (!cqe) {
                 ret = -EAGAIN;
-                ehca_dbg(cq->device, "Completion queue is empty ehca_cq=%p "
-                         "cq_num=%x ret=%i", my_cq, my_cq->cq_number, ret);
-                goto  poll_cq_one_exit0;
+                if (ehca_debug_level >= 3)
+                        ehca_dbg(cq->device, "Completion queue is empty  "
+                                 "my_cq=%p cq_num=%x", my_cq, my_cq->cq_number);
+                goto poll_cq_one_exit0;
         }
 
         /* prevents loads being reordered across this point */
@@ -609,7 +617,7 @@ poll_cq_one_read_cqe:
                         ehca_dbg(cq->device,
                                  "Got CQE with purged bit qp_num=%x src_qp=%x",
                                  cqe->local_qp_number, cqe->remote_qp_number);
-                        if (ehca_debug_level)
+                        if (ehca_debug_level >= 2)
                                 ehca_dmp(cqe, 64, "qp_num=%x src_qp=%x",
                                          cqe->local_qp_number,
                                          cqe->remote_qp_number);
@@ -622,11 +630,13 @@ poll_cq_one_read_cqe:
                 }
         }
 
-        /* tracing cqe */
-        if (unlikely(ehca_debug_level)) {
+        is_error = cqe->status & WC_STATUS_ERROR_BIT;
+
+        /* trace error CQEs if debug_level >= 1, trace all CQEs if >= 3 */
+        if (unlikely(ehca_debug_level >= 3 || (ehca_debug_level && is_error))) {
                 ehca_dbg(cq->device,
-                         "Received COMPLETION ehca_cq=%p cq_num=%x -----",
-                         my_cq, my_cq->cq_number);
+                         "Received %sCOMPLETION ehca_cq=%p cq_num=%x -----",
+                         is_error ? "ERROR " : "", my_cq, my_cq->cq_number);
                 ehca_dmp(cqe, 64, "ehca_cq=%p cq_num=%x",
                          my_cq, my_cq->cq_number);
                 ehca_dbg(cq->device,
@@ -649,8 +659,9 @@ poll_cq_one_read_cqe:
                 /* update also queue adder to throw away this entry!!! */
                 goto poll_cq_one_exit0;
         }
+
         /* eval ib_wc_status */
-        if (unlikely(cqe->status & WC_STATUS_ERROR_BIT)) {
+        if (unlikely(is_error)) {
                 /* complete with errors */
                 map_ib_wc_status(cqe->status, &wc->status);
                 wc->vendor_err = wc->status;
@@ -671,14 +682,6 @@ poll_cq_one_read_cqe:
         wc->imm_data = cpu_to_be32(cqe->immediate_data);
         wc->sl = cqe->service_level;
 
-        if (unlikely(wc->status != IB_WC_SUCCESS))
-                ehca_dbg(cq->device,
-                         "ehca_cq=%p cq_num=%x WARNING unsuccessful cqe "
-                         "OPType=%x status=%x qp_num=%x src_qp=%x wr_id=%lx "
-                         "cqe=%p", my_cq, my_cq->cq_number, cqe->optype,
-                         cqe->status, cqe->local_qp_number,
-                         cqe->remote_qp_number, cqe->work_request_id, cqe);
-
 poll_cq_one_exit0:
         if (cqe_count > 0)
                 hipz_update_feca(my_cq, cqe_count);
diff --git a/drivers/infiniband/hw/ehca/ehca_uverbs.c b/drivers/infiniband/hw/ehca/ehca_uverbs.c
index 1b07f2beafaf..e43ed8f8a0c8 100644
--- a/drivers/infiniband/hw/ehca/ehca_uverbs.c
+++ b/drivers/infiniband/hw/ehca/ehca_uverbs.c
@@ -211,8 +211,7 @@ static int ehca_mmap_qp(struct vm_area_struct *vma, struct ehca_qp *qp,
                 break;
 
         case 1: /* qp rqueue_addr */
-                ehca_dbg(qp->ib_qp.device, "qp_num=%x rqueue",
-                         qp->ib_qp.qp_num);
+                ehca_dbg(qp->ib_qp.device, "qp_num=%x rq", qp->ib_qp.qp_num);
                 ret = ehca_mmap_queue(vma, &qp->ipz_rqueue,
                                       &qp->mm_count_rqueue);
                 if (unlikely(ret)) {
@@ -224,8 +223,7 @@ static int ehca_mmap_qp(struct vm_area_struct *vma, struct ehca_qp *qp,
                 break;
 
         case 2: /* qp squeue_addr */
-                ehca_dbg(qp->ib_qp.device, "qp_num=%x squeue",
-                         qp->ib_qp.qp_num);
+                ehca_dbg(qp->ib_qp.device, "qp_num=%x sq", qp->ib_qp.qp_num);
                 ret = ehca_mmap_queue(vma, &qp->ipz_squeue,
                                       &qp->mm_count_squeue);
                 if (unlikely(ret)) {
diff --git a/drivers/infiniband/hw/ehca/hcp_if.c b/drivers/infiniband/hw/ehca/hcp_if.c
index 7029aa653751..5245e13c3a30 100644
--- a/drivers/infiniband/hw/ehca/hcp_if.c
+++ b/drivers/infiniband/hw/ehca/hcp_if.c
@@ -123,8 +123,9 @@ static long ehca_plpar_hcall_norets(unsigned long opcode,
         int i, sleep_msecs;
         unsigned long flags = 0;
 
-        ehca_gen_dbg("opcode=%lx " HCALL7_REGS_FORMAT,
-                     opcode, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+        if (unlikely(ehca_debug_level >= 2))
+                ehca_gen_dbg("opcode=%lx " HCALL7_REGS_FORMAT,
+                             opcode, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 
         for (i = 0; i < 5; i++) {
                 /* serialize hCalls to work around firmware issue */
@@ -148,7 +149,8 @@ static long ehca_plpar_hcall_norets(unsigned long opcode,
                                      opcode, ret, arg1, arg2, arg3,
                                      arg4, arg5, arg6, arg7);
                 else
-                        ehca_gen_dbg("opcode=%lx ret=%li", opcode, ret);
+                        if (unlikely(ehca_debug_level >= 2))
+                                ehca_gen_dbg("opcode=%lx ret=%li", opcode, ret);
 
                 return ret;
         }
@@ -172,8 +174,10 @@ static long ehca_plpar_hcall9(unsigned long opcode,
         int i, sleep_msecs;
         unsigned long flags = 0;
 
-        ehca_gen_dbg("INPUT -- opcode=%lx " HCALL9_REGS_FORMAT, opcode,
-                     arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        if (unlikely(ehca_debug_level >= 2))
+                ehca_gen_dbg("INPUT -- opcode=%lx " HCALL9_REGS_FORMAT, opcode,
+                             arg1, arg2, arg3, arg4, arg5,
+                             arg6, arg7, arg8, arg9);
 
         for (i = 0; i < 5; i++) {
                 /* serialize hCalls to work around firmware issue */
@@ -201,7 +205,7 @@ static long ehca_plpar_hcall9(unsigned long opcode,
                                      ret, outs[0], outs[1], outs[2], outs[3],
                                      outs[4], outs[5], outs[6], outs[7],
                                      outs[8]);
-                } else
+                } else if (unlikely(ehca_debug_level >= 2))
                         ehca_gen_dbg("OUTPUT -- ret=%li " HCALL9_REGS_FORMAT,
                                      ret, outs[0], outs[1], outs[2], outs[3],
                                      outs[4], outs[5], outs[6], outs[7],
@@ -381,7 +385,7 @@ u64 hipz_h_query_port(const struct ipz_adapter_handle adapter_handle,
                                       r_cb,                  /* r6 */
                                       0, 0, 0, 0);
 
-        if (ehca_debug_level)
+        if (ehca_debug_level >= 2)
                 ehca_dmp(query_port_response_block, 64, "response_block");
 
         return ret;
@@ -731,9 +735,6 @@ u64 hipz_h_alloc_resource_mr(const struct ipz_adapter_handle adapter_handle,
         u64 ret;
         u64 outs[PLPAR_HCALL9_BUFSIZE];
 
-        ehca_gen_dbg("kernel PAGE_SIZE=%x access_ctrl=%016x "
-                     "vaddr=%lx length=%lx",
-                     (u32)PAGE_SIZE, access_ctrl, vaddr, length);
         ret = ehca_plpar_hcall9(H_ALLOC_RESOURCE, outs,
                                 adapter_handle.handle,            /* r4 */
                                 5,                                /* r5 */
@@ -758,7 +759,7 @@ u64 hipz_h_register_rpage_mr(const struct ipz_adapter_handle adapter_handle,
 {
         u64 ret;
 
-        if (unlikely(ehca_debug_level >= 2)) {
+        if (unlikely(ehca_debug_level >= 3)) {
                 if (count > 1) {
                         u64 *kpage;
                         int i;
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 3557e7edc9b6..5e570bb0bb6f 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -204,7 +204,7 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector
 
                 uar = &to_mucontext(context)->uar;
         } else {
-                err = mlx4_ib_db_alloc(dev, &cq->db, 1);
+                err = mlx4_db_alloc(dev->dev, &cq->db, 1);
                 if (err)
                         goto err_cq;
 
@@ -250,7 +250,7 @@ err_mtt:
 
 err_db:
         if (!context)
-                mlx4_ib_db_free(dev, &cq->db);
+                mlx4_db_free(dev->dev, &cq->db);
 
 err_cq:
         kfree(cq);
@@ -435,7 +435,7 @@ int mlx4_ib_destroy_cq(struct ib_cq *cq)
                 ib_umem_release(mcq->umem);
         } else {
                 mlx4_ib_free_cq_buf(dev, &mcq->buf, cq->cqe + 1);
-                mlx4_ib_db_free(dev, &mcq->db);
+                mlx4_db_free(dev->dev, &mcq->db);
         }
 
         kfree(mcq);
diff --git a/drivers/infiniband/hw/mlx4/doorbell.c b/drivers/infiniband/hw/mlx4/doorbell.c
index 1c36087aef14..8e342cc9baec 100644
--- a/drivers/infiniband/hw/mlx4/doorbell.c
+++ b/drivers/infiniband/hw/mlx4/doorbell.c
@@ -34,124 +34,6 @@
 
 #include "mlx4_ib.h"
 
-struct mlx4_ib_db_pgdir {
-        struct list_head        list;
-        DECLARE_BITMAP(order0, MLX4_IB_DB_PER_PAGE);
-        DECLARE_BITMAP(order1, MLX4_IB_DB_PER_PAGE / 2);
-        unsigned long          *bits[2];
-        __be32                 *db_page;
-        dma_addr_t              db_dma;
-};
-
-static struct mlx4_ib_db_pgdir *mlx4_ib_alloc_db_pgdir(struct mlx4_ib_dev *dev)
-{
-        struct mlx4_ib_db_pgdir *pgdir;
-
-        pgdir = kzalloc(sizeof *pgdir, GFP_KERNEL);
-        if (!pgdir)
-                return NULL;
-
-        bitmap_fill(pgdir->order1, MLX4_IB_DB_PER_PAGE / 2);
-        pgdir->bits[0] = pgdir->order0;
-        pgdir->bits[1] = pgdir->order1;
-        pgdir->db_page = dma_alloc_coherent(dev->ib_dev.dma_device,
-                                            PAGE_SIZE, &pgdir->db_dma,
-                                            GFP_KERNEL);
-        if (!pgdir->db_page) {
-                kfree(pgdir);
-                return NULL;
-        }
-
-        return pgdir;
-}
-
-static int mlx4_ib_alloc_db_from_pgdir(struct mlx4_ib_db_pgdir *pgdir,
-                                       struct mlx4_ib_db *db, int order)
-{
-        int o;
-        int i;
-
-        for (o = order; o <= 1; ++o) {
-                i = find_first_bit(pgdir->bits[o], MLX4_IB_DB_PER_PAGE >> o);
-                if (i < MLX4_IB_DB_PER_PAGE >> o)
-                        goto found;
-        }
-
-        return -ENOMEM;
-
-found:
-        clear_bit(i, pgdir->bits[o]);
-
-        i <<= o;
-
-        if (o > order)
-                set_bit(i ^ 1, pgdir->bits[order]);
-
-        db->u.pgdir = pgdir;
-        db->index   = i;
-        db->db      = pgdir->db_page + db->index;
-        db->dma     = pgdir->db_dma  + db->index * 4;
-        db->order   = order;
-
-        return 0;
-}
-
-int mlx4_ib_db_alloc(struct mlx4_ib_dev *dev, struct mlx4_ib_db *db, int order)
-{
-        struct mlx4_ib_db_pgdir *pgdir;
-        int ret = 0;
-
-        mutex_lock(&dev->pgdir_mutex);
-
-        list_for_each_entry(pgdir, &dev->pgdir_list, list)
-                if (!mlx4_ib_alloc_db_from_pgdir(pgdir, db, order))
-                        goto out;
-
-        pgdir = mlx4_ib_alloc_db_pgdir(dev);
-        if (!pgdir) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        list_add(&pgdir->list, &dev->pgdir_list);
-
-        /* This should never fail -- we just allocated an empty page: */
-        WARN_ON(mlx4_ib_alloc_db_from_pgdir(pgdir, db, order));
-
-out:
-        mutex_unlock(&dev->pgdir_mutex);
-
-        return ret;
-}
-
-void mlx4_ib_db_free(struct mlx4_ib_dev *dev, struct mlx4_ib_db *db)
-{
-        int o;
-        int i;
-
-        mutex_lock(&dev->pgdir_mutex);
-
-        o = db->order;
-        i = db->index;
-
-        if (db->order == 0 && test_bit(i ^ 1, db->u.pgdir->order0)) {
-                clear_bit(i ^ 1, db->u.pgdir->order0);
-                ++o;
-        }
-
-        i >>= o;
-        set_bit(i, db->u.pgdir->bits[o]);
-
-        if (bitmap_full(db->u.pgdir->order1, MLX4_IB_DB_PER_PAGE / 2)) {
-                dma_free_coherent(dev->ib_dev.dma_device, PAGE_SIZE,
-                                  db->u.pgdir->db_page, db->u.pgdir->db_dma);
-                list_del(&db->u.pgdir->list);
-                kfree(db->u.pgdir);
-        }
-
-        mutex_unlock(&dev->pgdir_mutex);
-}
-
 struct mlx4_ib_user_db_page {
         struct list_head        list;
         struct ib_umem         *umem;
@@ -160,7 +42,7 @@ struct mlx4_ib_user_db_page {
 };
 
 int mlx4_ib_db_map_user(struct mlx4_ib_ucontext *context, unsigned long virt,
-                        struct mlx4_ib_db *db)
+                        struct mlx4_db *db)
 {
         struct mlx4_ib_user_db_page *page;
         struct ib_umem_chunk *chunk;
@@ -202,7 +84,7 @@ out:
         return err;
 }
 
-void mlx4_ib_db_unmap_user(struct mlx4_ib_ucontext *context, struct mlx4_ib_db *db)
+void mlx4_ib_db_unmap_user(struct mlx4_ib_ucontext *context, struct mlx4_db *db)
 {
         mutex_lock(&context->db_page_mutex);
 
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 4d9b5ac42202..4d61e32866c6 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -557,9 +557,6 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
                 goto err_uar;
         MLX4_INIT_DOORBELL_LOCK(&ibdev->uar_lock);
 
-        INIT_LIST_HEAD(&ibdev->pgdir_list);
-        mutex_init(&ibdev->pgdir_mutex);
-
         ibdev->dev = dev;
 
         strlcpy(ibdev->ib_dev.name, "mlx4_%d", IB_DEVICE_NAME_MAX);
diff --git a/drivers/infiniband/hw/mlx4/mlx4_ib.h b/drivers/infiniband/hw/mlx4/mlx4_ib.h
index 9e637323c155..5cf994794d25 100644
--- a/drivers/infiniband/hw/mlx4/mlx4_ib.h
+++ b/drivers/infiniband/hw/mlx4/mlx4_ib.h
@@ -43,24 +43,6 @@
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/doorbell.h>
 
-enum {
-        MLX4_IB_DB_PER_PAGE     = PAGE_SIZE / 4
-};
-
-struct mlx4_ib_db_pgdir;
-struct mlx4_ib_user_db_page;
-
-struct mlx4_ib_db {
-        __be32                 *db;
-        union {
-                struct mlx4_ib_db_pgdir        *pgdir;
-                struct mlx4_ib_user_db_page    *user_page;
-        }                       u;
-        dma_addr_t              dma;
-        int                     index;
-        int                     order;
-};
-
 struct mlx4_ib_ucontext {
         struct ib_ucontext      ibucontext;
         struct mlx4_uar         uar;
@@ -88,7 +70,7 @@ struct mlx4_ib_cq {
         struct mlx4_cq          mcq;
         struct mlx4_ib_cq_buf   buf;
         struct mlx4_ib_cq_resize *resize_buf;
-        struct mlx4_ib_db       db;
+        struct mlx4_db          db;
         spinlock_t              lock;
         struct mutex            resize_mutex;
         struct ib_umem         *umem;
@@ -127,7 +109,7 @@ struct mlx4_ib_qp {
         struct mlx4_qp          mqp;
         struct mlx4_buf         buf;
 
-        struct mlx4_ib_db       db;
+        struct mlx4_db          db;
         struct mlx4_ib_wq       rq;
 
         u32                     doorbell_qpn;
@@ -154,7 +136,7 @@ struct mlx4_ib_srq {
         struct ib_srq           ibsrq;
         struct mlx4_srq         msrq;
         struct mlx4_buf         buf;
-        struct mlx4_ib_db       db;
+        struct mlx4_db          db;
         u64                    *wrid;
         spinlock_t              lock;
         int                     head;
@@ -175,9 +157,6 @@ struct mlx4_ib_dev {
         struct mlx4_dev        *dev;
         void __iomem           *uar_map;
 
-        struct list_head        pgdir_list;
-        struct mutex            pgdir_mutex;
-
         struct mlx4_uar         priv_uar;
         u32                     priv_pdn;
         MLX4_DECLARE_DOORBELL_LOCK(uar_lock);
@@ -248,11 +227,9 @@ static inline struct mlx4_ib_ah *to_mah(struct ib_ah *ibah)
         return container_of(ibah, struct mlx4_ib_ah, ibah);
 }
 
-int mlx4_ib_db_alloc(struct mlx4_ib_dev *dev, struct mlx4_ib_db *db, int order);
-void mlx4_ib_db_free(struct mlx4_ib_dev *dev, struct mlx4_ib_db *db);
 int mlx4_ib_db_map_user(struct mlx4_ib_ucontext *context, unsigned long virt,
-                        struct mlx4_ib_db *db);
-void mlx4_ib_db_unmap_user(struct mlx4_ib_ucontext *context, struct mlx4_ib_db *db);
+                        struct mlx4_db *db);
+void mlx4_ib_db_unmap_user(struct mlx4_ib_ucontext *context, struct mlx4_db *db);
 
 struct ib_mr *mlx4_ib_get_dma_mr(struct ib_pd *pd, int acc);
 int mlx4_ib_umem_write_mtt(struct mlx4_ib_dev *dev, struct mlx4_mtt *mtt,
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index b75efae7e449..80ea8b9e7761 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -514,7 +514,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                         goto err;
 
                 if (!init_attr->srq) {
-                        err = mlx4_ib_db_alloc(dev, &qp->db, 0);
+                        err = mlx4_db_alloc(dev->dev, &qp->db, 0);
                         if (err)
                                 goto err;
 
@@ -580,7 +580,7 @@ err_buf:
 
 err_db:
         if (!pd->uobject && !init_attr->srq)
-                mlx4_ib_db_free(dev, &qp->db);
+                mlx4_db_free(dev->dev, &qp->db);
 
 err:
         return err;
@@ -666,7 +666,7 @@ static void destroy_qp_common(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp,
                 kfree(qp->rq.wrid);
                 mlx4_buf_free(dev->dev, qp->buf_size, &qp->buf);
                 if (!qp->ibqp.srq)
-                        mlx4_ib_db_free(dev, &qp->db);
+                        mlx4_db_free(dev->dev, &qp->db);
         }
 }
 
diff --git a/drivers/infiniband/hw/mlx4/srq.c b/drivers/infiniband/hw/mlx4/srq.c
index beaa3b06cf58..204619702f9d 100644
--- a/drivers/infiniband/hw/mlx4/srq.c
+++ b/drivers/infiniband/hw/mlx4/srq.c
@@ -129,7 +129,7 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
                 if (err)
                         goto err_mtt;
         } else {
-                err = mlx4_ib_db_alloc(dev, &srq->db, 0);
+                err = mlx4_db_alloc(dev->dev, &srq->db, 0);
                 if (err)
                         goto err_srq;
 
@@ -200,7 +200,7 @@ err_buf:
 
 err_db:
         if (!pd->uobject)
-                mlx4_ib_db_free(dev, &srq->db);
+                mlx4_db_free(dev->dev, &srq->db);
 
 err_srq:
         kfree(srq);
@@ -267,7 +267,7 @@ int mlx4_ib_destroy_srq(struct ib_srq *srq)
                 kfree(msrq->wrid);
                 mlx4_buf_free(dev->dev, msrq->msrq.max << msrq->msrq.wqe_shift,
                               &msrq->buf);
-                mlx4_ib_db_free(dev, &msrq->db);
+                mlx4_db_free(dev->dev, &msrq->db);
         }
 
         kfree(msrq);
diff --git a/drivers/infiniband/hw/nes/nes.c b/drivers/infiniband/hw/nes/nes.c
index b046262ed638..a4e9269a29bd 100644
--- a/drivers/infiniband/hw/nes/nes.c
+++ b/drivers/infiniband/hw/nes/nes.c
@@ -139,8 +139,9 @@ static int nes_inetaddr_event(struct notifier_block *notifier,
 
         addr = ntohl(ifa->ifa_address);
         mask = ntohl(ifa->ifa_mask);
-        nes_debug(NES_DBG_NETDEV, "nes_inetaddr_event: ip address %08X, netmask %08X.\n",
-                        addr, mask);
+        nes_debug(NES_DBG_NETDEV, "nes_inetaddr_event: ip address " NIPQUAD_FMT
+                  ", netmask " NIPQUAD_FMT ".\n",
+                  HIPQUAD(addr), HIPQUAD(mask));
         list_for_each_entry(nesdev, &nes_dev_list, list) {
                 nes_debug(NES_DBG_NETDEV, "Nesdev list entry = 0x%p. (%s)\n",
                                 nesdev, nesdev->netdev[0]->name);
@@ -353,13 +354,11 @@ struct ib_qp *nes_get_qp(struct ib_device *device, int qpn)
  */
 static void nes_print_macaddr(struct net_device *netdev)
 {
-        nes_debug(NES_DBG_INIT, "%s: MAC %02X:%02X:%02X:%02X:%02X:%02X, IRQ %u\n",
-                        netdev->name,
-                        netdev->dev_addr[0], netdev->dev_addr[1], netdev->dev_addr[2],
-                        netdev->dev_addr[3], netdev->dev_addr[4], netdev->dev_addr[5],
-                        netdev->irq);
-}
+        DECLARE_MAC_BUF(mac);
 
+        nes_debug(NES_DBG_INIT, "%s: %s, IRQ %u\n",
+                  netdev->name, print_mac(mac, netdev->dev_addr), netdev->irq);
+}
 
 /**
  * nes_interrupt - handle interrupts
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index d0738623bcf3..d940fc27129a 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -852,8 +852,8 @@ static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
         /* get a handle on the hte */
         hte = &cm_core->connected_nodes;
 
-        nes_debug(NES_DBG_CM, "Searching for an owner node:%x:%x from core %p->%p\n",
-                        loc_addr, loc_port, cm_core, hte);
+        nes_debug(NES_DBG_CM, "Searching for an owner node: " NIPQUAD_FMT ":%x from core %p->%p\n",
+                  HIPQUAD(loc_addr), loc_port, cm_core, hte);
 
         /* walk list and find cm_node associated with this session ID */
         spin_lock_irqsave(&cm_core->ht_lock, flags);
@@ -902,8 +902,8 @@ static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
         }
         spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
 
-        nes_debug(NES_DBG_CM, "Unable to find listener- %x:%x\n",
-                        dst_addr, dst_port);
+        nes_debug(NES_DBG_CM, "Unable to find listener for " NIPQUAD_FMT ":%x\n",
+                  HIPQUAD(dst_addr), dst_port);
 
         /* no listener */
         return NULL;
@@ -1054,6 +1054,7 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         int arpindex = 0;
         struct nes_device *nesdev;
         struct nes_adapter *nesadapter;
+        DECLARE_MAC_BUF(mac);
 
         /* create an hte and cm_node for this instance */
         cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC);
@@ -1066,8 +1067,9 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         cm_node->loc_port = cm_info->loc_port;
         cm_node->rem_port = cm_info->rem_port;
         cm_node->send_write0 = send_first;
-        nes_debug(NES_DBG_CM, "Make node addresses : loc = %x:%x, rem = %x:%x\n",
-                        cm_node->loc_addr, cm_node->loc_port, cm_node->rem_addr, cm_node->rem_port);
+        nes_debug(NES_DBG_CM, "Make node addresses : loc = " NIPQUAD_FMT ":%x, rem = " NIPQUAD_FMT ":%x\n",
+                  HIPQUAD(cm_node->loc_addr), cm_node->loc_port,
+                  HIPQUAD(cm_node->rem_addr), cm_node->rem_port);
         cm_node->listener = listener;
         cm_node->netdev = nesvnic->netdev;
         cm_node->cm_id = cm_info->cm_id;
@@ -1116,11 +1118,8 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
 
         /* copy the mac addr to node context */
         memcpy(cm_node->rem_mac, nesadapter->arp_table[arpindex].mac_addr, ETH_ALEN);
-        nes_debug(NES_DBG_CM, "Remote mac addr from arp table:%02x,"
-                        " %02x, %02x, %02x, %02x, %02x\n",
-                        cm_node->rem_mac[0], cm_node->rem_mac[1],
-                        cm_node->rem_mac[2], cm_node->rem_mac[3],
-                        cm_node->rem_mac[4], cm_node->rem_mac[5]);
+        nes_debug(NES_DBG_CM, "Remote mac addr from arp table: %s\n",
+                  print_mac(mac, cm_node->rem_mac));
 
         add_hte_node(cm_core, cm_node);
         atomic_inc(&cm_nodes_created);
@@ -1850,8 +1849,10 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core, struct nes_vnic *nesvni
         nfo.rem_addr = ntohl(iph->saddr);
         nfo.rem_port = ntohs(tcph->source);
 
-        nes_debug(NES_DBG_CM, "Received packet: dest=0x%08X:0x%04X src=0x%08X:0x%04X\n",
-                        iph->daddr, tcph->dest, iph->saddr, tcph->source);
+        nes_debug(NES_DBG_CM, "Received packet: dest=" NIPQUAD_FMT
+                  ":0x%04X src=" NIPQUAD_FMT ":0x%04X\n",
+                  NIPQUAD(iph->daddr), tcph->dest,
+                  NIPQUAD(iph->saddr), tcph->source);
 
         /* note: this call is going to increment cm_node ref count */
         cm_node = find_node(cm_core,
diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c
index aa53aab91bf8..08964cc7e98a 100644
--- a/drivers/infiniband/hw/nes/nes_hw.c
+++ b/drivers/infiniband/hw/nes/nes_hw.c
@@ -636,6 +636,15 @@ static unsigned int nes_reset_adapter_ne020(struct nes_device *nesdev, u8 *OneG_
                         nes_debug(NES_DBG_INIT, "Did not see full soft reset done.\n");
                         return 0;
                 }
+
+                i = 0;
+                while ((nes_read_indexed(nesdev, NES_IDX_INT_CPU_STATUS) != 0x80) && i++ < 10000)
+                        mdelay(1);
+                if (i >= 10000) {
+                        printk(KERN_ERR PFX "Internal CPU not ready, status = %02X\n",
+                               nes_read_indexed(nesdev, NES_IDX_INT_CPU_STATUS));
+                        return 0;
+                }
         }
 
         /* port reset */
@@ -684,17 +693,6 @@ static unsigned int nes_reset_adapter_ne020(struct nes_device *nesdev, u8 *OneG_
                 }
         }
 
-
-
-        i = 0;
-        while ((nes_read_indexed(nesdev, NES_IDX_INT_CPU_STATUS) != 0x80) && i++ < 10000)
-                mdelay(1);
-        if (i >= 10000) {
-                printk(KERN_ERR PFX "Internal CPU not ready, status = %02X\n",
-                                nes_read_indexed(nesdev, NES_IDX_INT_CPU_STATUS));
-                return 0;
-        }
-
         return port_count;
 }
 
diff --git a/drivers/infiniband/hw/nes/nes_hw.h b/drivers/infiniband/hw/nes/nes_hw.h
index b7e2844f096b..8f36e231bdf5 100644
--- a/drivers/infiniband/hw/nes/nes_hw.h
+++ b/drivers/infiniband/hw/nes/nes_hw.h
@@ -905,7 +905,7 @@ struct nes_hw_qp {
 };
 
 struct nes_hw_cq {
-        struct nes_hw_cqe volatile *cq_vbase;   /* PCI memory for host rings */
+        struct nes_hw_cqe *cq_vbase;    /* PCI memory for host rings */
         void (*ce_handler)(struct nes_device *nesdev, struct nes_hw_cq *cq);
         dma_addr_t cq_pbase;    /* PCI memory for host rings */
         u16 cq_head;
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index 01cd0effc492..e5366b013c1a 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -787,16 +787,14 @@ static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
         int i;
         u32 macaddr_low;
         u16 macaddr_high;
+        DECLARE_MAC_BUF(mac);
 
         if (!is_valid_ether_addr(mac_addr->sa_data))
                 return -EADDRNOTAVAIL;
 
         memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
-        printk(PFX "%s: Address length = %d, Address = %02X%02X%02X%02X%02X%02X..\n",
-                   __func__, netdev->addr_len,
-                   mac_addr->sa_data[0], mac_addr->sa_data[1],
-                   mac_addr->sa_data[2], mac_addr->sa_data[3],
-                   mac_addr->sa_data[4], mac_addr->sa_data[5]);
+        printk(PFX "%s: Address length = %d, Address = %s\n",
+               __func__, netdev->addr_len, print_mac(mac, mac_addr->sa_data));
         macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
         macaddr_high += (u16)netdev->dev_addr[1];
         macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
@@ -878,11 +876,11 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
                         if (mc_nic_index < 0)
                                 mc_nic_index = nesvnic->nic_index;
                         if (multicast_addr) {
-                                nes_debug(NES_DBG_NIC_RX, "Assigning MC Address = %02X%02X%02X%02X%02X%02X to register 0x%04X nic_idx=%d\n",
-                                                  multicast_addr->dmi_addr[0], multicast_addr->dmi_addr[1],
-                                                  multicast_addr->dmi_addr[2], multicast_addr->dmi_addr[3],
-                                                  multicast_addr->dmi_addr[4], multicast_addr->dmi_addr[5],
-                                                  perfect_filter_register_address+(mc_index * 8), mc_nic_index);
+                                DECLARE_MAC_BUF(mac);
+                                nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %s to register 0x%04X nic_idx=%d\n",
+                                          print_mac(mac, multicast_addr->dmi_addr),
+                                          perfect_filter_register_address+(mc_index * 8),
+                                          mc_nic_index);
                                 macaddr_high = ((u16)multicast_addr->dmi_addr[0]) << 8;
                                 macaddr_high += (u16)multicast_addr->dmi_addr[1];
                                 macaddr_low = ((u32)multicast_addr->dmi_addr[2]) << 24;
diff --git a/drivers/infiniband/hw/nes/nes_utils.c b/drivers/infiniband/hw/nes/nes_utils.c
index f9db07c2717d..c6d5631a6995 100644
--- a/drivers/infiniband/hw/nes/nes_utils.c
+++ b/drivers/infiniband/hw/nes/nes_utils.c
@@ -660,7 +660,9 @@ int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 acti
 
         /* DELETE or RESOLVE */
         if (arp_index == nesadapter->arp_table_size) {
-                nes_debug(NES_DBG_NETDEV, "mac address not in ARP table - cannot delete or resolve\n");
+                nes_debug(NES_DBG_NETDEV, "MAC for " NIPQUAD_FMT " not in ARP table - cannot %s\n",
+                          HIPQUAD(ip_addr),
+                          action == NES_ARP_RESOLVE ? "resolve" : "delete");
                 return -1;
         }
 
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index f9a5d4390892..ee74f7c7a6da 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -1976,7 +1976,7 @@ static int nes_destroy_cq(struct ib_cq *ib_cq)
 
         if (nescq->cq_mem_size)
                 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size,
-                                (void *)nescq->hw_cq.cq_vbase, nescq->hw_cq.cq_pbase);
+                                    nescq->hw_cq.cq_vbase, nescq->hw_cq.cq_pbase);
         kfree(nescq);
 
         return ret;
@@ -3610,6 +3610,12 @@ static int nes_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
         while (cqe_count < num_entries) {
                 if (le32_to_cpu(nescq->hw_cq.cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX]) &
                                 NES_CQE_VALID) {
+                        /*
+                         * Make sure we read CQ entry contents *after*
+                         * we've checked the valid bit.
+                         */
+                        rmb();
+
                         cqe = nescq->hw_cq.cq_vbase[head];
                         nescq->hw_cq.cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX] = 0;
                         u32temp = le32_to_cpu(cqe.cqe_words[NES_CQE_COMP_COMP_CTX_LOW_IDX]);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 73b2b176ad0e..f1f142dc64b1 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -56,11 +56,11 @@
 /* constants */
 
 enum {
-        IPOIB_PACKET_SIZE         = 2048,
-        IPOIB_BUF_SIZE            = IPOIB_PACKET_SIZE + IB_GRH_BYTES,
-
         IPOIB_ENCAP_LEN           = 4,
 
+        IPOIB_UD_HEAD_SIZE        = IB_GRH_BYTES + IPOIB_ENCAP_LEN,
+        IPOIB_UD_RX_SG            = 2, /* max buffer needed for 4K mtu */
+
         IPOIB_CM_MTU              = 0x10000 - 0x10, /* padding to align header to 16 */
         IPOIB_CM_BUF_SIZE         = IPOIB_CM_MTU  + IPOIB_ENCAP_LEN,
         IPOIB_CM_HEAD_SIZE        = IPOIB_CM_BUF_SIZE % PAGE_SIZE,
@@ -139,7 +139,7 @@ struct ipoib_mcast {
 
 struct ipoib_rx_buf {
         struct sk_buff *skb;
-        u64             mapping;
+        u64             mapping[IPOIB_UD_RX_SG];
 };
 
 struct ipoib_tx_buf {
@@ -294,6 +294,7 @@ struct ipoib_dev_priv {
 
         unsigned int admin_mtu;
         unsigned int mcast_mtu;
+        unsigned int max_ib_mtu;
 
         struct ipoib_rx_buf *rx_ring;
 
@@ -305,6 +306,9 @@ struct ipoib_dev_priv {
         struct ib_send_wr    tx_wr;
         unsigned             tx_outstanding;
 
+        struct ib_recv_wr    rx_wr;
+        struct ib_sge        rx_sge[IPOIB_UD_RX_SG];
+
         struct ib_wc ibwc[IPOIB_NUM_WC];
 
         struct list_head dead_ahs;
@@ -366,6 +370,14 @@ struct ipoib_neigh {
         struct list_head    list;
 };
 
+#define IPOIB_UD_MTU(ib_mtu)            (ib_mtu - IPOIB_ENCAP_LEN)
+#define IPOIB_UD_BUF_SIZE(ib_mtu)       (ib_mtu + IB_GRH_BYTES)
+
+static inline int ipoib_ud_need_sg(unsigned int ib_mtu)
+{
+        return IPOIB_UD_BUF_SIZE(ib_mtu) > PAGE_SIZE;
+}
+
 /*
  * We stash a pointer to our private neighbour information after our
  * hardware address in neigh->ha.  The ALIGN() expression here makes
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 0205eb7c1bd3..7cf1fa7074ab 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -89,28 +89,59 @@ void ipoib_free_ah(struct kref *kref)
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
+static void ipoib_ud_dma_unmap_rx(struct ipoib_dev_priv *priv,
+                                  u64 mapping[IPOIB_UD_RX_SG])
+{
+        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
+                ib_dma_unmap_single(priv->ca, mapping[0], IPOIB_UD_HEAD_SIZE,
+                                    DMA_FROM_DEVICE);
+                ib_dma_unmap_page(priv->ca, mapping[1], PAGE_SIZE,
+                                  DMA_FROM_DEVICE);
+        } else
+                ib_dma_unmap_single(priv->ca, mapping[0],
+                                    IPOIB_UD_BUF_SIZE(priv->max_ib_mtu),
+                                    DMA_FROM_DEVICE);
+}
+
+static void ipoib_ud_skb_put_frags(struct ipoib_dev_priv *priv,
+                                   struct sk_buff *skb,
+                                   unsigned int length)
+{
+        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
+                skb_frag_t *frag = &skb_shinfo(skb)->frags[0];
+                unsigned int size;
+                /*
+                 * There is only two buffers needed for max_payload = 4K,
+                 * first buf size is IPOIB_UD_HEAD_SIZE
+                 */
+                skb->tail += IPOIB_UD_HEAD_SIZE;
+                skb->len  += length;
+
+                size = length - IPOIB_UD_HEAD_SIZE;
+
+                frag->size     = size;
+                skb->data_len += size;
+                skb->truesize += size;
+        } else
+                skb_put(skb, length);
+
+}
+
 static int ipoib_ib_post_receive(struct net_device *dev, int id)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ib_sge list;
-        struct ib_recv_wr param;
         struct ib_recv_wr *bad_wr;
         int ret;
 
-        list.addr     = priv->rx_ring[id].mapping;
-        list.length   = IPOIB_BUF_SIZE;
-        list.lkey     = priv->mr->lkey;
+        priv->rx_wr.wr_id   = id | IPOIB_OP_RECV;
+        priv->rx_sge[0].addr = priv->rx_ring[id].mapping[0];
+        priv->rx_sge[1].addr = priv->rx_ring[id].mapping[1];
 
-        param.next    = NULL;
-        param.wr_id   = id | IPOIB_OP_RECV;
-        param.sg_list = &list;
-        param.num_sge = 1;
 
-        ret = ib_post_recv(priv->qp, &param, &bad_wr);
+        ret = ib_post_recv(priv->qp, &priv->rx_wr, &bad_wr);
         if (unlikely(ret)) {
                 ipoib_warn(priv, "receive failed for buf %d (%d)\n", id, ret);
-                ib_dma_unmap_single(priv->ca, priv->rx_ring[id].mapping,
-                                    IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
+                ipoib_ud_dma_unmap_rx(priv, priv->rx_ring[id].mapping);
                 dev_kfree_skb_any(priv->rx_ring[id].skb);
                 priv->rx_ring[id].skb = NULL;
         }
@@ -118,15 +149,21 @@ static int ipoib_ib_post_receive(struct net_device *dev, int id)
         return ret;
 }
 
-static int ipoib_alloc_rx_skb(struct net_device *dev, int id)
+static struct sk_buff *ipoib_alloc_rx_skb(struct net_device *dev, int id)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct sk_buff *skb;
-        u64 addr;
+        int buf_size;
+        u64 *mapping;
 
-        skb = dev_alloc_skb(IPOIB_BUF_SIZE + 4);
-        if (!skb)
-                return -ENOMEM;
+        if (ipoib_ud_need_sg(priv->max_ib_mtu))
+                buf_size = IPOIB_UD_HEAD_SIZE;
+        else
+                buf_size = IPOIB_UD_BUF_SIZE(priv->max_ib_mtu);
+
+        skb = dev_alloc_skb(buf_size + 4);
+        if (unlikely(!skb))
+                return NULL;
 
         /*
          * IB will leave a 40 byte gap for a GRH and IPoIB adds a 4 byte
@@ -135,17 +172,32 @@ static int ipoib_alloc_rx_skb(struct net_device *dev, int id)
          */
         skb_reserve(skb, 4);
 
-        addr = ib_dma_map_single(priv->ca, skb->data, IPOIB_BUF_SIZE,
-                                 DMA_FROM_DEVICE);
-        if (unlikely(ib_dma_mapping_error(priv->ca, addr))) {
-                dev_kfree_skb_any(skb);
-                return -EIO;
+        mapping = priv->rx_ring[id].mapping;
+        mapping[0] = ib_dma_map_single(priv->ca, skb->data, buf_size,
+                                       DMA_FROM_DEVICE);
+        if (unlikely(ib_dma_mapping_error(priv->ca, mapping[0])))
+                goto error;
+
+        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
+                struct page *page = alloc_page(GFP_ATOMIC);
+                if (!page)
+                        goto partial_error;
+                skb_fill_page_desc(skb, 0, page, 0, PAGE_SIZE);
+                mapping[1] =
+                        ib_dma_map_page(priv->ca, skb_shinfo(skb)->frags[0].page,
+                                        0, PAGE_SIZE, DMA_FROM_DEVICE);
+                if (unlikely(ib_dma_mapping_error(priv->ca, mapping[1])))
+                        goto partial_error;
         }
 
-        priv->rx_ring[id].skb     = skb;
-        priv->rx_ring[id].mapping = addr;
+        priv->rx_ring[id].skb = skb;
+        return skb;
 
-        return 0;
+partial_error:
+        ib_dma_unmap_single(priv->ca, mapping[0], buf_size, DMA_FROM_DEVICE);
+error:
+        dev_kfree_skb_any(skb);
+        return NULL;
 }
 
 static int ipoib_ib_post_receives(struct net_device *dev)
@@ -154,7 +206,7 @@ static int ipoib_ib_post_receives(struct net_device *dev)
         int i;
 
         for (i = 0; i < ipoib_recvq_size; ++i) {
-                if (ipoib_alloc_rx_skb(dev, i)) {
+                if (!ipoib_alloc_rx_skb(dev, i)) {
                         ipoib_warn(priv, "failed to allocate receive buffer %d\n", i);
                         return -ENOMEM;
                 }
@@ -172,7 +224,7 @@ static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         unsigned int wr_id = wc->wr_id & ~IPOIB_OP_RECV;
         struct sk_buff *skb;
-        u64 addr;
+        u64 mapping[IPOIB_UD_RX_SG];
 
         ipoib_dbg_data(priv, "recv completion: id %d, status: %d\n",
                        wr_id, wc->status);
@@ -184,15 +236,13 @@ static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
         }
 
         skb  = priv->rx_ring[wr_id].skb;
-        addr = priv->rx_ring[wr_id].mapping;
 
         if (unlikely(wc->status != IB_WC_SUCCESS)) {
                 if (wc->status != IB_WC_WR_FLUSH_ERR)
                         ipoib_warn(priv, "failed recv event "
                                    "(status=%d, wrid=%d vend_err %x)\n",
                                    wc->status, wr_id, wc->vendor_err);
-                ib_dma_unmap_single(priv->ca, addr,
-                                    IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
+                ipoib_ud_dma_unmap_rx(priv, priv->rx_ring[wr_id].mapping);
                 dev_kfree_skb_any(skb);
                 priv->rx_ring[wr_id].skb = NULL;
                 return;
@@ -205,11 +255,14 @@ static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
         if (wc->slid == priv->local_lid && wc->src_qp == priv->qp->qp_num)
                 goto repost;
 
+        memcpy(mapping, priv->rx_ring[wr_id].mapping,
+               IPOIB_UD_RX_SG * sizeof *mapping);
+
         /*
          * If we can't allocate a new RX buffer, dump
          * this packet and reuse the old buffer.
          */
-        if (unlikely(ipoib_alloc_rx_skb(dev, wr_id))) {
+        if (unlikely(!ipoib_alloc_rx_skb(dev, wr_id))) {
                 ++dev->stats.rx_dropped;
                 goto repost;
         }
@@ -217,9 +270,9 @@ static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
         ipoib_dbg_data(priv, "received %d bytes, SLID 0x%04x\n",
                        wc->byte_len, wc->slid);
 
-        ib_dma_unmap_single(priv->ca, addr, IPOIB_BUF_SIZE, DMA_FROM_DEVICE);
+        ipoib_ud_dma_unmap_rx(priv, mapping);
+        ipoib_ud_skb_put_frags(priv, skb, wc->byte_len);
 
-        skb_put(skb, wc->byte_len);
         skb_pull(skb, IB_GRH_BYTES);
 
         skb->protocol = ((struct ipoib_header *) skb->data)->proto;
@@ -733,10 +786,8 @@ int ipoib_ib_dev_stop(struct net_device *dev, int flush)
                                 rx_req = &priv->rx_ring[i];
                                 if (!rx_req->skb)
                                         continue;
-                                ib_dma_unmap_single(priv->ca,
-                                                    rx_req->mapping,
-                                                    IPOIB_BUF_SIZE,
-                                                    DMA_FROM_DEVICE);
+                                ipoib_ud_dma_unmap_rx(priv,
+                                                      priv->rx_ring[i].mapping);
                                 dev_kfree_skb_any(rx_req->skb);
                                 rx_req->skb = NULL;
                         }
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index bd07f02cf02b..7a4ed9d3d844 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -195,7 +195,7 @@ static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
                 return 0;
         }
 
-        if (new_mtu > IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN)
+        if (new_mtu > IPOIB_UD_MTU(priv->max_ib_mtu))
                 return -EINVAL;
 
         priv->admin_mtu = new_mtu;
@@ -971,10 +971,6 @@ static void ipoib_setup(struct net_device *dev)
                                     NETIF_F_LLTX                |
                                     NETIF_F_HIGHDMA);
 
-        /* MTU will be reset when mcast join happens */
-        dev->mtu                 = IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN;
-        priv->mcast_mtu          = priv->admin_mtu = dev->mtu;
-
         memcpy(dev->broadcast, ipv4_bcast_addr, INFINIBAND_ALEN);
 
         netif_carrier_off(dev);
@@ -1107,6 +1103,7 @@ static struct net_device *ipoib_add_port(const char *format,
 {
         struct ipoib_dev_priv *priv;
         struct ib_device_attr *device_attr;
+        struct ib_port_attr attr;
         int result = -ENOMEM;
 
         priv = ipoib_intf_alloc(format);
@@ -1115,6 +1112,18 @@ static struct net_device *ipoib_add_port(const char *format,
 
         SET_NETDEV_DEV(priv->dev, hca->dma_device);
 
+        if (!ib_query_port(hca, port, &attr))
+                priv->max_ib_mtu = ib_mtu_enum_to_int(attr.max_mtu);
+        else {
+                printk(KERN_WARNING "%s: ib_query_port %d failed\n",
+                       hca->name, port);
+                goto device_init_failed;
+        }
+
+        /* MTU will be reset when mcast join happens */
+        priv->dev->mtu  = IPOIB_UD_MTU(priv->max_ib_mtu);
+        priv->mcast_mtu  = priv->admin_mtu = priv->dev->mtu;
+
         result = ib_query_pkey(hca, port, 0, &priv->pkey);
         if (result) {
                 printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n",
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index 31a53c5bcb13..d00a2c174aee 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -567,8 +567,7 @@ void ipoib_mcast_join_task(struct work_struct *work)
                 return;
         }
 
-        priv->mcast_mtu = ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu) -
-                IPOIB_ENCAP_LEN;
+        priv->mcast_mtu = IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
 
         if (!ipoib_cm_admin_enabled(dev))
                 dev->mtu = min(priv->mcast_mtu, priv->admin_mtu);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
index 8a20e3742c43..07c03f178a49 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
@@ -150,7 +150,7 @@ int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca)
                         .max_send_wr  = ipoib_sendq_size,
                         .max_recv_wr  = ipoib_recvq_size,
                         .max_send_sge = 1,
-                        .max_recv_sge = 1
+                        .max_recv_sge = IPOIB_UD_RX_SG
                 },
                 .sq_sig_type = IB_SIGNAL_ALL_WR,
                 .qp_type     = IB_QPT_UD
@@ -215,6 +215,19 @@ int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca)
         priv->tx_wr.sg_list     = priv->tx_sge;
         priv->tx_wr.send_flags  = IB_SEND_SIGNALED;
 
+        priv->rx_sge[0].lkey = priv->mr->lkey;
+        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
+                priv->rx_sge[0].length = IPOIB_UD_HEAD_SIZE;
+                priv->rx_sge[1].length = PAGE_SIZE;
+                priv->rx_sge[1].lkey = priv->mr->lkey;
+                priv->rx_wr.num_sge = IPOIB_UD_RX_SG;
+        } else {
+                priv->rx_sge[0].length = IPOIB_UD_BUF_SIZE(priv->max_ib_mtu);
+                priv->rx_wr.num_sge = 1;
+        }
+        priv->rx_wr.next = NULL;
+        priv->rx_wr.sg_list = priv->rx_sge;
+
         return 0;
 
 out_free_cq:
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
index 293f5b892e3f..431fdeaa2dc4 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
@@ -89,6 +89,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
                 goto err;
         }
 
+        priv->max_ib_mtu = ppriv->max_ib_mtu;
         set_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags);
 
         priv->pkey = pkey;
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 4b07bdadb81e..b29e3affb805 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -444,6 +444,23 @@ exit:
                      __FUNCTION__, retval);
 }
 
+static void xpad_bulk_out(struct urb *urb)
+{
+        switch (urb->status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                break;
+        default:
+                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+        }
+}
+
 #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 static void xpad_irq_out(struct urb *urb)
 {
@@ -475,23 +492,6 @@ exit:
                     __FUNCTION__, retval);
 }
 
-static void xpad_bulk_out(struct urb *urb)
-{
-        switch (urb->status) {
-        case 0:
-                /* success */
-                break;
-        case -ECONNRESET:
-        case -ENOENT:
-        case -ESHUTDOWN:
-                /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
-                break;
-        default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
-        }
-}
-
 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 {
         struct usb_endpoint_descriptor *ep_irq_out;
diff --git a/drivers/macintosh/mac_hid.c b/drivers/macintosh/mac_hid.c
index f972ff377b63..cc9f27514aef 100644
--- a/drivers/macintosh/mac_hid.c
+++ b/drivers/macintosh/mac_hid.c
@@ -114,8 +114,8 @@ static int emumousebtn_input_register(void)
         if (!emumousebtn)
                 return -ENOMEM;
 
-        lockdep_set_class(emumousebtn->event_lock, &emumousebtn_event_class);
-        lockdep_set_class(emumousebtn->mutex, &emumousebtn_mutex_class);
+        lockdep_set_class(&emumousebtn->event_lock, &emumousebtn_event_class);
+        lockdep_set_class(&emumousebtn->mutex, &emumousebtn_mutex_class);
 
         emumousebtn->name = "Macintosh mouse button emulation";
         emumousebtn->id.bustype = BUS_ADB;
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c
index 6477fc66cc23..346223856f59 100644
--- a/drivers/media/dvb/dvb-usb/dib0700_devices.c
+++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c
@@ -299,7 +299,7 @@ static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
 }
 
 /* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
-struct dibx000_agc_config xc3028_agc_config = {
+static struct dibx000_agc_config xc3028_agc_config = {
         BAND_VHF | BAND_UHF,       /* band_caps */
 
         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
@@ -342,7 +342,7 @@ struct dibx000_agc_config xc3028_agc_config = {
 };
 
 /* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
-struct dibx000_bandwidth_config xc3028_bw_config = {
+static struct dibx000_bandwidth_config xc3028_bw_config = {
         60000, 30000, /* internal, sampling */
         1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
         0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index 68fab616f55d..f5fceb3cdb3c 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -307,6 +307,14 @@ config DVB_AU8522
           An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
           to support this frontend.
 
+config DVB_S5H1411
+        tristate "Samsung S5H1411 based"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        help
+          An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
+          to support this frontend.
+
 comment "Tuners/PLL support"
         depends on DVB_CORE
 
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 2f873fc0f649..9747c73dc826 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -55,3 +55,4 @@ obj-$(CONFIG_DVB_TUNER_XC5000) += xc5000.o
 obj-$(CONFIG_DVB_TUNER_ITD1000) += itd1000.o
 obj-$(CONFIG_DVB_AU8522) += au8522.o
 obj-$(CONFIG_DVB_TDA10048) += tda10048.o
+obj-$(CONFIG_DVB_S5H1411) += s5h1411.o
diff --git a/drivers/media/dvb/frontends/mt312.h b/drivers/media/dvb/frontends/mt312.h
index 96338f0c4dd4..de796eab3911 100644
--- a/drivers/media/dvb/frontends/mt312.h
+++ b/drivers/media/dvb/frontends/mt312.h
@@ -33,7 +33,7 @@ struct mt312_config {
         u8 demod_address;
 
         /* inverted voltage setting */
-        int voltage_inverted:1;
+        unsigned int voltage_inverted:1;
 };
 
 #if defined(CONFIG_DVB_MT312) || (defined(CONFIG_DVB_MT312_MODULE) && defined(MODULE))
diff --git a/drivers/media/dvb/frontends/s5h1411.c b/drivers/media/dvb/frontends/s5h1411.c
new file mode 100644
index 000000000000..eb5bfc99d4e9
--- /dev/null
+++ b/drivers/media/dvb/frontends/s5h1411.c
@@ -0,0 +1,888 @@
+/*
+    Samsung S5H1411 VSB/QAM demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include "dvb_frontend.h"
+#include "dvb-pll.h"
+#include "s5h1411.h"
+
+struct s5h1411_state {
+
+        struct i2c_adapter *i2c;
+
+        /* configuration settings */
+        const struct s5h1411_config *config;
+
+        struct dvb_frontend frontend;
+
+        fe_modulation_t current_modulation;
+
+        u32 current_frequency;
+        int if_freq;
+
+        u8 inversion;
+};
+
+static int debug;
+
+#define dprintk(arg...) do {    \
+        if (debug)              \
+                printk(arg);    \
+        } while (0)
+
+/* Register values to initialise the demod, defaults to VSB */
+static struct init_tab {
+        u8      addr;
+        u8      reg;
+        u16     data;
+} init_tab[] = {
+        { S5H1411_I2C_TOP_ADDR, 0x00, 0x0071, },
+        { S5H1411_I2C_TOP_ADDR, 0x08, 0x0047, },
+        { S5H1411_I2C_TOP_ADDR, 0x1c, 0x0400, },
+        { S5H1411_I2C_TOP_ADDR, 0x1e, 0x0370, },
+        { S5H1411_I2C_TOP_ADDR, 0x1f, 0x342a, },
+        { S5H1411_I2C_TOP_ADDR, 0x24, 0x0231, },
+        { S5H1411_I2C_TOP_ADDR, 0x25, 0x1011, },
+        { S5H1411_I2C_TOP_ADDR, 0x26, 0x0f07, },
+        { S5H1411_I2C_TOP_ADDR, 0x27, 0x0f04, },
+        { S5H1411_I2C_TOP_ADDR, 0x28, 0x070f, },
+        { S5H1411_I2C_TOP_ADDR, 0x29, 0x2820, },
+        { S5H1411_I2C_TOP_ADDR, 0x2a, 0x102e, },
+        { S5H1411_I2C_TOP_ADDR, 0x2b, 0x0220, },
+        { S5H1411_I2C_TOP_ADDR, 0x2e, 0x0d0e, },
+        { S5H1411_I2C_TOP_ADDR, 0x2f, 0x1013, },
+        { S5H1411_I2C_TOP_ADDR, 0x31, 0x171b, },
+        { S5H1411_I2C_TOP_ADDR, 0x32, 0x0e0f, },
+        { S5H1411_I2C_TOP_ADDR, 0x33, 0x0f10, },
+        { S5H1411_I2C_TOP_ADDR, 0x34, 0x170e, },
+        { S5H1411_I2C_TOP_ADDR, 0x35, 0x4b10, },
+        { S5H1411_I2C_TOP_ADDR, 0x36, 0x0f17, },
+        { S5H1411_I2C_TOP_ADDR, 0x3c, 0x1577, },
+        { S5H1411_I2C_TOP_ADDR, 0x3d, 0x081a, },
+        { S5H1411_I2C_TOP_ADDR, 0x3e, 0x77ee, },
+        { S5H1411_I2C_TOP_ADDR, 0x40, 0x1e09, },
+        { S5H1411_I2C_TOP_ADDR, 0x41, 0x0f0c, },
+        { S5H1411_I2C_TOP_ADDR, 0x42, 0x1f10, },
+        { S5H1411_I2C_TOP_ADDR, 0x4d, 0x0509, },
+        { S5H1411_I2C_TOP_ADDR, 0x4e, 0x0a00, },
+        { S5H1411_I2C_TOP_ADDR, 0x50, 0x0000, },
+        { S5H1411_I2C_TOP_ADDR, 0x5b, 0x0000, },
+        { S5H1411_I2C_TOP_ADDR, 0x5c, 0x0008, },
+        { S5H1411_I2C_TOP_ADDR, 0x57, 0x1101, },
+        { S5H1411_I2C_TOP_ADDR, 0x65, 0x007c, },
+        { S5H1411_I2C_TOP_ADDR, 0x68, 0x0512, },
+        { S5H1411_I2C_TOP_ADDR, 0x69, 0x0258, },
+        { S5H1411_I2C_TOP_ADDR, 0x70, 0x0004, },
+        { S5H1411_I2C_TOP_ADDR, 0x71, 0x0007, },
+        { S5H1411_I2C_TOP_ADDR, 0x76, 0x00a9, },
+        { S5H1411_I2C_TOP_ADDR, 0x78, 0x3141, },
+        { S5H1411_I2C_TOP_ADDR, 0x7a, 0x3141, },
+        { S5H1411_I2C_TOP_ADDR, 0xb3, 0x8003, },
+        { S5H1411_I2C_TOP_ADDR, 0xb5, 0xafbb, },
+        { S5H1411_I2C_TOP_ADDR, 0xb5, 0xa6bb, },
+        { S5H1411_I2C_TOP_ADDR, 0xb6, 0x0609, },
+        { S5H1411_I2C_TOP_ADDR, 0xb7, 0x2f06, },
+        { S5H1411_I2C_TOP_ADDR, 0xb8, 0x003f, },
+        { S5H1411_I2C_TOP_ADDR, 0xb9, 0x2700, },
+        { S5H1411_I2C_TOP_ADDR, 0xba, 0xfac8, },
+        { S5H1411_I2C_TOP_ADDR, 0xbe, 0x1003, },
+        { S5H1411_I2C_TOP_ADDR, 0xbf, 0x103f, },
+        { S5H1411_I2C_TOP_ADDR, 0xce, 0x2000, },
+        { S5H1411_I2C_TOP_ADDR, 0xcf, 0x0800, },
+        { S5H1411_I2C_TOP_ADDR, 0xd0, 0x0800, },
+        { S5H1411_I2C_TOP_ADDR, 0xd1, 0x0400, },
+        { S5H1411_I2C_TOP_ADDR, 0xd2, 0x0800, },
+        { S5H1411_I2C_TOP_ADDR, 0xd3, 0x2000, },
+        { S5H1411_I2C_TOP_ADDR, 0xd4, 0x3000, },
+        { S5H1411_I2C_TOP_ADDR, 0xdb, 0x4a9b, },
+        { S5H1411_I2C_TOP_ADDR, 0xdc, 0x1000, },
+        { S5H1411_I2C_TOP_ADDR, 0xde, 0x0001, },
+        { S5H1411_I2C_TOP_ADDR, 0xdf, 0x0000, },
+        { S5H1411_I2C_TOP_ADDR, 0xe3, 0x0301, },
+        { S5H1411_I2C_QAM_ADDR, 0xf3, 0x0000, },
+        { S5H1411_I2C_QAM_ADDR, 0xf3, 0x0001, },
+        { S5H1411_I2C_QAM_ADDR, 0x08, 0x0600, },
+        { S5H1411_I2C_QAM_ADDR, 0x18, 0x4201, },
+        { S5H1411_I2C_QAM_ADDR, 0x1e, 0x6476, },
+        { S5H1411_I2C_QAM_ADDR, 0x21, 0x0830, },
+        { S5H1411_I2C_QAM_ADDR, 0x0c, 0x5679, },
+        { S5H1411_I2C_QAM_ADDR, 0x0d, 0x579b, },
+        { S5H1411_I2C_QAM_ADDR, 0x24, 0x0102, },
+        { S5H1411_I2C_QAM_ADDR, 0x31, 0x7488, },
+        { S5H1411_I2C_QAM_ADDR, 0x32, 0x0a08, },
+        { S5H1411_I2C_QAM_ADDR, 0x3d, 0x8689, },
+        { S5H1411_I2C_QAM_ADDR, 0x49, 0x0048, },
+        { S5H1411_I2C_QAM_ADDR, 0x57, 0x2012, },
+        { S5H1411_I2C_QAM_ADDR, 0x5d, 0x7676, },
+        { S5H1411_I2C_QAM_ADDR, 0x04, 0x0400, },
+        { S5H1411_I2C_QAM_ADDR, 0x58, 0x00c0, },
+        { S5H1411_I2C_QAM_ADDR, 0x5b, 0x0100, },
+};
+
+/* VSB SNR lookup table */
+static struct vsb_snr_tab {
+        u16     val;
+        u16     data;
+} vsb_snr_tab[] = {
+        {  0x39f, 300, },
+        {  0x39b, 295, },
+        {  0x397, 290, },
+        {  0x394, 285, },
+        {  0x38f, 280, },
+        {  0x38b, 275, },
+        {  0x387, 270, },
+        {  0x382, 265, },
+        {  0x37d, 260, },
+        {  0x377, 255, },
+        {  0x370, 250, },
+        {  0x36a, 245, },
+        {  0x364, 240, },
+        {  0x35b, 235, },
+        {  0x353, 230, },
+        {  0x349, 225, },
+        {  0x340, 320, },
+        {  0x337, 215, },
+        {  0x327, 210, },
+        {  0x31b, 205, },
+        {  0x310, 200, },
+        {  0x302, 195, },
+        {  0x2f3, 190, },
+        {  0x2e4, 185, },
+        {  0x2d7, 180, },
+        {  0x2cd, 175, },
+        {  0x2bb, 170, },
+        {  0x2a9, 165, },
+        {  0x29e, 160, },
+        {  0x284, 155, },
+        {  0x27a, 150, },
+        {  0x260, 145, },
+        {  0x23a, 140, },
+        {  0x224, 135, },
+        {  0x213, 130, },
+        {  0x204, 125, },
+        {  0x1fe, 120, },
+        {      0,   0, },
+};
+
+/* QAM64 SNR lookup table */
+static struct qam64_snr_tab {
+        u16     val;
+        u16     data;
+} qam64_snr_tab[] = {
+        {  0x0001,   0, },
+        {  0x0af0, 300, },
+        {  0x0d80, 290, },
+        {  0x10a0, 280, },
+        {  0x14b5, 270, },
+        {  0x1590, 268, },
+        {  0x1680, 266, },
+        {  0x17b0, 264, },
+        {  0x18c0, 262, },
+        {  0x19b0, 260, },
+        {  0x1ad0, 258, },
+        {  0x1d00, 256, },
+        {  0x1da0, 254, },
+        {  0x1ef0, 252, },
+        {  0x2050, 250, },
+        {  0x20f0, 249, },
+        {  0x21d0, 248, },
+        {  0x22b0, 247, },
+        {  0x23a0, 246, },
+        {  0x2470, 245, },
+        {  0x24f0, 244, },
+        {  0x25a0, 243, },
+        {  0x26c0, 242, },
+        {  0x27b0, 241, },
+        {  0x28d0, 240, },
+        {  0x29b0, 239, },
+        {  0x2ad0, 238, },
+        {  0x2ba0, 237, },
+        {  0x2c80, 236, },
+        {  0x2d20, 235, },
+        {  0x2e00, 234, },
+        {  0x2f10, 233, },
+        {  0x3050, 232, },
+        {  0x3190, 231, },
+        {  0x3300, 230, },
+        {  0x3340, 229, },
+        {  0x3200, 228, },
+        {  0x3550, 227, },
+        {  0x3610, 226, },
+        {  0x3600, 225, },
+        {  0x3700, 224, },
+        {  0x3800, 223, },
+        {  0x3920, 222, },
+        {  0x3a20, 221, },
+        {  0x3b30, 220, },
+        {  0x3d00, 219, },
+        {  0x3e00, 218, },
+        {  0x4000, 217, },
+        {  0x4100, 216, },
+        {  0x4300, 215, },
+        {  0x4400, 214, },
+        {  0x4600, 213, },
+        {  0x4700, 212, },
+        {  0x4800, 211, },
+        {  0x4a00, 210, },
+        {  0x4b00, 209, },
+        {  0x4d00, 208, },
+        {  0x4f00, 207, },
+        {  0x5050, 206, },
+        {  0x5200, 205, },
+        {  0x53c0, 204, },
+        {  0x5450, 203, },
+        {  0x5650, 202, },
+        {  0x5820, 201, },
+        {  0x6000, 200, },
+        {  0xffff,   0, },
+};
+
+/* QAM256 SNR lookup table */
+static struct qam256_snr_tab {
+        u16     val;
+        u16     data;
+} qam256_snr_tab[] = {
+        {  0x0001,   0, },
+        {  0x0970, 400, },
+        {  0x0a90, 390, },
+        {  0x0b90, 380, },
+        {  0x0d90, 370, },
+        {  0x0ff0, 360, },
+        {  0x1240, 350, },
+        {  0x1345, 348, },
+        {  0x13c0, 346, },
+        {  0x14c0, 344, },
+        {  0x1500, 342, },
+        {  0x1610, 340, },
+        {  0x1700, 338, },
+        {  0x1800, 336, },
+        {  0x18b0, 334, },
+        {  0x1900, 332, },
+        {  0x1ab0, 330, },
+        {  0x1bc0, 328, },
+        {  0x1cb0, 326, },
+        {  0x1db0, 324, },
+        {  0x1eb0, 322, },
+        {  0x2030, 320, },
+        {  0x2200, 318, },
+        {  0x2280, 316, },
+        {  0x2410, 314, },
+        {  0x25b0, 312, },
+        {  0x27a0, 310, },
+        {  0x2840, 308, },
+        {  0x29d0, 306, },
+        {  0x2b10, 304, },
+        {  0x2d30, 302, },
+        {  0x2f20, 300, },
+        {  0x30c0, 298, },
+        {  0x3260, 297, },
+        {  0x32c0, 296, },
+        {  0x3300, 295, },
+        {  0x33b0, 294, },
+        {  0x34b0, 293, },
+        {  0x35a0, 292, },
+        {  0x3650, 291, },
+        {  0x3800, 290, },
+        {  0x3900, 289, },
+        {  0x3a50, 288, },
+        {  0x3b30, 287, },
+        {  0x3cb0, 286, },
+        {  0x3e20, 285, },
+        {  0x3fa0, 284, },
+        {  0x40a0, 283, },
+        {  0x41c0, 282, },
+        {  0x42f0, 281, },
+        {  0x44a0, 280, },
+        {  0x4600, 279, },
+        {  0x47b0, 278, },
+        {  0x4900, 277, },
+        {  0x4a00, 276, },
+        {  0x4ba0, 275, },
+        {  0x4d00, 274, },
+        {  0x4f00, 273, },
+        {  0x5000, 272, },
+        {  0x51f0, 272, },
+        {  0x53a0, 270, },
+        {  0x5520, 269, },
+        {  0x5700, 268, },
+        {  0x5800, 267, },
+        {  0x5a00, 266, },
+        {  0x5c00, 265, },
+        {  0x5d00, 264, },
+        {  0x5f00, 263, },
+        {  0x6000, 262, },
+        {  0x6200, 261, },
+        {  0x6400, 260, },
+        {  0xffff,   0, },
+};
+
+/* 8 bit registers, 16 bit values */
+static int s5h1411_writereg(struct s5h1411_state *state,
+        u8 addr, u8 reg, u16 data)
+{
+        int ret;
+        u8 buf [] = { reg, data >> 8,  data & 0xff };
+
+        struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = buf, .len = 3 };
+
+        ret = i2c_transfer(state->i2c, &msg, 1);
+
+        if (ret != 1)
+                printk(KERN_ERR "%s: writereg error 0x%02x 0x%02x 0x%04x, "
+                       "ret == %i)\n", __func__, addr, reg, data, ret);
+
+        return (ret != 1) ? -1 : 0;
+}
+
+static u16 s5h1411_readreg(struct s5h1411_state *state, u8 addr, u8 reg)
+{
+        int ret;
+        u8 b0 [] = { reg };
+        u8 b1 [] = { 0, 0 };
+
+        struct i2c_msg msg [] = {
+                { .addr = addr, .flags = 0, .buf = b0, .len = 1 },
+                { .addr = addr, .flags = I2C_M_RD, .buf = b1, .len = 2 } };
+
+        ret = i2c_transfer(state->i2c, msg, 2);
+
+        if (ret != 2)
+                printk(KERN_ERR "%s: readreg error (ret == %i)\n",
+                        __func__, ret);
+        return (b1[0] << 8) | b1[1];
+}
+
+static int s5h1411_softreset(struct dvb_frontend *fe)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s()\n", __func__);
+
+        s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf7, 0);
+        s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf7, 1);
+        return 0;
+}
+
+static int s5h1411_set_if_freq(struct dvb_frontend *fe, int KHz)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s(%d KHz)\n", __func__, KHz);
+
+        switch (KHz) {
+        case 3250:
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x38, 0x10d9);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x39, 0x5342);
+                s5h1411_writereg(state, S5H1411_I2C_QAM_ADDR, 0x2c, 0x10d9);
+                break;
+        case 3500:
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x38, 0x1225);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x39, 0x1e96);
+                s5h1411_writereg(state, S5H1411_I2C_QAM_ADDR, 0x2c, 0x1225);
+                break;
+        case 4000:
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x38, 0x14bc);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x39, 0xb53e);
+                s5h1411_writereg(state, S5H1411_I2C_QAM_ADDR, 0x2c, 0x14bd);
+                break;
+        default:
+                dprintk("%s(%d KHz) Invalid, defaulting to 5380\n",
+                        __func__, KHz);
+                /* no break, need to continue */
+        case 5380:
+        case 44000:
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x38, 0x1be4);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x39, 0x3655);
+                s5h1411_writereg(state, S5H1411_I2C_QAM_ADDR, 0x2c, 0x1be4);
+                break;
+        }
+
+        state->if_freq = KHz;
+
+        return 0;
+}
+
+static int s5h1411_set_mpeg_timing(struct dvb_frontend *fe, int mode)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        u16 val;
+
+        dprintk("%s(%d)\n", __func__, mode);
+
+        val = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xbe) & 0xcfff;
+        switch (mode) {
+        case S5H1411_MPEGTIMING_CONTINOUS_INVERTING_CLOCK:
+                val |= 0x0000;
+                break;
+        case S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK:
+                dprintk("%s(%d) Mode1 or Defaulting\n", __func__, mode);
+                val |= 0x1000;
+                break;
+        case S5H1411_MPEGTIMING_NONCONTINOUS_INVERTING_CLOCK:
+                val |= 0x2000;
+                break;
+        case S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK:
+                val |= 0x3000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* Configure MPEG Signal Timing charactistics */
+        return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xbe, val);
+}
+
+static int s5h1411_set_spectralinversion(struct dvb_frontend *fe, int inversion)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        u16 val;
+
+        dprintk("%s(%d)\n", __func__, inversion);
+        val = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0x24) & ~0x1000;
+
+        if (inversion == 1)
+                val |= 0x1000; /* Inverted */
+        else
+                val |= 0x0000;
+
+        state->inversion = inversion;
+        return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x24, val);
+}
+
+static int s5h1411_enable_modulation(struct dvb_frontend *fe,
+                                     fe_modulation_t m)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s(0x%08x)\n", __func__, m);
+
+        switch (m) {
+        case VSB_8:
+                dprintk("%s() VSB_8\n", __func__);
+                s5h1411_set_if_freq(fe, state->config->vsb_if);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x00, 0x71);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf6, 0x00);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xcd, 0xf1);
+                break;
+        case QAM_64:
+        case QAM_256:
+                dprintk("%s() QAM_AUTO (64/256)\n", __func__);
+                s5h1411_set_if_freq(fe, state->config->qam_if);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0x00, 0x0171);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf6, 0x0001);
+                s5h1411_writereg(state, S5H1411_I2C_QAM_ADDR, 0x16, 0x1101);
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xcd, 0x00f0);
+                break;
+        default:
+                dprintk("%s() Invalid modulation\n", __func__);
+                return -EINVAL;
+        }
+
+        state->current_modulation = m;
+        s5h1411_softreset(fe);
+
+        return 0;
+}
+
+static int s5h1411_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s(%d)\n", __func__, enable);
+
+        if (enable)
+                return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf5, 1);
+        else
+                return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf5, 0);
+}
+
+static int s5h1411_set_gpio(struct dvb_frontend *fe, int enable)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        u16 val;
+
+        dprintk("%s(%d)\n", __func__, enable);
+
+        val = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xe0) & ~0x02;
+
+        if (enable)
+                return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xe0,
+                                val | 0x02);
+        else
+                return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xe0, val);
+}
+
+static int s5h1411_sleep(struct dvb_frontend *fe, int enable)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s(%d)\n", __func__, enable);
+
+        if (enable)
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf4, 1);
+        else {
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf4, 0);
+                s5h1411_softreset(fe);
+        }
+
+        return 0;
+}
+
+static int s5h1411_register_reset(struct dvb_frontend *fe)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s()\n", __func__);
+
+        return s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf3, 0);
+}
+
+/* Talk to the demod, set the FEC, GUARD, QAM settings etc */
+static int s5h1411_set_frontend(struct dvb_frontend *fe,
+        struct dvb_frontend_parameters *p)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        dprintk("%s(frequency=%d)\n", __func__, p->frequency);
+
+        s5h1411_softreset(fe);
+
+        state->current_frequency = p->frequency;
+
+        s5h1411_enable_modulation(fe, p->u.vsb.modulation);
+
+        /* Allow the demod to settle */
+        msleep(100);
+
+        if (fe->ops.tuner_ops.set_params) {
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 1);
+
+                fe->ops.tuner_ops.set_params(fe, p);
+
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 0);
+        }
+
+        return 0;
+}
+
+/* Reset the demod hardware and reset all of the configuration registers
+   to a default state. */
+static int s5h1411_init(struct dvb_frontend *fe)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        int i;
+
+        dprintk("%s()\n", __func__);
+
+        s5h1411_sleep(fe, 0);
+        s5h1411_register_reset(fe);
+
+        for (i = 0; i < ARRAY_SIZE(init_tab); i++)
+                s5h1411_writereg(state, init_tab[i].addr,
+                        init_tab[i].reg,
+                        init_tab[i].data);
+
+        /* The datasheet says that after initialisation, VSB is default */
+        state->current_modulation = VSB_8;
+
+        if (state->config->output_mode == S5H1411_SERIAL_OUTPUT)
+                /* Serial */
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xbd, 0x1101);
+        else
+                /* Parallel */
+                s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xbd, 0x1001);
+
+        s5h1411_set_spectralinversion(fe, state->config->inversion);
+        s5h1411_set_if_freq(fe, state->config->vsb_if);
+        s5h1411_set_gpio(fe, state->config->gpio);
+        s5h1411_set_mpeg_timing(fe, state->config->mpeg_timing);
+        s5h1411_softreset(fe);
+
+        /* Note: Leaving the I2C gate closed. */
+        s5h1411_i2c_gate_ctrl(fe, 0);
+
+        return 0;
+}
+
+static int s5h1411_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        u16 reg;
+        u32 tuner_status = 0;
+
+        *status = 0;
+
+        /* Get the demodulator status */
+        reg = (s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xf2) >> 15)
+                & 0x0001;
+        if (reg)
+                *status |= FE_HAS_LOCK | FE_HAS_CARRIER | FE_HAS_SIGNAL;
+
+        switch (state->current_modulation) {
+        case QAM_64:
+        case QAM_256:
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xf0);
+                if (reg & 0x100)
+                        *status |= FE_HAS_VITERBI;
+                if (reg & 0x10)
+                        *status |= FE_HAS_SYNC;
+                break;
+        case VSB_8:
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0x5e);
+                if (reg & 0x0001)
+                        *status |= FE_HAS_SYNC;
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xf2);
+                if (reg & 0x1000)
+                        *status |= FE_HAS_VITERBI;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (state->config->status_mode) {
+        case S5H1411_DEMODLOCKING:
+                if (*status & FE_HAS_VITERBI)
+                        *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+                break;
+        case S5H1411_TUNERLOCKING:
+                /* Get the tuner status */
+                if (fe->ops.tuner_ops.get_status) {
+                        if (fe->ops.i2c_gate_ctrl)
+                                fe->ops.i2c_gate_ctrl(fe, 1);
+
+                        fe->ops.tuner_ops.get_status(fe, &tuner_status);
+
+                        if (fe->ops.i2c_gate_ctrl)
+                                fe->ops.i2c_gate_ctrl(fe, 0);
+                }
+                if (tuner_status)
+                        *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+                break;
+        }
+
+        dprintk("%s() status 0x%08x\n", __func__, *status);
+
+        return 0;
+}
+
+static int s5h1411_qam256_lookup_snr(struct dvb_frontend *fe, u16 *snr, u16 v)
+{
+        int i, ret = -EINVAL;
+        dprintk("%s()\n", __func__);
+
+        for (i = 0; i < ARRAY_SIZE(qam256_snr_tab); i++) {
+                if (v < qam256_snr_tab[i].val) {
+                        *snr = qam256_snr_tab[i].data;
+                        ret = 0;
+                        break;
+                }
+        }
+        return ret;
+}
+
+static int s5h1411_qam64_lookup_snr(struct dvb_frontend *fe, u16 *snr, u16 v)
+{
+        int i, ret = -EINVAL;
+        dprintk("%s()\n", __func__);
+
+        for (i = 0; i < ARRAY_SIZE(qam64_snr_tab); i++) {
+                if (v < qam64_snr_tab[i].val) {
+                        *snr = qam64_snr_tab[i].data;
+                        ret = 0;
+                        break;
+                }
+        }
+        return ret;
+}
+
+static int s5h1411_vsb_lookup_snr(struct dvb_frontend *fe, u16 *snr, u16 v)
+{
+        int i, ret = -EINVAL;
+        dprintk("%s()\n", __func__);
+
+        for (i = 0; i < ARRAY_SIZE(vsb_snr_tab); i++) {
+                if (v > vsb_snr_tab[i].val) {
+                        *snr = vsb_snr_tab[i].data;
+                        ret = 0;
+                        break;
+                }
+        }
+        dprintk("%s() snr=%d\n", __func__, *snr);
+        return ret;
+}
+
+static int s5h1411_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        u16 reg;
+        dprintk("%s()\n", __func__);
+
+        switch (state->current_modulation) {
+        case QAM_64:
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xf1);
+                return s5h1411_qam64_lookup_snr(fe, snr, reg);
+        case QAM_256:
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xf1);
+                return s5h1411_qam256_lookup_snr(fe, snr, reg);
+        case VSB_8:
+                reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR,
+                        0xf2) & 0x3ff;
+                return s5h1411_vsb_lookup_snr(fe, snr, reg);
+        default:
+                break;
+        }
+
+        return -EINVAL;
+}
+
+static int s5h1411_read_signal_strength(struct dvb_frontend *fe,
+        u16 *signal_strength)
+{
+        return s5h1411_read_snr(fe, signal_strength);
+}
+
+static int s5h1411_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        *ucblocks = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0xc9);
+
+        return 0;
+}
+
+static int s5h1411_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        return s5h1411_read_ucblocks(fe, ber);
+}
+
+static int s5h1411_get_frontend(struct dvb_frontend *fe,
+                                struct dvb_frontend_parameters *p)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+
+        p->frequency = state->current_frequency;
+        p->u.vsb.modulation = state->current_modulation;
+
+        return 0;
+}
+
+static int s5h1411_get_tune_settings(struct dvb_frontend *fe,
+                                     struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1000;
+        return 0;
+}
+
+static void s5h1411_release(struct dvb_frontend *fe)
+{
+        struct s5h1411_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops s5h1411_ops;
+
+struct dvb_frontend *s5h1411_attach(const struct s5h1411_config *config,
+                                    struct i2c_adapter *i2c)
+{
+        struct s5h1411_state *state = NULL;
+        u16 reg;
+
+        /* allocate memory for the internal state */
+        state = kmalloc(sizeof(struct s5h1411_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        /* setup the state */
+        state->config = config;
+        state->i2c = i2c;
+        state->current_modulation = VSB_8;
+        state->inversion = state->config->inversion;
+
+        /* check if the demod exists */
+        reg = s5h1411_readreg(state, S5H1411_I2C_TOP_ADDR, 0x05);
+        if (reg != 0x0066)
+                goto error;
+
+        /* create dvb_frontend */
+        memcpy(&state->frontend.ops, &s5h1411_ops,
+               sizeof(struct dvb_frontend_ops));
+
+        state->frontend.demodulator_priv = state;
+
+        if (s5h1411_init(&state->frontend) != 0) {
+                printk(KERN_ERR "%s: Failed to initialize correctly\n",
+                        __func__);
+                goto error;
+        }
+
+        /* Note: Leaving the I2C gate open here. */
+        s5h1411_writereg(state, S5H1411_I2C_TOP_ADDR, 0xf5, 1);
+
+        return &state->frontend;
+
+error:
+        kfree(state);
+        return NULL;
+}
+EXPORT_SYMBOL(s5h1411_attach);
+
+static struct dvb_frontend_ops s5h1411_ops = {
+
+        .info = {
+                .name                   = "Samsung S5H1411 QAM/8VSB Frontend",
+                .type                   = FE_ATSC,
+                .frequency_min          = 54000000,
+                .frequency_max          = 858000000,
+                .frequency_stepsize     = 62500,
+                .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
+        },
+
+        .init                 = s5h1411_init,
+        .i2c_gate_ctrl        = s5h1411_i2c_gate_ctrl,
+        .set_frontend         = s5h1411_set_frontend,
+        .get_frontend         = s5h1411_get_frontend,
+        .get_tune_settings    = s5h1411_get_tune_settings,
+        .read_status          = s5h1411_read_status,
+        .read_ber             = s5h1411_read_ber,
+        .read_signal_strength = s5h1411_read_signal_strength,
+        .read_snr             = s5h1411_read_snr,
+        .read_ucblocks        = s5h1411_read_ucblocks,
+        .release              = s5h1411_release,
+};
+
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Enable verbose debug messages");
+
+MODULE_DESCRIPTION("Samsung S5H1411 QAM-B/ATSC Demodulator driver");
+MODULE_AUTHOR("Steven Toth");
+MODULE_LICENSE("GPL");
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
diff --git a/drivers/media/dvb/frontends/s5h1411.h b/drivers/media/dvb/frontends/s5h1411.h
new file mode 100644
index 000000000000..1855f64ed4d8
--- /dev/null
+++ b/drivers/media/dvb/frontends/s5h1411.h
@@ -0,0 +1,90 @@
+/*
+    Samsung S5H1411 VSB/QAM demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __S5H1411_H__
+#define __S5H1411_H__
+
+#include <linux/dvb/frontend.h>
+
+#define S5H1411_I2C_TOP_ADDR (0x32 >> 1)
+#define S5H1411_I2C_QAM_ADDR (0x34 >> 1)
+
+struct s5h1411_config {
+
+        /* serial/parallel output */
+#define S5H1411_PARALLEL_OUTPUT 0
+#define S5H1411_SERIAL_OUTPUT   1
+        u8 output_mode;
+
+        /* GPIO Setting */
+#define S5H1411_GPIO_OFF 0
+#define S5H1411_GPIO_ON  1
+        u8 gpio;
+
+        /* MPEG signal timing */
+#define S5H1411_MPEGTIMING_CONTINOUS_INVERTING_CLOCK       0
+#define S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK    1
+#define S5H1411_MPEGTIMING_NONCONTINOUS_INVERTING_CLOCK    2
+#define S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK 3
+        u16 mpeg_timing;
+
+        /* IF Freq for QAM and VSB in KHz */
+#define S5H1411_IF_2500  2500
+#define S5H1411_IF_3500  3500
+#define S5H1411_IF_4000  4000
+#define S5H1411_IF_5380  5380
+#define S5H1411_IF_44000 44000
+#define S5H1411_VSB_IF_DEFAULT S5H1411_IF_44000
+#define S5H1411_QAM_IF_DEFAULT S5H1411_IF_44000
+        u16 qam_if;
+        u16 vsb_if;
+
+        /* Spectral Inversion */
+#define S5H1411_INVERSION_OFF 0
+#define S5H1411_INVERSION_ON  1
+        u8 inversion;
+
+        /* Return lock status based on tuner lock, or demod lock */
+#define S5H1411_TUNERLOCKING 0
+#define S5H1411_DEMODLOCKING 1
+        u8 status_mode;
+};
+
+#if defined(CONFIG_DVB_S5H1411) || \
+        (defined(CONFIG_DVB_S5H1411_MODULE) && defined(MODULE))
+extern struct dvb_frontend *s5h1411_attach(const struct s5h1411_config *config,
+                                           struct i2c_adapter *i2c);
+#else
+static inline struct dvb_frontend *s5h1411_attach(
+        const struct s5h1411_config *config,
+        struct i2c_adapter *i2c)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+#endif /* CONFIG_DVB_S5H1411 */
+
+#endif /* __S5H1411_H__ */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
diff --git a/drivers/media/video/au0828/Kconfig b/drivers/media/video/au0828/Kconfig
index c97c4bd24841..41708267e7a4 100644
--- a/drivers/media/video/au0828/Kconfig
+++ b/drivers/media/video/au0828/Kconfig
@@ -1,7 +1,7 @@
 
 config VIDEO_AU0828
         tristate "Auvitek AU0828 support"
-        depends on VIDEO_DEV && I2C && INPUT
+       depends on VIDEO_DEV && I2C && INPUT && DVB_CORE
         select I2C_ALGOBIT
         select DVB_AU8522 if !DVB_FE_CUSTOMIZE
         select DVB_TUNER_XC5000 if !DVB_FE_CUSTOMIZE
diff --git a/drivers/media/video/au0828/au0828-cards.c b/drivers/media/video/au0828/au0828-cards.c
index 8ca91f814277..a2a6983444fa 100644
--- a/drivers/media/video/au0828/au0828-cards.c
+++ b/drivers/media/video/au0828/au0828-cards.c
@@ -36,7 +36,6 @@ struct au0828_board au0828_boards[] = {
                 .name   = "DViCO FusionHDTV USB",
         },
 };
-const unsigned int au0828_bcount = ARRAY_SIZE(au0828_boards);
 
 /* Tuner callback function for au0828 boards. Currently only needed
  * for HVR1500Q, which has an xc5000 tuner.
diff --git a/drivers/media/video/au0828/au0828-core.c b/drivers/media/video/au0828/au0828-core.c
index e65d5642cb1d..54bfc0f05295 100644
--- a/drivers/media/video/au0828/au0828-core.c
+++ b/drivers/media/video/au0828/au0828-core.c
@@ -32,18 +32,10 @@
  * 4 = I2C related
  * 8 = Bridge related
  */
-unsigned int debug;
-module_param(debug, int, 0644);
+int au0828_debug;
+module_param_named(debug, au0828_debug, int, 0644);
 MODULE_PARM_DESC(debug, "enable debug messages");
 
-unsigned int usb_debug;
-module_param(usb_debug, int, 0644);
-MODULE_PARM_DESC(usb_debug, "enable usb debug messages");
-
-unsigned int bridge_debug;
-module_param(bridge_debug, int, 0644);
-MODULE_PARM_DESC(bridge_debug, "enable bridge debug messages");
-
 #define _AU0828_BULKPIPE 0x03
 #define _BULKPIPESIZE 0xffff
 
@@ -229,24 +221,18 @@ static int __init au0828_init(void)
 {
         int ret;
 
-        if (debug)
+        if (au0828_debug & 1)
                 printk(KERN_INFO "%s() Debugging is enabled\n", __func__);
 
-        if (usb_debug) {
+        if (au0828_debug & 2)
                 printk(KERN_INFO "%s() USB Debugging is enabled\n", __func__);
-                debug |= 2;
-        }
 
-        if (i2c_debug) {
+        if (au0828_debug & 4)
                 printk(KERN_INFO "%s() I2C Debugging is enabled\n", __func__);
-                debug |= 4;
-        }
 
-        if (bridge_debug) {
+        if (au0828_debug & 8)
                 printk(KERN_INFO "%s() Bridge Debugging is enabled\n",
                        __func__);
-                debug |= 8;
-        }
 
         printk(KERN_INFO "au0828 driver loaded\n");
 
diff --git a/drivers/media/video/au0828/au0828-dvb.c b/drivers/media/video/au0828/au0828-dvb.c
index 85d0ae9a322f..5040d7fc4af5 100644
--- a/drivers/media/video/au0828/au0828-dvb.c
+++ b/drivers/media/video/au0828/au0828-dvb.c
@@ -204,7 +204,7 @@ static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
         return ret;
 }
 
-int dvb_register(struct au0828_dev *dev)
+static int dvb_register(struct au0828_dev *dev)
 {
         struct au0828_dvb *dvb = &dev->dvb;
         int result;
diff --git a/drivers/media/video/au0828/au0828-i2c.c b/drivers/media/video/au0828/au0828-i2c.c
index 94c8b74a6651..741a4937b050 100644
--- a/drivers/media/video/au0828/au0828-i2c.c
+++ b/drivers/media/video/au0828/au0828-i2c.c
@@ -29,11 +29,7 @@
 
 #include <media/v4l2-common.h>
 
-unsigned int i2c_debug;
-module_param(i2c_debug, int, 0444);
-MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
-
-unsigned int i2c_scan;
+static int i2c_scan;
 module_param(i2c_scan, int, 0444);
 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
 
diff --git a/drivers/media/video/au0828/au0828.h b/drivers/media/video/au0828/au0828.h
index 0200b9fc5dc4..7beb571798e5 100644
--- a/drivers/media/video/au0828/au0828.h
+++ b/drivers/media/video/au0828/au0828.h
@@ -96,15 +96,12 @@ struct au0828_buff {
 /* au0828-core.c */
 extern u32 au0828_read(struct au0828_dev *dev, u16 reg);
 extern u32 au0828_write(struct au0828_dev *dev, u16 reg, u32 val);
-extern unsigned int debug;
-extern unsigned int usb_debug;
-extern unsigned int bridge_debug;
+extern int au0828_debug;
 
 /* ----------------------------------------------------------- */
 /* au0828-cards.c */
 extern struct au0828_board au0828_boards[];
 extern struct usb_device_id au0828_usb_id_table[];
-extern const unsigned int au0828_bcount;
 extern void au0828_gpio_setup(struct au0828_dev *dev);
 extern int au0828_tuner_callback(void *priv, int command, int arg);
 extern void au0828_card_setup(struct au0828_dev *dev);
@@ -115,7 +112,6 @@ extern int au0828_i2c_register(struct au0828_dev *dev);
 extern int au0828_i2c_unregister(struct au0828_dev *dev);
 extern void au0828_call_i2c_clients(struct au0828_dev *dev,
         unsigned int cmd, void *arg);
-extern unsigned int i2c_debug;
 
 /* ----------------------------------------------------------- */
 /* au0828-dvb.c */
@@ -123,6 +119,6 @@ extern int au0828_dvb_register(struct au0828_dev *dev);
 extern void au0828_dvb_unregister(struct au0828_dev *dev);
 
 #define dprintk(level, fmt, arg...)\
-        do { if (debug & level)\
+        do { if (au0828_debug & level)\
                 printk(KERN_DEBUG DRIVER_NAME "/0: " fmt, ## arg);\
         } while (0)
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index 870d6e197d65..f05649727b60 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -191,7 +191,7 @@ static struct tda18271_config hauppauge_hvr1200_tuner_config = {
         .gate    = TDA18271_GATE_ANALOG,
 };
 
-struct dibx000_agc_config xc3028_agc_config = {
+static struct dibx000_agc_config xc3028_agc_config = {
         BAND_VHF | BAND_UHF,    /* band_caps */
 
         /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
@@ -237,7 +237,7 @@ struct dibx000_agc_config xc3028_agc_config = {
 
 /* PLL Configuration for COFDM BW_MHz = 8.000000
  * With external clock = 30.000000 */
-struct dibx000_bandwidth_config xc3028_bw_config = {
+static struct dibx000_bandwidth_config xc3028_bw_config = {
         60000,  /* internal */
         30000,  /* sampling */
         1,      /* pll_cfg: prediv */
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig
index bcf6d9ba063d..27635cdcbaf2 100644
--- a/drivers/media/video/cx88/Kconfig
+++ b/drivers/media/video/cx88/Kconfig
@@ -58,6 +58,7 @@ config VIDEO_CX88_DVB
         select DVB_CX24123 if !DVB_FE_CUSTOMISE
         select DVB_ISL6421 if !DVB_FE_CUSTOMISE
         select TUNER_SIMPLE if !DVB_FE_CUSTOMISE
+        select DVB_S5H1411 if !DVB_FE_CUSTOMISE
         ---help---
           This adds support for DVB/ATSC cards based on the
           Conexant 2388x chip.
diff --git a/drivers/media/video/cx88/cx88-blackbird.c b/drivers/media/video/cx88/cx88-blackbird.c
index 61c4f72644b8..6c0c94c5ef91 100644
--- a/drivers/media/video/cx88/cx88-blackbird.c
+++ b/drivers/media/video/cx88/cx88-blackbird.c
@@ -546,10 +546,12 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
                 if (retval < 0)
                         return retval;
 
-                dev->mailbox = blackbird_find_mailbox(dev);
-                if (dev->mailbox < 0)
+                retval = blackbird_find_mailbox(dev);
+                if (retval < 0)
                         return -1;
 
+                dev->mailbox = retval;
+
                 retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
                 if (retval < 0) {
                         dprintk(0, "ERROR: Firmware ping failed!\n");
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index 620159d05506..2b6b283cda15 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1591,6 +1591,7 @@ static const struct cx88_board cx88_boards[] = {
                         .vmux   = 2,
                         .gpio0  = 0x16d9,
                 }},
+                .mpeg           = CX88_MPEG_DVB,
         },
         [CX88_BOARD_PROLINK_PV_8000GT] = {
                 .name           = "Prolink Pixelview MPEG 8000GT",
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index f1251b844e08..1c7fe6862a60 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -47,6 +47,7 @@
 #include "isl6421.h"
 #include "tuner-simple.h"
 #include "tda9887.h"
+#include "s5h1411.h"
 
 MODULE_DESCRIPTION("driver for cx2388x based DVB cards");
 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
@@ -463,6 +464,22 @@ static struct zl10353_config cx88_geniatech_x8000_mt = {
        .no_tuner = 1,
 };
 
+static struct s5h1411_config dvico_fusionhdtv7_config = {
+        .output_mode   = S5H1411_SERIAL_OUTPUT,
+        .gpio          = S5H1411_GPIO_ON,
+        .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
+        .qam_if        = S5H1411_IF_44000,
+        .vsb_if        = S5H1411_IF_44000,
+        .inversion     = S5H1411_INVERSION_OFF,
+        .status_mode   = S5H1411_DEMODLOCKING
+};
+
+static struct xc5000_config dvico_fusionhdtv7_tuner_config = {
+        .i2c_address    = 0xc2 >> 1,
+        .if_khz         = 5380,
+        .tuner_callback = cx88_tuner_callback,
+};
+
 static int attach_xc3028(u8 addr, struct cx8802_dev *dev)
 {
         struct dvb_frontend *fe;
@@ -844,6 +861,21 @@ static int dvb_register(struct cx8802_dev *dev)
                 if (attach_xc3028(0x61, dev) < 0)
                         return -EINVAL;
                 break;
+        case CX88_BOARD_DVICO_FUSIONHDTV_7_GOLD:
+                dev->dvb.frontend = dvb_attach(s5h1411_attach,
+                                               &dvico_fusionhdtv7_config,
+                                               &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        /* tuner_config.video_dev must point to
+                         * i2c_adap.algo_data
+                         */
+                        dvico_fusionhdtv7_tuner_config.priv =
+                                                dev->core->i2c_adap.algo_data;
+                        dvb_attach(xc5000_attach, dev->dvb.frontend,
+                                   &dev->core->i2c_adap,
+                                   &dvico_fusionhdtv7_tuner_config);
+                }
+                break;
         default:
                 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n",
                        dev->core->name);
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index f8c41d8c74c4..5d837c16ee22 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -650,7 +650,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
 
         dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
                                               GFP_KERNEL);
-        if (!dev->isoc_ctl.urb) {
+        if (!dev->isoc_ctl.transfer_buffer) {
                 em28xx_errdev("cannot allocate memory for usbtransfer\n");
                 kfree(dev->isoc_ctl.urb);
                 return -ENOMEM;
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 11c5fdedc23b..7b65f5e537f8 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -509,8 +509,11 @@ static int ir_probe(struct i2c_adapter *adap)
         static const int probe_cx88[] = { 0x18, 0x6b, 0x71, -1 };
         static const int probe_cx23885[] = { 0x6b, -1 };
         const int *probe;
-        struct i2c_client *c;
-        unsigned char buf;
+        struct i2c_msg msg = {
+                .flags = I2C_M_RD,
+                .len = 0,
+                .buf = NULL,
+        };
         int i, rc;
 
         switch (adap->id) {
@@ -536,23 +539,17 @@ static int ir_probe(struct i2c_adapter *adap)
                 return 0;
         }
 
-        c = kzalloc(sizeof(*c), GFP_KERNEL);
-        if (!c)
-                return -ENOMEM;
-
-        c->adapter = adap;
         for (i = 0; -1 != probe[i]; i++) {
-                c->addr = probe[i];
-                rc = i2c_master_recv(c, &buf, 0);
+                msg.addr = probe[i];
+                rc = i2c_transfer(adap, &msg, 1);
                 dprintk(1,"probe 0x%02x @ %s: %s\n",
                         probe[i], adap->name,
-                        (0 == rc) ? "yes" : "no");
-                if (0 == rc) {
+                        (1 == rc) ? "yes" : "no");
+                if (1 == rc) {
                         ir_attach(adap, probe[i], 0, 0);
                         break;
                 }
         }
-        kfree(c);
         return 0;
 }
 
diff --git a/drivers/media/video/pvrusb2/Kconfig b/drivers/media/video/pvrusb2/Kconfig
index a8da90f69dd9..158b3d0c6532 100644
--- a/drivers/media/video/pvrusb2/Kconfig
+++ b/drivers/media/video/pvrusb2/Kconfig
@@ -64,6 +64,7 @@ config VIDEO_PVRUSB2_DVB
         depends on VIDEO_PVRUSB2 && DVB_CORE && EXPERIMENTAL
         select DVB_LGDT330X if !DVB_FE_CUSTOMISE
         select DVB_S5H1409 if !DVB_FE_CUSTOMISE
+        select DVB_S5H1411 if !DVB_FE_CUSTOMISE
         select DVB_TDA10048 if !DVB_FE_CUSTOMIZE
         select DVB_TDA18271 if !DVB_FE_CUSTOMIZE
         select TUNER_SIMPLE if !DVB_FE_CUSTOMISE
diff --git a/drivers/media/video/pvrusb2/pvrusb2-devattr.c b/drivers/media/video/pvrusb2/pvrusb2-devattr.c
index 2dd06a90adce..3a141d93e1a9 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-devattr.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-devattr.c
@@ -36,6 +36,7 @@ pvr2_device_desc structures.
 #include "pvrusb2-hdw-internal.h"
 #include "lgdt330x.h"
 #include "s5h1409.h"
+#include "s5h1411.h"
 #include "tda10048.h"
 #include "tda18271.h"
 #include "tda8290.h"
@@ -368,6 +369,15 @@ static struct s5h1409_config pvr2_s5h1409_config = {
         .status_mode   = S5H1409_DEMODLOCKING,
 };
 
+static struct s5h1411_config pvr2_s5h1411_config = {
+        .output_mode   = S5H1411_PARALLEL_OUTPUT,
+        .gpio          = S5H1411_GPIO_OFF,
+        .vsb_if        = S5H1411_IF_44000,
+        .qam_if        = S5H1411_IF_4000,
+        .inversion     = S5H1411_INVERSION_ON,
+        .status_mode   = S5H1411_DEMODLOCKING,
+};
+
 static struct tda18271_std_map hauppauge_tda18271_std_map = {
         .atsc_6   = { .if_freq = 5380, .agc_mode = 3, .std = 3,
                       .if_lvl = 6, .rfagc_top = 0x37, },
@@ -390,6 +400,16 @@ static int pvr2_s5h1409_attach(struct pvr2_dvb_adapter *adap)
         return -EIO;
 }
 
+static int pvr2_s5h1411_attach(struct pvr2_dvb_adapter *adap)
+{
+        adap->fe = dvb_attach(s5h1411_attach, &pvr2_s5h1411_config,
+                              &adap->channel.hdw->i2c_adap);
+        if (adap->fe)
+                return 0;
+
+        return -EIO;
+}
+
 static int pvr2_tda18271_8295_attach(struct pvr2_dvb_adapter *adap)
 {
         dvb_attach(tda829x_attach, adap->fe,
@@ -406,6 +426,11 @@ struct pvr2_dvb_props pvr2_750xx_dvb_props = {
         .frontend_attach = pvr2_s5h1409_attach,
         .tuner_attach    = pvr2_tda18271_8295_attach,
 };
+
+struct pvr2_dvb_props pvr2_751xx_dvb_props = {
+        .frontend_attach = pvr2_s5h1411_attach,
+        .tuner_attach    = pvr2_tda18271_8295_attach,
+};
 #endif
 
 static const char *pvr2_client_75xxx[] = {
@@ -454,6 +479,9 @@ static const struct pvr2_device_desc pvr2_device_751xx = {
                 .digital_control_scheme = PVR2_DIGITAL_SCHEME_HAUPPAUGE,
                 .default_std_mask = V4L2_STD_NTSC_M,
                 .led_scheme = PVR2_LED_SCHEME_HAUPPAUGE,
+#ifdef CONFIG_VIDEO_PVRUSB2_DVB
+                .dvb_props = &pvr2_751xx_dvb_props,
+#endif
 };
 
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-devattr.h b/drivers/media/video/pvrusb2/pvrusb2-devattr.h
index c2e2b06fe2e0..d016f8b6c70b 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-devattr.h
+++ b/drivers/media/video/pvrusb2/pvrusb2-devattr.h
@@ -104,28 +104,28 @@ struct pvr2_device_desc {
         unsigned char digital_control_scheme;
 
         /* If set, we don't bother trying to load cx23416 firmware. */
-        int flag_skip_cx23416_firmware:1;
+        unsigned int flag_skip_cx23416_firmware:1;
 
         /* If set, the encoder must be healthy in order for digital mode to
            work (otherwise we assume that digital streaming will work even
            if we fail to locate firmware for the encoder).  If the device
            doesn't support digital streaming then this flag has no
            effect. */
-        int flag_digital_requires_cx23416:1;
+        unsigned int flag_digital_requires_cx23416:1;
 
         /* Device has a hauppauge eeprom which we can interrogate. */
-        int flag_has_hauppauge_rom:1;
+        unsigned int flag_has_hauppauge_rom:1;
 
         /* Device does not require a powerup command to be issued. */
-        int flag_no_powerup:1;
+        unsigned int flag_no_powerup:1;
 
         /* Device has a cx25840 - this enables special additional logic to
            handle it. */
-        int flag_has_cx25840:1;
+        unsigned int flag_has_cx25840:1;
 
         /* Device has a wm8775 - this enables special additional logic to
            ensure that it is found. */
-        int flag_has_wm8775:1;
+        unsigned int flag_has_wm8775:1;
 
         /* Device has IR hardware that can be faked into looking like a
            normal Hauppauge i2c IR receiver.  This is currently very
@@ -135,15 +135,15 @@ struct pvr2_device_desc {
            to virtualize the presence of the non-existant IR receiver chip and
            implement the virtual receiver in terms of appropriate FX2
            commands. */
-        int flag_has_hauppauge_custom_ir:1;
+        unsigned int flag_has_hauppauge_custom_ir:1;
 
         /* These bits define which kinds of sources the device can handle.
            Note: Digital tuner presence is inferred by the
            digital_control_scheme enumeration. */
-        int flag_has_fmradio:1;       /* Has FM radio receiver */
-        int flag_has_analogtuner:1;   /* Has analog tuner */
-        int flag_has_composite:1;     /* Has composite input */
-        int flag_has_svideo:1;        /* Has s-video input */
+        unsigned int flag_has_fmradio:1;       /* Has FM radio receiver */
+        unsigned int flag_has_analogtuner:1;   /* Has analog tuner */
+        unsigned int flag_has_composite:1;     /* Has composite input */
+        unsigned int flag_has_svideo:1;        /* Has s-video input */
 };
 
 extern struct usb_device_id pvr2_device_table[];
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 529e00952a8d..2b72e10e6b9f 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -369,19 +369,13 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 break;
         }
         case TUNER_TEA5767:
-                if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
+                        goto attach_failed;
                 t->mode_mask = T_RADIO;
                 break;
         case TUNER_TEA5761:
-                if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
+                        goto attach_failed;
                 t->mode_mask = T_RADIO;
                 break;
         case TUNER_PHILIPS_FMD1216ME_MK3:
@@ -394,12 +388,9 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 buffer[2] = 0x86;
                 buffer[3] = 0x54;
                 i2c_master_send(c, buffer, 4);
-                if (simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr,
-                                        t->type) == NULL) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr,
+                                        t->type))
+                        goto attach_failed;
                 break;
         case TUNER_PHILIPS_TD1316:
                 buffer[0] = 0x0b;
@@ -407,12 +398,9 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 buffer[2] = 0x86;
                 buffer[3] = 0xa4;
                 i2c_master_send(c,buffer,4);
-                if (simple_tuner_attach(&t->fe, t->i2c->adapter,
-                                        t->i2c->addr, t->type) == NULL) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
+                                        t->i2c->addr, t->type))
+                        goto attach_failed;
                 break;
         case TUNER_XC2028:
         {
@@ -421,40 +409,34 @@ static void set_type(struct i2c_client *c, unsigned int type,
                         .i2c_addr  = t->i2c->addr,
                         .callback  = t->tuner_callback,
                 };
-                if (!xc2028_attach(&t->fe, &cfg)) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!xc2028_attach(&t->fe, &cfg))
+                        goto attach_failed;
                 break;
         }
         case TUNER_TDA9887:
                 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
                 break;
         case TUNER_XC5000:
+        {
+                struct dvb_tuner_ops *xc_tuner_ops;
+
                 xc5000_cfg.i2c_address    = t->i2c->addr;
                 xc5000_cfg.if_khz         = 5380;
                 xc5000_cfg.priv           = c->adapter->algo_data;
                 xc5000_cfg.tuner_callback = t->tuner_callback;
-                if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg)) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
-                {
-                struct dvb_tuner_ops *xc_tuner_ops;
+                if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg))
+                        goto attach_failed;
+
                 xc_tuner_ops = &t->fe.ops.tuner_ops;
-                if(xc_tuner_ops->init != NULL)
+                if (xc_tuner_ops->init)
                         xc_tuner_ops->init(&t->fe);
-                }
                 break;
+        }
         default:
-                if (simple_tuner_attach(&t->fe, t->i2c->adapter,
-                                        t->i2c->addr, t->type) == NULL) {
-                        t->type = TUNER_ABSENT;
-                        t->mode_mask = T_UNINITIALIZED;
-                        return;
-                }
+                if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
+                                        t->i2c->addr, t->type))
+                        goto attach_failed;
+
                 break;
         }
 
@@ -476,11 +458,27 @@ static void set_type(struct i2c_client *c, unsigned int type,
         if (t->mode_mask == T_UNINITIALIZED)
                 t->mode_mask = new_mode_mask;
 
-        set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
+        /* xc2028/3028 and xc5000 requires a firmware to be set-up later
+           trying to set a frequency here will just fail
+           FIXME: better to move set_freq to the tuner code. This is needed
+           on analog tuners for PLL to properly work
+         */
+        if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
+                set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
+                            t->radio_freq : t->tv_freq);
+
         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
                   t->mode_mask);
         tuner_i2c_address_check(t);
+        return;
+
+attach_failed:
+        tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
+        t->type = TUNER_ABSENT;
+        t->mode_mask = T_UNINITIALIZED;
+
+        return;
 }
 
 /*
@@ -495,14 +493,16 @@ static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 {
         struct tuner *t = i2c_get_clientdata(c);
 
-        tuner_dbg("set addr for type %i\n", t->type);
-
         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
                 (t->mode_mask & tun_setup->mode_mask))) ||
                 (tun_setup->addr == c->addr)) {
                         set_type(c, tun_setup->type, tun_setup->mode_mask,
                                  tun_setup->config, tun_setup->tuner_callback);
-        }
+        } else
+                tuner_dbg("set addr discarded for type %i, mask %x. "
+                          "Asked to change tuner at addr 0x%02x, with mask %x\n",
+                          t->type, t->mode_mask,
+                          tun_setup->addr, tun_setup->mode_mask);
 }
 
 static inline int check_mode(struct tuner *t, char *cmd)
diff --git a/drivers/media/video/tuner-xc2028.c b/drivers/media/video/tuner-xc2028.c
index cc3db7d79a0d..9e9003cffc7f 100644
--- a/drivers/media/video/tuner-xc2028.c
+++ b/drivers/media/video/tuner-xc2028.c
@@ -432,7 +432,7 @@ static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
 
         type &= type_mask;
 
-        if (!type & SCODE)
+        if (!(type & SCODE))
                 type_mask = ~0;
 
         /* Seek for exact match */
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index b1e9592acb90..845be1864f68 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -888,7 +888,7 @@ static int vivi_open(struct inode *inode, struct file *file)
 {
         int minor = iminor(inode);
         struct vivi_dev *dev;
-        struct vivi_fh *fh;
+        struct vivi_fh *fh = NULL;
         int i;
         int retval = 0;
 
diff --git a/drivers/misc/enclosure.c b/drivers/misc/enclosure.c
index fafb57fed761..0736cff9d97a 100644
--- a/drivers/misc/enclosure.c
+++ b/drivers/misc/enclosure.c
@@ -31,7 +31,6 @@
 static LIST_HEAD(container_list);
 static DEFINE_MUTEX(container_list_lock);
 static struct class enclosure_class;
-static struct class enclosure_component_class;
 
 /**
  * enclosure_find - find an enclosure given a device
@@ -166,6 +165,40 @@ void enclosure_unregister(struct enclosure_device *edev)
 }
 EXPORT_SYMBOL_GPL(enclosure_unregister);
 
+#define ENCLOSURE_NAME_SIZE     64
+
+static void enclosure_link_name(struct enclosure_component *cdev, char *name)
+{
+        strcpy(name, "enclosure_device:");
+        strcat(name, cdev->cdev.bus_id);
+}
+
+static void enclosure_remove_links(struct enclosure_component *cdev)
+{
+        char name[ENCLOSURE_NAME_SIZE];
+
+        enclosure_link_name(cdev, name);
+        sysfs_remove_link(&cdev->dev->kobj, name);
+        sysfs_remove_link(&cdev->cdev.kobj, "device");
+}
+
+static int enclosure_add_links(struct enclosure_component *cdev)
+{
+        int error;
+        char name[ENCLOSURE_NAME_SIZE];
+
+        error = sysfs_create_link(&cdev->cdev.kobj, &cdev->dev->kobj, "device");
+        if (error)
+                return error;
+
+        enclosure_link_name(cdev, name);
+        error = sysfs_create_link(&cdev->dev->kobj, &cdev->cdev.kobj, name);
+        if (error)
+                sysfs_remove_link(&cdev->cdev.kobj, "device");
+
+        return error;
+}
+
 static void enclosure_release(struct device *cdev)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev);
@@ -178,10 +211,15 @@ static void enclosure_component_release(struct device *dev)
 {
         struct enclosure_component *cdev = to_enclosure_component(dev);
 
-        put_device(cdev->dev);
+        if (cdev->dev) {
+                enclosure_remove_links(cdev);
+                put_device(cdev->dev);
+        }
         put_device(dev->parent);
 }
 
+static struct attribute_group *enclosure_groups[];
+
 /**
  * enclosure_component_register - add a particular component to an enclosure
  * @edev:       the enclosure to add the component
@@ -217,12 +255,14 @@ enclosure_component_register(struct enclosure_device *edev,
         ecomp->number = number;
         cdev = &ecomp->cdev;
         cdev->parent = get_device(&edev->edev);
-        cdev->class = &enclosure_component_class;
         if (name)
                 snprintf(cdev->bus_id, BUS_ID_SIZE, "%s", name);
         else
                 snprintf(cdev->bus_id, BUS_ID_SIZE, "%u", number);
 
+        cdev->release = enclosure_component_release;
+        cdev->groups = enclosure_groups;
+
         err = device_register(cdev);
         if (err)
                 ERR_PTR(err);
@@ -255,10 +295,12 @@ int enclosure_add_device(struct enclosure_device *edev, int component,
 
         cdev = &edev->component[component];
 
-        device_del(&cdev->cdev);
+        if (cdev->dev)
+                enclosure_remove_links(cdev);
+
         put_device(cdev->dev);
         cdev->dev = get_device(dev);
-        return device_add(&cdev->cdev);
+        return enclosure_add_links(cdev);
 }
 EXPORT_SYMBOL_GPL(enclosure_add_device);
 
@@ -442,24 +484,32 @@ static ssize_t get_component_type(struct device *cdev,
 }
 
 
-static struct device_attribute enclosure_component_attrs[] = {
-        __ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
-               set_component_fault),
-        __ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
-               set_component_status),
-        __ATTR(active, S_IRUGO | S_IWUSR, get_component_active,
-               set_component_active),
-        __ATTR(locate, S_IRUGO | S_IWUSR, get_component_locate,
-               set_component_locate),
-        __ATTR(type, S_IRUGO, get_component_type, NULL),
-        __ATTR_NULL
+static DEVICE_ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
+                    set_component_fault);
+static DEVICE_ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
+                   set_component_status);
+static DEVICE_ATTR(active, S_IRUGO | S_IWUSR, get_component_active,
+                   set_component_active);
+static DEVICE_ATTR(locate, S_IRUGO | S_IWUSR, get_component_locate,
+                   set_component_locate);
+static DEVICE_ATTR(type, S_IRUGO, get_component_type, NULL);
+
+static struct attribute *enclosure_component_attrs[] = {
+        &dev_attr_fault.attr,
+        &dev_attr_status.attr,
+        &dev_attr_active.attr,
+        &dev_attr_locate.attr,
+        &dev_attr_type.attr,
+        NULL
 };
 
-static struct class enclosure_component_class =  {
-        .name                   = "enclosure_component",
-        .owner                  = THIS_MODULE,
-        .dev_attrs      = enclosure_component_attrs,
-        .dev_release            = enclosure_component_release,
+static struct attribute_group enclosure_group = {
+        .attrs = enclosure_component_attrs,
+};
+
+static struct attribute_group *enclosure_groups[] = {
+        &enclosure_group,
+        NULL
 };
 
 static int __init enclosure_init(void)
@@ -469,20 +519,12 @@ static int __init enclosure_init(void)
         err = class_register(&enclosure_class);
         if (err)
                 return err;
-        err = class_register(&enclosure_component_class);
-        if (err)
-                goto err_out;
 
         return 0;
- err_out:
-        class_unregister(&enclosure_class);
-
-        return err;
 }
 
 static void __exit enclosure_exit(void)
 {
-        class_unregister(&enclosure_component_class);
         class_unregister(&enclosure_class);
 }
 
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 0697aa8ea774..8082c1d142df 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2011,7 +2011,7 @@ config E1000_DISABLE_PACKET_SPLIT
 
 config E1000E
         tristate "Intel(R) PRO/1000 PCI-Express Gigabit Ethernet support"
-        depends on PCI
+        depends on PCI && (!SPARC32 || BROKEN)
         ---help---
           This driver supports the PCI-Express Intel(R) PRO/1000 gigabit
           ethernet family of adapters. For PCI or PCI-X e1000 adapters,
diff --git a/drivers/net/mlx4/alloc.c b/drivers/net/mlx4/alloc.c
index 75ef9d0d974d..f9d6b4dca180 100644
--- a/drivers/net/mlx4/alloc.c
+++ b/drivers/net/mlx4/alloc.c
@@ -196,3 +196,160 @@ void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
         }
 }
 EXPORT_SYMBOL_GPL(mlx4_buf_free);
+
+static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device)
+{
+        struct mlx4_db_pgdir *pgdir;
+
+        pgdir = kzalloc(sizeof *pgdir, GFP_KERNEL);
+        if (!pgdir)
+                return NULL;
+
+        bitmap_fill(pgdir->order1, MLX4_DB_PER_PAGE / 2);
+        pgdir->bits[0] = pgdir->order0;
+        pgdir->bits[1] = pgdir->order1;
+        pgdir->db_page = dma_alloc_coherent(dma_device, PAGE_SIZE,
+                                            &pgdir->db_dma, GFP_KERNEL);
+        if (!pgdir->db_page) {
+                kfree(pgdir);
+                return NULL;
+        }
+
+        return pgdir;
+}
+
+static int mlx4_alloc_db_from_pgdir(struct mlx4_db_pgdir *pgdir,
+                                    struct mlx4_db *db, int order)
+{
+        int o;
+        int i;
+
+        for (o = order; o <= 1; ++o) {
+                i = find_first_bit(pgdir->bits[o], MLX4_DB_PER_PAGE >> o);
+                if (i < MLX4_DB_PER_PAGE >> o)
+                        goto found;
+        }
+
+        return -ENOMEM;
+
+found:
+        clear_bit(i, pgdir->bits[o]);
+
+        i <<= o;
+
+        if (o > order)
+                set_bit(i ^ 1, pgdir->bits[order]);
+
+        db->u.pgdir = pgdir;
+        db->index   = i;
+        db->db      = pgdir->db_page + db->index;
+        db->dma     = pgdir->db_dma  + db->index * 4;
+        db->order   = order;
+
+        return 0;
+}
+
+int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        struct mlx4_db_pgdir *pgdir;
+        int ret = 0;
+
+        mutex_lock(&priv->pgdir_mutex);
+
+        list_for_each_entry(pgdir, &priv->pgdir_list, list)
+                if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
+                        goto out;
+
+        pgdir = mlx4_alloc_db_pgdir(&(dev->pdev->dev));
+        if (!pgdir) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        list_add(&pgdir->list, &priv->pgdir_list);
+
+        /* This should never fail -- we just allocated an empty page: */
+        WARN_ON(mlx4_alloc_db_from_pgdir(pgdir, db, order));
+
+out:
+        mutex_unlock(&priv->pgdir_mutex);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mlx4_db_alloc);
+
+void mlx4_db_free(struct mlx4_dev *dev, struct mlx4_db *db)
+{
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        int o;
+        int i;
+
+        mutex_lock(&priv->pgdir_mutex);
+
+        o = db->order;
+        i = db->index;
+
+        if (db->order == 0 && test_bit(i ^ 1, db->u.pgdir->order0)) {
+                clear_bit(i ^ 1, db->u.pgdir->order0);
+                ++o;
+        }
+        i >>= o;
+        set_bit(i, db->u.pgdir->bits[o]);
+
+        if (bitmap_full(db->u.pgdir->order1, MLX4_DB_PER_PAGE / 2)) {
+                dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
+                                  db->u.pgdir->db_page, db->u.pgdir->db_dma);
+                list_del(&db->u.pgdir->list);
+                kfree(db->u.pgdir);
+        }
+
+        mutex_unlock(&priv->pgdir_mutex);
+}
+EXPORT_SYMBOL_GPL(mlx4_db_free);
+
+int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
+                       int size, int max_direct)
+{
+        int err;
+
+        err = mlx4_db_alloc(dev, &wqres->db, 1);
+        if (err)
+                return err;
+
+        *wqres->db.db = 0;
+
+        err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf);
+        if (err)
+                goto err_db;
+
+        err = mlx4_mtt_init(dev, wqres->buf.npages, wqres->buf.page_shift,
+                            &wqres->mtt);
+        if (err)
+                goto err_buf;
+
+        err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf);
+        if (err)
+                goto err_mtt;
+
+        return 0;
+
+err_mtt:
+        mlx4_mtt_cleanup(dev, &wqres->mtt);
+err_buf:
+        mlx4_buf_free(dev, size, &wqres->buf);
+err_db:
+        mlx4_db_free(dev, &wqres->db);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_alloc_hwq_res);
+
+void mlx4_free_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
+                       int size)
+{
+        mlx4_mtt_cleanup(dev, &wqres->mtt);
+        mlx4_buf_free(dev, size, &wqres->buf);
+        mlx4_db_free(dev, &wqres->db);
+}
+EXPORT_SYMBOL_GPL(mlx4_free_hwq_res);
diff --git a/drivers/net/mlx4/cq.c b/drivers/net/mlx4/cq.c
index caa5bcf54e35..6fda0af9d0a6 100644
--- a/drivers/net/mlx4/cq.c
+++ b/drivers/net/mlx4/cq.c
@@ -180,7 +180,7 @@ int mlx4_cq_resize(struct mlx4_dev *dev, struct mlx4_cq *cq,
         cq_context->mtt_base_addr_h = mtt_addr >> 32;
         cq_context->mtt_base_addr_l = cpu_to_be32(mtt_addr & 0xffffffff);
 
-        err = mlx4_MODIFY_CQ(dev, mailbox, cq->cqn, 1);
+        err = mlx4_MODIFY_CQ(dev, mailbox, cq->cqn, 0);
 
         mlx4_free_cmd_mailbox(dev, mailbox);
         return err;
diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index 49a4acab5e82..a6aa49fc1d68 100644
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -798,6 +798,9 @@ static int __mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         INIT_LIST_HEAD(&priv->ctx_list);
         spin_lock_init(&priv->ctx_lock);
 
+        INIT_LIST_HEAD(&priv->pgdir_list);
+        mutex_init(&priv->pgdir_mutex);
+
         /*
          * Now reset the HCA before we touch the PCI capabilities or
          * attempt a firmware command, since a boot ROM may have left
diff --git a/drivers/net/mlx4/mlx4.h b/drivers/net/mlx4/mlx4.h
index 73336810e652..a4023c2dd050 100644
--- a/drivers/net/mlx4/mlx4.h
+++ b/drivers/net/mlx4/mlx4.h
@@ -257,6 +257,9 @@ struct mlx4_priv {
         struct list_head        ctx_list;
         spinlock_t              ctx_lock;
 
+        struct list_head        pgdir_list;
+        struct mutex            pgdir_mutex;
+
         struct mlx4_fw          fw;
         struct mlx4_cmd         cmd;
 
diff --git a/drivers/net/mlx4/qp.c b/drivers/net/mlx4/qp.c
index fa24e6597591..ee5484c44a18 100644
--- a/drivers/net/mlx4/qp.c
+++ b/drivers/net/mlx4/qp.c
@@ -299,3 +299,34 @@ int mlx4_qp_query(struct mlx4_dev *dev, struct mlx4_qp *qp,
 }
 EXPORT_SYMBOL_GPL(mlx4_qp_query);
 
+int mlx4_qp_to_ready(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
+                     struct mlx4_qp_context *context,
+                     struct mlx4_qp *qp, enum mlx4_qp_state *qp_state)
+{
+        int err;
+        int i;
+        enum mlx4_qp_state states[] = {
+                MLX4_QP_STATE_RST,
+                MLX4_QP_STATE_INIT,
+                MLX4_QP_STATE_RTR,
+                MLX4_QP_STATE_RTS
+        };
+
+        for (i = 0; i < ARRAY_SIZE(states) - 1; i++) {
+                context->flags &= cpu_to_be32(~(0xf << 28));
+                context->flags |= cpu_to_be32(states[i + 1] << 28);
+                err = mlx4_qp_modify(dev, mtt, states[i], states[i + 1],
+                                     context, 0, 0, qp);
+                if (err) {
+                        mlx4_err(dev, "Failed to bring QP to state: "
+                                 "%d with error: %d\n",
+                                 states[i + 1], err);
+                        return err;
+                }
+
+                *qp_state = states[i + 1];
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_qp_to_ready);
diff --git a/drivers/s390/Makefile b/drivers/s390/Makefile
index 5a888704a8d0..4f4e7cf105d4 100644
--- a/drivers/s390/Makefile
+++ b/drivers/s390/Makefile
@@ -5,7 +5,7 @@
 CFLAGS_sysinfo.o += -Iinclude/math-emu -Iarch/s390/math-emu -w
 
 obj-y += s390mach.o sysinfo.o s390_rdev.o
-obj-y += cio/ block/ char/ crypto/ net/ scsi/
+obj-y += cio/ block/ char/ crypto/ net/ scsi/ kvm/
 
 drivers-y += drivers/s390/built-in.o
 
diff --git a/drivers/s390/kvm/Makefile b/drivers/s390/kvm/Makefile
new file mode 100644
index 000000000000..4a5ec39f9ca6
--- /dev/null
+++ b/drivers/s390/kvm/Makefile
@@ -0,0 +1,9 @@
+# Makefile for kvm guest drivers on s390
+#
+# Copyright IBM Corp. 2008
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License (version 2 only)
+# as published by the Free Software Foundation.
+
+obj-$(CONFIG_VIRTIO) += kvm_virtio.o
diff --git a/drivers/s390/kvm/kvm_virtio.c b/drivers/s390/kvm/kvm_virtio.c
new file mode 100644
index 000000000000..bbef3764fbf8
--- /dev/null
+++ b/drivers/s390/kvm/kvm_virtio.c
@@ -0,0 +1,338 @@
+/*
+ * kvm_virtio.c - virtio for kvm on s390
+ *
+ * Copyright IBM Corp. 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (version 2 only)
+ * as published by the Free Software Foundation.
+ *
+ *    Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
+ */
+
+#include <linux/init.h>
+#include <linux/bootmem.h>
+#include <linux/err.h>
+#include <linux/virtio.h>
+#include <linux/virtio_config.h>
+#include <linux/interrupt.h>
+#include <linux/virtio_ring.h>
+#include <asm/io.h>
+#include <asm/kvm_para.h>
+#include <asm/kvm_virtio.h>
+#include <asm/setup.h>
+#include <asm/s390_ext.h>
+
+#define VIRTIO_SUBCODE_64 0x0D00
+
+/*
+ * The pointer to our (page) of device descriptions.
+ */
+static void *kvm_devices;
+
+/*
+ * Unique numbering for kvm devices.
+ */
+static unsigned int dev_index;
+
+struct kvm_device {
+        struct virtio_device vdev;
+        struct kvm_device_desc *desc;
+};
+
+#define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev)
+
+/*
+ * memory layout:
+ * - kvm_device_descriptor
+ *        struct kvm_device_desc
+ * - configuration
+ *        struct kvm_vqconfig
+ * - feature bits
+ * - config space
+ */
+static struct kvm_vqconfig *kvm_vq_config(const struct kvm_device_desc *desc)
+{
+        return (struct kvm_vqconfig *)(desc + 1);
+}
+
+static u8 *kvm_vq_features(const struct kvm_device_desc *desc)
+{
+        return (u8 *)(kvm_vq_config(desc) + desc->num_vq);
+}
+
+static u8 *kvm_vq_configspace(const struct kvm_device_desc *desc)
+{
+        return kvm_vq_features(desc) + desc->feature_len * 2;
+}
+
+/*
+ * The total size of the config page used by this device (incl. desc)
+ */
+static unsigned desc_size(const struct kvm_device_desc *desc)
+{
+        return sizeof(*desc)
+                + desc->num_vq * sizeof(struct kvm_vqconfig)
+                + desc->feature_len * 2
+                + desc->config_len;
+}
+
+/*
+ * This tests (and acknowleges) a feature bit.
+ */
+static bool kvm_feature(struct virtio_device *vdev, unsigned fbit)
+{
+        struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
+        u8 *features;
+
+        if (fbit / 8 > desc->feature_len)
+                return false;
+
+        features = kvm_vq_features(desc);
+        if (!(features[fbit / 8] & (1 << (fbit % 8))))
+                return false;
+
+        /*
+         * We set the matching bit in the other half of the bitmap to tell the
+         * Host we want to use this feature.
+         */
+        features[desc->feature_len + fbit / 8] |= (1 << (fbit % 8));
+        return true;
+}
+
+/*
+ * Reading and writing elements in config space
+ */
+static void kvm_get(struct virtio_device *vdev, unsigned int offset,
+                   void *buf, unsigned len)
+{
+        struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
+
+        BUG_ON(offset + len > desc->config_len);
+        memcpy(buf, kvm_vq_configspace(desc) + offset, len);
+}
+
+static void kvm_set(struct virtio_device *vdev, unsigned int offset,
+                   const void *buf, unsigned len)
+{
+        struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
+
+        BUG_ON(offset + len > desc->config_len);
+        memcpy(kvm_vq_configspace(desc) + offset, buf, len);
+}
+
+/*
+ * The operations to get and set the status word just access
+ * the status field of the device descriptor. set_status will also
+ * make a hypercall to the host, to tell about status changes
+ */
+static u8 kvm_get_status(struct virtio_device *vdev)
+{
+        return to_kvmdev(vdev)->desc->status;
+}
+
+static void kvm_set_status(struct virtio_device *vdev, u8 status)
+{
+        BUG_ON(!status);
+        to_kvmdev(vdev)->desc->status = status;
+        kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS,
+                       (unsigned long) to_kvmdev(vdev)->desc);
+}
+
+/*
+ * To reset the device, we use the KVM_VIRTIO_RESET hypercall, using the
+ * descriptor address. The Host will zero the status and all the
+ * features.
+ */
+static void kvm_reset(struct virtio_device *vdev)
+{
+        kvm_hypercall1(KVM_S390_VIRTIO_RESET,
+                       (unsigned long) to_kvmdev(vdev)->desc);
+}
+
+/*
+ * When the virtio_ring code wants to notify the Host, it calls us here and we
+ * make a hypercall.  We hand the address  of the virtqueue so the Host
+ * knows which virtqueue we're talking about.
+ */
+static void kvm_notify(struct virtqueue *vq)
+{
+        struct kvm_vqconfig *config = vq->priv;
+
+        kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, config->address);
+}
+
+/*
+ * This routine finds the first virtqueue described in the configuration of
+ * this device and sets it up.
+ */
+static struct virtqueue *kvm_find_vq(struct virtio_device *vdev,
+                                    unsigned index,
+                                    void (*callback)(struct virtqueue *vq))
+{
+        struct kvm_device *kdev = to_kvmdev(vdev);
+        struct kvm_vqconfig *config;
+        struct virtqueue *vq;
+        int err;
+
+        if (index >= kdev->desc->num_vq)
+                return ERR_PTR(-ENOENT);
+
+        config = kvm_vq_config(kdev->desc)+index;
+
+        if (add_shared_memory(config->address,
+                                vring_size(config->num, PAGE_SIZE))) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        vq = vring_new_virtqueue(config->num, vdev, (void *) config->address,
+                                 kvm_notify, callback);
+        if (!vq) {
+                err = -ENOMEM;
+                goto unmap;
+        }
+
+        /*
+         * register a callback token
+         * The host will sent this via the external interrupt parameter
+         */
+        config->token = (u64) vq;
+
+        vq->priv = config;
+        return vq;
+unmap:
+        remove_shared_memory(config->address, vring_size(config->num,
+                             PAGE_SIZE));
+out:
+        return ERR_PTR(err);
+}
+
+static void kvm_del_vq(struct virtqueue *vq)
+{
+        struct kvm_vqconfig *config = vq->priv;
+
+        vring_del_virtqueue(vq);
+        remove_shared_memory(config->address,
+                             vring_size(config->num, PAGE_SIZE));
+}
+
+/*
+ * The config ops structure as defined by virtio config
+ */
+static struct virtio_config_ops kvm_vq_configspace_ops = {
+        .feature = kvm_feature,
+        .get = kvm_get,
+        .set = kvm_set,
+        .get_status = kvm_get_status,
+        .set_status = kvm_set_status,
+        .reset = kvm_reset,
+        .find_vq = kvm_find_vq,
+        .del_vq = kvm_del_vq,
+};
+
+/*
+ * The root device for the kvm virtio devices.
+ * This makes them appear as /sys/devices/kvm_s390/0,1,2 not /sys/devices/0,1,2.
+ */
+static struct device kvm_root = {
+        .parent = NULL,
+        .bus_id = "kvm_s390",
+};
+
+/*
+ * adds a new device and register it with virtio
+ * appropriate drivers are loaded by the device model
+ */
+static void add_kvm_device(struct kvm_device_desc *d)
+{
+        struct kvm_device *kdev;
+
+        kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
+        if (!kdev) {
+                printk(KERN_EMERG "Cannot allocate kvm dev %u\n",
+                       dev_index++);
+                return;
+        }
+
+        kdev->vdev.dev.parent = &kvm_root;
+        kdev->vdev.index = dev_index++;
+        kdev->vdev.id.device = d->type;
+        kdev->vdev.config = &kvm_vq_configspace_ops;
+        kdev->desc = d;
+
+        if (register_virtio_device(&kdev->vdev) != 0) {
+                printk(KERN_ERR "Failed to register kvm device %u\n",
+                       kdev->vdev.index);
+                kfree(kdev);
+        }
+}
+
+/*
+ * scan_devices() simply iterates through the device page.
+ * The type 0 is reserved to mean "end of devices".
+ */
+static void scan_devices(void)
+{
+        unsigned int i;
+        struct kvm_device_desc *d;
+
+        for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
+                d = kvm_devices + i;
+
+                if (d->type == 0)
+                        break;
+
+                add_kvm_device(d);
+        }
+}
+
+/*
+ * we emulate the request_irq behaviour on top of s390 extints
+ */
+static void kvm_extint_handler(u16 code)
+{
+        void *data = (void *) *(long *) __LC_PFAULT_INTPARM;
+        u16 subcode = S390_lowcore.cpu_addr;
+
+        if ((subcode & 0xff00) != VIRTIO_SUBCODE_64)
+                return;
+
+        vring_interrupt(0, data);
+}
+
+/*
+ * Init function for virtio
+ * devices are in a single page above top of "normal" mem
+ */
+static int __init kvm_devices_init(void)
+{
+        int rc;
+
+        if (!MACHINE_IS_KVM)
+                return -ENODEV;
+
+        rc = device_register(&kvm_root);
+        if (rc) {
+                printk(KERN_ERR "Could not register kvm_s390 root device");
+                return rc;
+        }
+
+        if (add_shared_memory((max_pfn) << PAGE_SHIFT, PAGE_SIZE)) {
+                device_unregister(&kvm_root);
+                return -ENOMEM;
+        }
+
+        kvm_devices  = (void *) (max_pfn << PAGE_SHIFT);
+
+        ctl_set_bit(0, 9);
+        register_external_interrupt(0x2603, kvm_extint_handler);
+
+        scan_devices();
+        return 0;
+}
+
+/*
+ * We do this after core stuff, but before the drivers.
+ */
+postcore_initcall(kvm_devices_init);
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 7c3f02816e95..9af2330f07a2 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -1927,7 +1927,8 @@ zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
 
         /* setup new FSF request */
         retval = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
-                                     0, NULL, &lock_flags, &fsf_req);
+                                     ZFCP_WAIT_FOR_SBAL, NULL, &lock_flags,
+                                     &fsf_req);
         if (retval) {
                 ZFCP_LOG_INFO("error: Could not create exchange configuration "
                               "data request for adapter %s.\n",
@@ -2035,21 +2036,21 @@ zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok)
                        min(FC_SERIAL_NUMBER_SIZE, 17));
         }
 
-        ZFCP_LOG_NORMAL("The adapter %s reported the following "
-                        "characteristics:\n"
-                        "WWNN 0x%016Lx, "
-                        "WWPN 0x%016Lx, "
-                        "S_ID 0x%06x,\n"
-                        "adapter version 0x%x, "
-                        "LIC version 0x%x, "
-                        "FC link speed %d Gb/s\n",
-                        zfcp_get_busid_by_adapter(adapter),
-                        (wwn_t) fc_host_node_name(shost),
-                        (wwn_t) fc_host_port_name(shost),
-                        fc_host_port_id(shost),
-                        adapter->hydra_version,
-                        adapter->fsf_lic_version,
-                        fc_host_speed(shost));
+        if (fsf_req->erp_action)
+                ZFCP_LOG_NORMAL("The adapter %s reported the following "
+                                "characteristics:\n"
+                                "WWNN 0x%016Lx, WWPN 0x%016Lx, "
+                                "S_ID 0x%06x,\n"
+                                "adapter version 0x%x, "
+                                "LIC version 0x%x, "
+                                "FC link speed %d Gb/s\n",
+                                zfcp_get_busid_by_adapter(adapter),
+                                (wwn_t) fc_host_node_name(shost),
+                                (wwn_t) fc_host_port_name(shost),
+                                fc_host_port_id(shost),
+                                adapter->hydra_version,
+                                adapter->fsf_lic_version,
+                                fc_host_speed(shost));
         if (ZFCP_QTCB_VERSION < bottom->low_qtcb_version) {
                 ZFCP_LOG_NORMAL("error: the adapter %s "
                                 "only supports newer control block "
@@ -2114,8 +2115,10 @@ zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
                         zfcp_erp_adapter_shutdown(adapter, 0, 127, fsf_req);
                         return -EIO;
                 case FC_PORTTYPE_NPORT:
-                        ZFCP_LOG_NORMAL("Switched fabric fibrechannel "
-                                        "network detected at adapter %s.\n",
+                        if (fsf_req->erp_action)
+                                ZFCP_LOG_NORMAL("Switched fabric fibrechannel "
+                                                "network detected at adapter "
+                                                "%s.\n",
                                         zfcp_get_busid_by_adapter(adapter));
                         break;
                 default:
diff --git a/drivers/s390/scsi/zfcp_fsf.h b/drivers/s390/scsi/zfcp_fsf.h
index 8cce5cc11d50..099970b27001 100644
--- a/drivers/s390/scsi/zfcp_fsf.h
+++ b/drivers/s390/scsi/zfcp_fsf.h
@@ -213,6 +213,7 @@
 #define FSF_FEATURE_HBAAPI_MANAGEMENT           0x00000010
 #define FSF_FEATURE_ELS_CT_CHAINED_SBALS        0x00000020
 #define FSF_FEATURE_UPDATE_ALERT                0x00000100
+#define FSF_FEATURE_MEASUREMENT_DATA            0x00000200
 
 /* host connection features */
 #define FSF_FEATURE_NPIV_MODE                   0x00000001
@@ -340,6 +341,15 @@ struct fsf_qtcb_prefix {
         u8  res1[20];
 } __attribute__ ((packed));
 
+struct fsf_statistics_info {
+        u64 input_req;
+        u64 output_req;
+        u64 control_req;
+        u64 input_mb;
+        u64 output_mb;
+        u64 seconds_act;
+} __attribute__ ((packed));
+
 union fsf_status_qual {
         u8  byte[FSF_STATUS_QUALIFIER_SIZE];
         u16 halfword[FSF_STATUS_QUALIFIER_SIZE / sizeof (u16)];
@@ -436,7 +446,8 @@ struct fsf_qtcb_bottom_config {
         u32 hardware_version;
         u8 serial_number[32];
         struct fsf_nport_serv_param plogi_payload;
-        u8 res4[160];
+        struct fsf_statistics_info stat_info;
+        u8 res4[112];
 } __attribute__ ((packed));
 
 struct fsf_qtcb_bottom_port {
@@ -469,7 +480,10 @@ struct fsf_qtcb_bottom_port {
         u64 control_requests;
         u64 input_mb;           /* where 1 MByte == 1.000.000 Bytes */
         u64 output_mb;          /* where 1 MByte == 1.000.000 Bytes */
-        u8 res2[256];
+        u8 cp_util;
+        u8 cb_util;
+        u8 a_util;
+        u8 res2[253];
 } __attribute__ ((packed));
 
 union fsf_qtcb_bottom {
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index f81850624eed..01687559dc06 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -40,6 +40,7 @@ static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *, int,
                                           unsigned int, unsigned int);
 
 static struct device_attribute *zfcp_sysfs_sdev_attrs[];
+static struct device_attribute *zfcp_a_stats_attrs[];
 
 struct zfcp_data zfcp_data = {
         .scsi_host_template = {
@@ -61,6 +62,7 @@ struct zfcp_data zfcp_data = {
                 .use_clustering         = 1,
                 .sdev_attrs             = zfcp_sysfs_sdev_attrs,
                 .max_sectors            = ZFCP_MAX_SECTORS,
+                .shost_attrs            = zfcp_a_stats_attrs,
         },
         .driver_version = ZFCP_VERSION,
 };
@@ -809,4 +811,116 @@ static struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
         NULL
 };
 
+static ssize_t zfcp_sysfs_adapter_util_show(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
+{
+        struct Scsi_Host *scsi_host = dev_to_shost(dev);
+        struct fsf_qtcb_bottom_port *qtcb_port;
+        int retval;
+        struct zfcp_adapter *adapter;
+
+        adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
+        if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
+                return -EOPNOTSUPP;
+
+        qtcb_port = kzalloc(sizeof(struct fsf_qtcb_bottom_port), GFP_KERNEL);
+        if (!qtcb_port)
+                return -ENOMEM;
+
+        retval = zfcp_fsf_exchange_port_data_sync(adapter, qtcb_port);
+        if (!retval)
+                retval = sprintf(buf, "%u %u %u\n", qtcb_port->cp_util,
+                                 qtcb_port->cb_util, qtcb_port->a_util);
+        kfree(qtcb_port);
+        return retval;
+}
+
+static int zfcp_sysfs_adapter_ex_config(struct device *dev,
+                                        struct fsf_statistics_info *stat_inf)
+{
+        int retval;
+        struct fsf_qtcb_bottom_config *qtcb_config;
+        struct Scsi_Host *scsi_host = dev_to_shost(dev);
+        struct zfcp_adapter *adapter;
+
+        adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
+        if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
+                return -EOPNOTSUPP;
+
+        qtcb_config = kzalloc(sizeof(struct fsf_qtcb_bottom_config),
+                               GFP_KERNEL);
+        if (!qtcb_config)
+                return -ENOMEM;
+
+        retval = zfcp_fsf_exchange_config_data_sync(adapter, qtcb_config);
+        if (!retval)
+                *stat_inf = qtcb_config->stat_info;
+
+        kfree(qtcb_config);
+        return retval;
+}
+
+static ssize_t zfcp_sysfs_adapter_request_show(struct device *dev,
+                                               struct device_attribute *attr,
+                                               char *buf)
+{
+        struct fsf_statistics_info stat_info;
+        int retval;
+
+        retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);
+        if (retval)
+                return retval;
+
+        return sprintf(buf, "%llu %llu %llu\n",
+                       (unsigned long long) stat_info.input_req,
+                       (unsigned long long) stat_info.output_req,
+                       (unsigned long long) stat_info.control_req);
+}
+
+static ssize_t zfcp_sysfs_adapter_mb_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
+{
+        struct fsf_statistics_info stat_info;
+        int retval;
+
+        retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);
+        if (retval)
+                return retval;
+
+        return sprintf(buf, "%llu %llu\n",
+                       (unsigned long long) stat_info.input_mb,
+                       (unsigned long long) stat_info.output_mb);
+}
+
+static ssize_t zfcp_sysfs_adapter_sec_active_show(struct device *dev,
+                                                  struct device_attribute *attr,
+                                                  char *buf)
+{
+        struct fsf_statistics_info stat_info;
+        int retval;
+
+        retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);
+        if (retval)
+                return retval;
+
+        return sprintf(buf, "%llu\n",
+                       (unsigned long long) stat_info.seconds_act);
+}
+
+static DEVICE_ATTR(utilization, S_IRUGO, zfcp_sysfs_adapter_util_show, NULL);
+static DEVICE_ATTR(requests, S_IRUGO, zfcp_sysfs_adapter_request_show, NULL);
+static DEVICE_ATTR(megabytes, S_IRUGO, zfcp_sysfs_adapter_mb_show, NULL);
+static DEVICE_ATTR(seconds_active, S_IRUGO,
+                   zfcp_sysfs_adapter_sec_active_show, NULL);
+
+static struct device_attribute *zfcp_a_stats_attrs[] = {
+        &dev_attr_utilization,
+        &dev_attr_requests,
+        &dev_attr_megabytes,
+        &dev_attr_seconds_active,
+        NULL
+};
+
 #undef ZFCP_LOG_AREA
diff --git a/drivers/scsi/FlashPoint.c b/drivers/scsi/FlashPoint.c
index b374e457e5e2..b898d382b7b0 100644
--- a/drivers/scsi/FlashPoint.c
+++ b/drivers/scsi/FlashPoint.c
@@ -1499,7 +1499,7 @@ static void FlashPoint_StartCCB(unsigned long pCurrCard, struct sccb *p_Sccb)
         thisCard = ((struct sccb_card *)pCurrCard)->cardIndex;
         ioport = ((struct sccb_card *)pCurrCard)->ioPort;
 
-        if ((p_Sccb->TargID > MAX_SCSI_TAR) || (p_Sccb->Lun > MAX_LUN)) {
+        if ((p_Sccb->TargID >= MAX_SCSI_TAR) || (p_Sccb->Lun >= MAX_LUN)) {
 
                 p_Sccb->HostStatus = SCCB_COMPLETE;
                 p_Sccb->SccbStatus = SCCB_ERROR;
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 7f78e3ea517d..99c57b0c1d54 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -1677,6 +1677,16 @@ config MAC_SCSI
           SCSI-HOWTO, available from
           <http://www.tldp.org/docs.html#howto>.
 
+config SCSI_MAC_ESP
+        tristate "Macintosh NCR53c9[46] SCSI"
+        depends on MAC && SCSI
+        help
+          This is the NCR 53c9x SCSI controller found on most of the 68040
+          based Macintoshes.
+
+          To compile this driver as a module, choose M here: the module
+          will be called mac_esp.
+
 config MVME147_SCSI
         bool "WD33C93 SCSI driver for MVME147"
         depends on MVME147 && SCSI=y
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 23e6ecbd4778..6c775e350c98 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_MVME147_SCSI)	+= mvme147.o	wd33c93.o
 obj-$(CONFIG_SGIWD93_SCSI)      += sgiwd93.o    wd33c93.o
 obj-$(CONFIG_ATARI_SCSI)        += atari_scsi.o
 obj-$(CONFIG_MAC_SCSI)          += mac_scsi.o
+obj-$(CONFIG_SCSI_MAC_ESP)      += esp_scsi.o   mac_esp.o
 obj-$(CONFIG_SUN3_SCSI)         += sun3_scsi.o  sun3_scsi_vme.o
 obj-$(CONFIG_MVME16x_SCSI)      += 53c700.o     mvme16x_scsi.o
 obj-$(CONFIG_BVME6000_SCSI)     += 53c700.o     bvme6000_scsi.o
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index 6ccdc96cc480..a09b2d3fdf5a 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -1432,15 +1432,10 @@ static void run(struct work_struct *work)
  */
 static irqreturn_t intr(int irqno, void *dev_id)
 {
-        struct Scsi_Host *shpnt = (struct Scsi_Host *)dev_id;
+        struct Scsi_Host *shpnt = dev_id;
         unsigned long flags;
         unsigned char rev, dmacntrl0;
 
-        if (!shpnt) {
-                printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
-                return IRQ_NONE;
-        }
-
         /*
          * Read a couple of registers that are known to not be all 1's. If
          * we read all 1's (-1), that means that either:
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index 5a1471c370fa..80594947c6f6 100644
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
@@ -153,8 +153,6 @@ struct aha1542_hostdata {
 
 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
 
-static struct Scsi_Host *aha_host[7];   /* One for each IRQ level (9-15) */
-
 static DEFINE_SPINLOCK(aha1542_lock);
 
 
@@ -163,8 +161,7 @@ static DEFINE_SPINLOCK(aha1542_lock);
 
 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
 static int aha1542_restart(struct Scsi_Host *shost);
-static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id);
-static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id);
+static void aha1542_intr_handle(struct Scsi_Host *shost);
 
 #define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
 
@@ -404,23 +401,19 @@ fail:
 }
 
 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
-static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id)
+static irqreturn_t do_aha1542_intr_handle(int dummy, void *dev_id)
 {
         unsigned long flags;
-        struct Scsi_Host *shost;
-
-        shost = aha_host[irq - 9];
-        if (!shost)
-                panic("Splunge!");
+        struct Scsi_Host *shost = dev_id;
 
         spin_lock_irqsave(shost->host_lock, flags);
-        aha1542_intr_handle(shost, dev_id);
+        aha1542_intr_handle(shost);
         spin_unlock_irqrestore(shost->host_lock, flags);
         return IRQ_HANDLED;
 }
 
 /* A "high" level interrupt handler */
-static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id)
+static void aha1542_intr_handle(struct Scsi_Host *shost)
 {
         void (*my_done) (Scsi_Cmnd *) = NULL;
         int errstatus, mbi, mbo, mbistatus;
@@ -1197,7 +1190,8 @@ fail:
 
                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
                         spin_lock_irqsave(&aha1542_lock, flags);
-                        if (request_irq(irq_level, do_aha1542_intr_handle, 0, "aha1542", NULL)) {
+                        if (request_irq(irq_level, do_aha1542_intr_handle, 0,
+                                        "aha1542", shpnt)) {
                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
                                 spin_unlock_irqrestore(&aha1542_lock, flags);
                                 goto unregister;
@@ -1205,7 +1199,7 @@ fail:
                         if (dma_chan != 0xFF) {
                                 if (request_dma(dma_chan, "aha1542")) {
                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
-                                        free_irq(irq_level, NULL);
+                                        free_irq(irq_level, shpnt);
                                         spin_unlock_irqrestore(&aha1542_lock, flags);
                                         goto unregister;
                                 }
@@ -1214,7 +1208,7 @@ fail:
                                         enable_dma(dma_chan);
                                 }
                         }
-                        aha_host[irq_level - 9] = shpnt;
+
                         shpnt->this_id = scsi_id;
                         shpnt->unique_id = base_io;
                         shpnt->io_port = base_io;
@@ -1276,7 +1270,7 @@ unregister:
 static int aha1542_release(struct Scsi_Host *shost)
 {
         if (shost->irq)
-                free_irq(shost->irq, NULL);
+                free_irq(shost->irq, shost);
         if (shost->dma_channel != 0xff)
                 free_dma(shost->dma_channel);
         if (shost->io_port && shost->n_io_port)
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index 2f00467b6b8c..be5558ab84ea 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -815,7 +815,7 @@ struct ahd_tmode_tstate {
 struct ahd_phase_table_entry {
         uint8_t phase;
         uint8_t mesg_out; /* Message response to parity errors */
-        char *phasemsg;
+        const char *phasemsg;
 };
 
 /************************** Serial EEPROM Format ******************************/
@@ -1314,7 +1314,7 @@ typedef int (ahd_device_setup_t)(struct ahd_softc *);
 struct ahd_pci_identity {
         uint64_t                 full_id;
         uint64_t                 id_mask;
-        char                    *name;
+        const char              *name;
         ahd_device_setup_t      *setup;
 };
 
@@ -1322,7 +1322,7 @@ struct ahd_pci_identity {
 struct aic7770_identity {
         uint32_t                 full_id;
         uint32_t                 id_mask;
-        char                    *name;
+        const char              *name;
         ahd_device_setup_t      *setup;
 };
 extern struct aic7770_identity aic7770_ident_table [];
@@ -1333,12 +1333,11 @@ extern const int ahd_num_aic7770_devs;
 
 /*************************** Function Declarations ****************************/
 /******************************************************************************/
-void                    ahd_reset_cmds_pending(struct ahd_softc *ahd);
 
 /***************************** PCI Front End *********************************/
-struct  ahd_pci_identity *ahd_find_pci_device(ahd_dev_softc_t);
+const struct    ahd_pci_identity *ahd_find_pci_device(ahd_dev_softc_t);
 int                       ahd_pci_config(struct ahd_softc *,
-                                         struct ahd_pci_identity *);
+                                         const struct ahd_pci_identity *);
 int     ahd_pci_test_register_access(struct ahd_softc *);
 #ifdef CONFIG_PM
 void    ahd_pci_suspend(struct ahd_softc *);
@@ -1376,16 +1375,6 @@ int			 ahd_write_flexport(struct ahd_softc *ahd,
 int                      ahd_read_flexport(struct ahd_softc *ahd, u_int addr,
                                            uint8_t *value);
 
-/*************************** Interrupt Services *******************************/
-void                    ahd_run_qoutfifo(struct ahd_softc *ahd);
-#ifdef AHD_TARGET_MODE
-void                    ahd_run_tqinfifo(struct ahd_softc *ahd, int paused);
-#endif
-void                    ahd_handle_hwerrint(struct ahd_softc *ahd);
-void                    ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat);
-void                    ahd_handle_scsiint(struct ahd_softc *ahd,
-                                           u_int intstat);
-
 /***************************** Error Recovery *********************************/
 typedef enum {
         SEARCH_COMPLETE,
@@ -1479,7 +1468,7 @@ extern uint32_t ahd_debug;
 void                    ahd_print_devinfo(struct ahd_softc *ahd,
                                           struct ahd_devinfo *devinfo);
 void                    ahd_dump_card_state(struct ahd_softc *ahd);
-int                     ahd_print_register(ahd_reg_parse_entry_t *table,
+int                     ahd_print_register(const ahd_reg_parse_entry_t *table,
                                            u_int num_entries,
                                            const char *name,
                                            u_int address,
diff --git a/drivers/scsi/aic7xxx/aic79xx.reg b/drivers/scsi/aic7xxx/aic79xx.reg
index be14e2ecb8f7..cca16fc5b4ad 100644
--- a/drivers/scsi/aic7xxx/aic79xx.reg
+++ b/drivers/scsi/aic7xxx/aic79xx.reg
@@ -198,6 +198,7 @@ register SEQINTCODE {
 register CLRINT {
         address                 0x003
         access_mode     WO
+        count           19
         field   CLRHWERRINT     0x80 /* Rev B or greater */
         field   CLRBRKADRINT    0x40
         field   CLRSWTMINT      0x20
@@ -245,6 +246,7 @@ register CLRERR {
 register HCNTRL {
         address                 0x005
         access_mode     RW
+        count           12
         field   SEQ_RESET       0x80 /* Rev B or greater */
         field   POWRDN          0x40
         field   SWINT           0x10
@@ -262,6 +264,7 @@ register HNSCB_QOFF {
         address                 0x006
         access_mode     RW
         size            2
+        count           2
 }
 
 /*
@@ -270,6 +273,7 @@ register HNSCB_QOFF {
 register HESCB_QOFF {
         address                 0x008
         access_mode     RW
+        count           2
 }
 
 /*
@@ -287,6 +291,7 @@ register HS_MAILBOX {
  */
 register SEQINTSTAT {
         address                 0x00C
+        count           1
         access_mode     RO
         field   SEQ_SWTMRTO     0x10
         field   SEQ_SEQINT      0x08
@@ -332,6 +337,7 @@ register SNSCB_QOFF {
  */
 register SESCB_QOFF {
         address                 0x012
+        count           2
         access_mode     RW
         modes           M_CCHAN
 }
@@ -397,6 +403,7 @@ register DFCNTRL {
         address                 0x019
         access_mode     RW
         modes           M_DFF0, M_DFF1
+        count           11
         field   PRELOADEN       0x80
         field   SCSIENWRDIS     0x40    /* Rev B only. */
         field   SCSIEN          0x20
@@ -415,6 +422,7 @@ register DFCNTRL {
  */
 register DSCOMMAND0 {
         address                 0x019
+        count           1
         access_mode     RW
         modes           M_CFG
         field   CACHETHEN       0x80    /* Cache Threshold enable */
@@ -580,6 +588,7 @@ register DFF_THRSH {
         address                 0x088
         access_mode     RW
         modes           M_CFG
+        count           1
         field   WR_DFTHRSH      0x70 {
                 WR_DFTHRSH_MIN,
                 WR_DFTHRSH_25,
@@ -800,6 +809,7 @@ register PCIXCTL {
         address                 0x093
         access_mode     RW
         modes           M_CFG
+        count           1
         field   SERRPULSE       0x80
         field   UNEXPSCIEN      0x20
         field   SPLTSMADIS      0x10
@@ -844,6 +854,7 @@ register DCHSPLTSTAT0 {
         address                 0x096
         access_mode     RW
         modes           M_DFF0, M_DFF1
+        count           2
         field   STAETERM        0x80
         field   SCBCERR         0x40
         field   SCADERR         0x20
@@ -895,6 +906,7 @@ register DCHSPLTSTAT1 {
         address                 0x097
         access_mode     RW
         modes           M_DFF0, M_DFF1
+        count           2
         field   RXDATABUCKET    0x01
 }
 
@@ -1048,6 +1060,7 @@ register SGSPLTSTAT0 {
         address                 0x09E
         access_mode     RW
         modes           M_DFF0, M_DFF1
+        count           2
         field   STAETERM        0x80
         field   SCBCERR         0x40
         field   SCADERR         0x20
@@ -1065,6 +1078,7 @@ register SGSPLTSTAT1 {
         address                 0x09F
         access_mode     RW
         modes           M_DFF0, M_DFF1
+        count           2
         field   RXDATABUCKET    0x01
 }
 
@@ -1086,6 +1100,7 @@ register DF0PCISTAT {
         address                 0x0A0
         access_mode     RW
         modes           M_CFG
+        count           1
         field   DPE             0x80
         field   SSE             0x40
         field   RMA             0x20
@@ -1184,6 +1199,7 @@ register TARGPCISTAT {
         address                 0x0A7
         access_mode     RW
         modes           M_CFG
+        count           5
         field   DPE             0x80
         field   SSE             0x40
         field   STA             0x08
@@ -1198,6 +1214,7 @@ register LQIN {
         address                 0x020
         access_mode     RW
         size            20
+        count           2
         modes           M_DFF0, M_DFF1, M_SCSI
 }
 
@@ -1229,6 +1246,7 @@ register LUNPTR {
         address                 0x022
         access_mode     RW
         modes           M_CFG
+        count           2
 }
 
 /*
@@ -1259,6 +1277,7 @@ register CMDLENPTR {
         address                 0x025
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1270,6 +1289,7 @@ register ATTRPTR {
         address                 0x026
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1281,6 +1301,7 @@ register FLAGPTR {
         address                 0x027
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1291,6 +1312,7 @@ register CMDPTR {
         address                 0x028
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1301,6 +1323,7 @@ register QNEXTPTR {
         address                 0x029
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1323,6 +1346,7 @@ register ABRTBYTEPTR {
         address                 0x02B
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1333,6 +1357,7 @@ register ABRTBITPTR {
         address                 0x02C
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1370,6 +1395,7 @@ register LUNLEN {
         address                 0x030
         access_mode     RW
         modes           M_CFG
+        count           2
         mask            ILUNLEN 0x0F
         mask            TLUNLEN 0xF0
 }
@@ -1383,6 +1409,7 @@ register CDBLIMIT {
         address                 0x031
         access_mode     RW
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -1394,6 +1421,7 @@ register MAXCMD {
         address                 0x032
         access_mode     RW
         modes           M_CFG
+        count           9
 }
 
 /*
@@ -1458,6 +1486,7 @@ register LQCTL1 {
         address                 0x038
         access_mode     RW
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           2
         field   PCI2PCI         0x04
         field   SINGLECMD       0x02
         field   ABORTPENDING    0x01
@@ -1470,6 +1499,7 @@ register LQCTL2 {
         address                 0x039
         access_mode     RW
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           5
         field   LQIRETRY        0x80
         field   LQICONTINUE     0x40
         field   LQITOIDLE       0x20
@@ -1528,6 +1558,7 @@ register SCSISEQ1 {
         address                 0x03B
         access_mode     RW
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           8
         field   MANUALCTL       0x40
         field   ENSELI          0x20
         field   ENRSELI         0x10
@@ -1667,6 +1698,9 @@ register SCSISIGO {
         }
 }
 
+/*
+ * SCSI Control Signal In
+ */
 register SCSISIGI {
         address                 0x041
         access_mode     RO
@@ -1703,6 +1737,7 @@ register MULTARGID {
         access_mode     RW
         modes           M_CFG
         size            2
+        count           2
 }
 
 /*
@@ -1758,6 +1793,7 @@ register TARGIDIN {
         address                 0x048
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           2
         field   CLKOUT          0x80
         field   TARGID          0x0F
 }
@@ -1798,6 +1834,7 @@ register OPTIONMODE {
         address                 0x04A
         access_mode     RW
         modes           M_CFG
+        count           4
         field   BIOSCANCTL              0x80
         field   AUTOACKEN               0x40
         field   BIASCANCTL              0x20
@@ -1850,6 +1887,7 @@ register SIMODE0 {
         address                 0x04B
         access_mode     RW
         modes           M_CFG
+        count           8
         field   ENSELDO         0x40
         field   ENSELDI         0x20
         field   ENSELINGO       0x10
@@ -1945,6 +1983,7 @@ register PERRDIAG {
         address                 0x04E
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           3
         field   HIZERO          0x80
         field   HIPERR          0x40
         field   PREVPHASE       0x20
@@ -1962,6 +2001,7 @@ register LQISTATE {
         address                 0x04E
         access_mode     RO
         modes           M_CFG
+        count           6
 }
 
 /*
@@ -1971,6 +2011,7 @@ register SOFFCNT {
         address                 0x04F
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           1
 }
 
 /*
@@ -1980,6 +2021,7 @@ register LQOSTATE {
         address                 0x04F
         access_mode     RO
         modes           M_CFG
+        count           2
 }
 
 /*
@@ -1989,6 +2031,7 @@ register LQISTAT0 {
         address                 0x050
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           2
         field   LQIATNQAS       0x20
         field   LQICRCT1        0x10
         field   LQICRCT2        0x08
@@ -2004,6 +2047,7 @@ register CLRLQIINT0 {
         address                 0x050
         access_mode     WO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           1
         field   CLRLQIATNQAS    0x20
         field   CLRLQICRCT1     0x10
         field   CLRLQICRCT2     0x08
@@ -2019,6 +2063,7 @@ register LQIMODE0 {
         address                 0x050
         access_mode     RW
         modes           M_CFG
+        count           3
         field   ENLQIATNQASK    0x20
         field   ENLQICRCT1      0x10
         field   ENLQICRCT2      0x08
@@ -2034,6 +2079,7 @@ register LQISTAT1 {
         address                 0x051
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           3
         field   LQIPHASE_LQ     0x80
         field   LQIPHASE_NLQ    0x40
         field   LQIABORT        0x20
@@ -2051,6 +2097,7 @@ register CLRLQIINT1 {
         address                 0x051
         access_mode     WO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           4
         field   CLRLQIPHASE_LQ  0x80
         field   CLRLQIPHASE_NLQ 0x40
         field   CLRLIQABORT     0x20
@@ -2068,6 +2115,7 @@ register LQIMODE1 {
         address                 0x051
         access_mode     RW
         modes           M_CFG
+        count           4
         field   ENLQIPHASE_LQ   0x80    /* LQIPHASE1 */
         field   ENLQIPHASE_NLQ  0x40    /* LQIPHASE2 */
         field   ENLIQABORT      0x20
@@ -2102,6 +2150,7 @@ register SSTAT3 {
         address                 0x053
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           3
         field   NTRAMPERR       0x02
         field   OSRAMPERR       0x01
 }
@@ -2113,6 +2162,7 @@ register CLRSINT3 {
         address                 0x053
         access_mode     WO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           3
         field   CLRNTRAMPERR    0x02
         field   CLROSRAMPERR    0x01
 }
@@ -2124,6 +2174,7 @@ register SIMODE3 {
         address                 0x053
         access_mode     RW
         modes           M_CFG
+        count           4
         field   ENNTRAMPERR     0x02
         field   ENOSRAMPERR     0x01
 }
@@ -2135,6 +2186,7 @@ register LQOSTAT0 {
         address                 0x054
         access_mode     RO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           2
         field   LQOTARGSCBPERR  0x10
         field   LQOSTOPT2       0x08
         field   LQOATNLQ        0x04
@@ -2149,6 +2201,7 @@ register CLRLQOINT0 {
         address                 0x054
         access_mode     WO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           3
         field   CLRLQOTARGSCBPERR       0x10
         field   CLRLQOSTOPT2            0x08
         field   CLRLQOATNLQ             0x04
@@ -2163,6 +2216,7 @@ register LQOMODE0 {
         address                 0x054
         access_mode     RW
         modes           M_CFG
+        count           4
         field   ENLQOTARGSCBPERR        0x10
         field   ENLQOSTOPT2             0x08
         field   ENLQOATNLQ              0x04
@@ -2191,6 +2245,7 @@ register CLRLQOINT1 {
         address                 0x055
         access_mode     WO
         modes           M_DFF0, M_DFF1, M_SCSI
+        count           7
         field   CLRLQOINITSCBPERR       0x10
         field   CLRLQOSTOPI2            0x08
         field   CLRLQOBADQAS            0x04
@@ -2205,6 +2260,7 @@ register LQOMODE1 {
         address                 0x055
         access_mode     RW
         modes           M_CFG
+        count           4
         field   ENLQOINITSCBPERR        0x10
         field   ENLQOSTOPI2             0x08
         field   ENLQOBADQAS             0x04
@@ -2232,6 +2288,7 @@ register OS_SPACE_CNT {
         address                 0x056
         access_mode     RO
         modes           M_CFG
+        count           2
 }
 
 /*
@@ -2286,13 +2343,19 @@ register NEXTSCB {
         modes           M_SCSI
 }
 
-/* Rev B only. */
+/*
+ * LQO SCSI Control
+ * (Rev B only.)
+ */
 register LQOSCSCTL {
         address                 0x05A
         access_mode     RW
         size            1
         modes           M_CFG
+        count           1
         field           LQOH2A_VERSION  0x80
+        field           LQOBUSETDLY     0x40
+        field           LQONOHOLDLACK   0x02
         field           LQONOCHKOVER    0x01
 }
 
@@ -2459,6 +2522,7 @@ register NEGPERIOD {
         address                 0x061
         access_mode     RW
         modes           M_SCSI
+        count           1
 }
 
 /*
@@ -2478,6 +2542,7 @@ register NEGOFFSET {
         address                 0x062
         access_mode     RW
         modes           M_SCSI
+        count           1
 }
 
 /*
@@ -2487,6 +2552,7 @@ register NEGPPROPTS {
         address                 0x063
         access_mode     RW
         modes           M_SCSI
+        count           1
         field   PPROPT_PACE     0x08
         field   PPROPT_QAS      0x04
         field   PPROPT_DT       0x02
@@ -2516,12 +2582,19 @@ register ANNEXCOL {
         address                 0x065
         access_mode     RW
         modes           M_SCSI
+        count           7
 }
 
+/*
+ * SCSI Check
+ * (Rev. B only)
+ */
 register SCSCHKN {
         address                 0x066
         access_mode     RW
         modes           M_CFG
+        count           1
+        field   BIDICHKDIS      0x80
         field   STSELSKIDDIS    0x40
         field   CURRFIFODEF     0x20
         field   WIDERESEN       0x10
@@ -2561,6 +2634,7 @@ register ANNEXDAT {
         address                 0x066
         access_mode     RW
         modes           M_SCSI
+        count           3
 }
 
 /*
@@ -2596,6 +2670,7 @@ register TOWNID {
         address                 0x069
         access_mode     RW
         modes           M_SCSI
+        count           2
 }
 
 /*
@@ -2737,6 +2812,7 @@ register SCBAUTOPTR {
         address                 0x0AB
         access_mode     RW
         modes           M_CFG
+        count           1
         field   AUSCBPTR_EN     0x80
         field   SCBPTR_ADDR     0x38
         field   SCBPTR_OFF      0x07
@@ -2881,6 +2957,7 @@ register BRDDAT {
         address                 0x0B8
         access_mode     RW
         modes           M_SCSI
+        count           2
 }
 
 /*
@@ -2890,6 +2967,7 @@ register BRDCTL {
         address                 0x0B9
         access_mode     RW
         modes           M_SCSI
+        count           7
         field   FLXARBACK       0x80
         field   FLXARBREQ       0x40
         field   BRDADDR         0x38
@@ -2905,6 +2983,7 @@ register SEEADR {
         address                 0x0BA
         access_mode     RW
         modes           M_SCSI
+        count           4
 }
 
 /*
@@ -2915,6 +2994,7 @@ register SEEDAT {
         access_mode     RW
         size            2
         modes           M_SCSI
+        count           4
 }
 
 /*
@@ -2924,6 +3004,7 @@ register SEESTAT {
         address                 0x0BE
         access_mode     RO
         modes           M_SCSI
+        count           1
         field   INIT_DONE       0x80
         field   SEEOPCODE       0x70
         field   LDALTID_L       0x08
@@ -2939,6 +3020,7 @@ register SEECTL {
         address                 0x0BE
         access_mode     RW
         modes           M_SCSI
+        count           4
         field   SEEOPCODE       0x70 {
                 SEEOP_ERASE     0x70,
                 SEEOP_READ      0x60,
@@ -3000,6 +3082,7 @@ register DSPDATACTL {
         address                 0x0C1
         access_mode     RW
         modes           M_CFG
+        count           3
         field   BYPASSENAB      0x80
         field   DESQDIS         0x10
         field   RCVROFFSTDIS    0x04
@@ -3058,6 +3141,7 @@ register DSPSELECT {
         address                 0x0C4
         access_mode     RW
         modes           M_CFG
+        count           1
         field   AUTOINCEN       0x80
         field   DSPSEL          0x1F
 }
@@ -3071,6 +3155,7 @@ register WRTBIASCTL {
         address                 0x0C5
         access_mode     WO
         modes           M_CFG
+        count           3
         field   AUTOXBCDIS      0x80
         field   XMITMANVAL      0x3F
 }
@@ -3196,7 +3281,8 @@ register OVLYADDR {
  */
 register SEQCTL0 {
         address                 0x0D6
-        access_mode RW
+        access_mode     RW
+        count           11
         field   PERRORDIS       0x80
         field   PAUSEDIS        0x40
         field   FAILDIS         0x20
@@ -3226,7 +3312,8 @@ register SEQCTL1 {
  */
 register FLAGS {
         address                 0x0D8
-        access_mode RO
+        access_mode     RO
+        count           23
         field   ZERO            0x02
         field   CARRY           0x01
 }
@@ -3255,7 +3342,8 @@ register SEQINTCTL {
  */
 register SEQRAM {
         address                 0x0DA
-        access_mode RW
+        access_mode     RW
+        count           2
 }
 
 /*
@@ -3266,6 +3354,7 @@ register PRGMCNT {
         address                 0x0DE
         access_mode     RW
         size            2
+        count           5
 }
 
 /*
@@ -3273,7 +3362,7 @@ register PRGMCNT {
  */
 register ACCUM {
         address                 0x0E0
-        access_mode RW
+        access_mode     RW
         accumulator
 }
 
@@ -3401,6 +3490,7 @@ register INTVEC1_ADDR {
         access_mode     RW
         size            2
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -3412,6 +3502,7 @@ register CURADDR {
         access_mode     RW
         size            2
         modes           M_SCSI
+        count           2
 }
 
 /*
@@ -3423,6 +3514,7 @@ register INTVEC2_ADDR {
         access_mode     RW
         size            2
         modes           M_CFG
+        count           1
 }
 
 /*
@@ -3579,6 +3671,7 @@ scratch_ram {
         /* Parameters for DMA Logic */
         DMAPARAMS {
                 size            1
+                count           8
                 field   PRELOADEN       0x80
                 field   WIDEODD         0x40
                 field   SCSIEN          0x20
@@ -3648,9 +3741,11 @@ scratch_ram {
          */
         KERNEL_TQINPOS {
                 size            1
+                count           1
         }
-        TQINPOS {                
+        TQINPOS {
                 size            1
+                count           8
         }
         /*
          * Base address of our shared data with the kernel driver in host
@@ -3681,6 +3776,7 @@ scratch_ram {
         }
         ARG_2 {
                 size            1
+                count           1
                 alias   RETURN_2
         }
 
@@ -3698,6 +3794,7 @@ scratch_ram {
          */
         SCSISEQ_TEMPLATE {
                 size            1
+                count           7
                 field   MANUALCTL       0x40
                 field   ENSELI          0x20
                 field   ENRSELI         0x10
@@ -3711,6 +3808,7 @@ scratch_ram {
          */
         INITIATOR_TAG {
                 size            1
+                count           1
         }
 
         SEQ_FLAGS2 {
@@ -3777,6 +3875,7 @@ scratch_ram {
          */
         CMDSIZE_TABLE {
                 size            8
+                count           8
         }
         /*
          * When an SCB with the MK_MESSAGE flag is
@@ -3803,8 +3902,8 @@ scratch_ram {
 /************************* Hardware SCB Definition ****************************/
 scb {
         address                 0x180
-        size    64
-        modes   0, 1, 2, 3
+        size            64
+        modes           0, 1, 2, 3
         SCB_RESIDUAL_DATACNT {
                 size    4
                 alias   SCB_CDB_STORE
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index ade0fb8fbdb2..55508b0fcec4 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -52,7 +52,7 @@
 
 
 /***************************** Lookup Tables **********************************/
-static char *ahd_chip_names[] =
+static const char *const ahd_chip_names[] =
 {
         "NONE",
         "aic7901",
@@ -66,10 +66,10 @@ static const u_int num_chip_names = ARRAY_SIZE(ahd_chip_names);
  */
 struct ahd_hard_error_entry {
         uint8_t errno;
-        char *errmesg;
+        const char *errmesg;
 };
 
-static struct ahd_hard_error_entry ahd_hard_errors[] = {
+static const struct ahd_hard_error_entry ahd_hard_errors[] = {
         { DSCTMOUT,     "Discard Timer has timed out" },
         { ILLOPCODE,    "Illegal Opcode in sequencer program" },
         { SQPARERR,     "Sequencer Parity Error" },
@@ -79,7 +79,7 @@ static struct ahd_hard_error_entry ahd_hard_errors[] = {
 };
 static const u_int num_errors = ARRAY_SIZE(ahd_hard_errors);
 
-static struct ahd_phase_table_entry ahd_phase_table[] =
+static const struct ahd_phase_table_entry ahd_phase_table[] =
 {
         { P_DATAOUT,    MSG_NOOP,               "in Data-out phase"     },
         { P_DATAIN,     MSG_INITIATOR_DET_ERR,  "in Data-in phase"      },
@@ -213,7 +213,7 @@ static void		ahd_dumpseq(struct ahd_softc *ahd);
 #endif
 static void             ahd_loadseq(struct ahd_softc *ahd);
 static int              ahd_check_patch(struct ahd_softc *ahd,
-                                        struct patch **start_patch,
+                                        const struct patch **start_patch,
                                         u_int start_instr, u_int *skip_addr);
 static u_int            ahd_resolve_seqaddr(struct ahd_softc *ahd,
                                             u_int address);
@@ -254,7 +254,7 @@ static void		ahd_freeze_devq(struct ahd_softc *ahd,
                                         struct scb *scb);
 static void             ahd_handle_scb_status(struct ahd_softc *ahd,
                                               struct scb *scb);
-static struct ahd_phase_table_entry* ahd_lookup_phase_entry(int phase);
+static const struct ahd_phase_table_entry* ahd_lookup_phase_entry(int phase);
 static void             ahd_shutdown(void *arg);
 static void             ahd_update_coalescing_values(struct ahd_softc *ahd,
                                                      u_int timer,
@@ -266,8 +266,774 @@ static int		ahd_match_scb(struct ahd_softc *ahd, struct scb *scb,
                                       int target, char channel, int lun,
                                       u_int tag, role_t role);
 
-/******************************** Private Inlines *****************************/
+static void             ahd_reset_cmds_pending(struct ahd_softc *ahd);
+
+/*************************** Interrupt Services *******************************/
+static void             ahd_run_qoutfifo(struct ahd_softc *ahd);
+#ifdef AHD_TARGET_MODE
+static void             ahd_run_tqinfifo(struct ahd_softc *ahd, int paused);
+#endif
+static void             ahd_handle_hwerrint(struct ahd_softc *ahd);
+static void             ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat);
+static void             ahd_handle_scsiint(struct ahd_softc *ahd,
+                                           u_int intstat);
+
+/************************ Sequencer Execution Control *************************/
+void
+ahd_set_modes(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)
+{
+        if (ahd->src_mode == src && ahd->dst_mode == dst)
+                return;
+#ifdef AHD_DEBUG
+        if (ahd->src_mode == AHD_MODE_UNKNOWN
+         || ahd->dst_mode == AHD_MODE_UNKNOWN)
+                panic("Setting mode prior to saving it.\n");
+        if ((ahd_debug & AHD_SHOW_MODEPTR) != 0)
+                printf("%s: Setting mode 0x%x\n", ahd_name(ahd),
+                       ahd_build_mode_state(ahd, src, dst));
+#endif
+        ahd_outb(ahd, MODE_PTR, ahd_build_mode_state(ahd, src, dst));
+        ahd->src_mode = src;
+        ahd->dst_mode = dst;
+}
+
+static void
+ahd_update_modes(struct ahd_softc *ahd)
+{
+        ahd_mode_state mode_ptr;
+        ahd_mode src;
+        ahd_mode dst;
+
+        mode_ptr = ahd_inb(ahd, MODE_PTR);
+#ifdef AHD_DEBUG
+        if ((ahd_debug & AHD_SHOW_MODEPTR) != 0)
+                printf("Reading mode 0x%x\n", mode_ptr);
+#endif
+        ahd_extract_mode_state(ahd, mode_ptr, &src, &dst);
+        ahd_known_modes(ahd, src, dst);
+}
+
+static void
+ahd_assert_modes(struct ahd_softc *ahd, ahd_mode srcmode,
+                 ahd_mode dstmode, const char *file, int line)
+{
+#ifdef AHD_DEBUG
+        if ((srcmode & AHD_MK_MSK(ahd->src_mode)) == 0
+         || (dstmode & AHD_MK_MSK(ahd->dst_mode)) == 0) {
+                panic("%s:%s:%d: Mode assertion failed.\n",
+                       ahd_name(ahd), file, line);
+        }
+#endif
+}
+
+#define AHD_ASSERT_MODES(ahd, source, dest) \
+        ahd_assert_modes(ahd, source, dest, __FILE__, __LINE__);
+
+ahd_mode_state
+ahd_save_modes(struct ahd_softc *ahd)
+{
+        if (ahd->src_mode == AHD_MODE_UNKNOWN
+         || ahd->dst_mode == AHD_MODE_UNKNOWN)
+                ahd_update_modes(ahd);
+
+        return (ahd_build_mode_state(ahd, ahd->src_mode, ahd->dst_mode));
+}
+
+void
+ahd_restore_modes(struct ahd_softc *ahd, ahd_mode_state state)
+{
+        ahd_mode src;
+        ahd_mode dst;
+
+        ahd_extract_mode_state(ahd, state, &src, &dst);
+        ahd_set_modes(ahd, src, dst);
+}
+
+/*
+ * Determine whether the sequencer has halted code execution.
+ * Returns non-zero status if the sequencer is stopped.
+ */
+int
+ahd_is_paused(struct ahd_softc *ahd)
+{
+        return ((ahd_inb(ahd, HCNTRL) & PAUSE) != 0);
+}
+
+/*
+ * Request that the sequencer stop and wait, indefinitely, for it
+ * to stop.  The sequencer will only acknowledge that it is paused
+ * once it has reached an instruction boundary and PAUSEDIS is
+ * cleared in the SEQCTL register.  The sequencer may use PAUSEDIS
+ * for critical sections.
+ */
+void
+ahd_pause(struct ahd_softc *ahd)
+{
+        ahd_outb(ahd, HCNTRL, ahd->pause);
+
+        /*
+         * Since the sequencer can disable pausing in a critical section, we
+         * must loop until it actually stops.
+         */
+        while (ahd_is_paused(ahd) == 0)
+                ;
+}
+
+/*
+ * Allow the sequencer to continue program execution.
+ * We check here to ensure that no additional interrupt
+ * sources that would cause the sequencer to halt have been
+ * asserted.  If, for example, a SCSI bus reset is detected
+ * while we are fielding a different, pausing, interrupt type,
+ * we don't want to release the sequencer before going back
+ * into our interrupt handler and dealing with this new
+ * condition.
+ */
+void
+ahd_unpause(struct ahd_softc *ahd)
+{
+        /*
+         * Automatically restore our modes to those saved
+         * prior to the first change of the mode.
+         */
+        if (ahd->saved_src_mode != AHD_MODE_UNKNOWN
+         && ahd->saved_dst_mode != AHD_MODE_UNKNOWN) {
+                if ((ahd->flags & AHD_UPDATE_PEND_CMDS) != 0)
+                        ahd_reset_cmds_pending(ahd);
+                ahd_set_modes(ahd, ahd->saved_src_mode, ahd->saved_dst_mode);
+        }
+
+        if ((ahd_inb(ahd, INTSTAT) & ~CMDCMPLT) == 0)
+                ahd_outb(ahd, HCNTRL, ahd->unpause);
+
+        ahd_known_modes(ahd, AHD_MODE_UNKNOWN, AHD_MODE_UNKNOWN);
+}
+
+/*********************** Scatter Gather List Handling *************************/
+void *
+ahd_sg_setup(struct ahd_softc *ahd, struct scb *scb,
+             void *sgptr, dma_addr_t addr, bus_size_t len, int last)
+{
+        scb->sg_count++;
+        if (sizeof(dma_addr_t) > 4
+         && (ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
+                struct ahd_dma64_seg *sg;
+
+                sg = (struct ahd_dma64_seg *)sgptr;
+                sg->addr = ahd_htole64(addr);
+                sg->len = ahd_htole32(len | (last ? AHD_DMA_LAST_SEG : 0));
+                return (sg + 1);
+        } else {
+                struct ahd_dma_seg *sg;
 
+                sg = (struct ahd_dma_seg *)sgptr;
+                sg->addr = ahd_htole32(addr & 0xFFFFFFFF);
+                sg->len = ahd_htole32(len | ((addr >> 8) & 0x7F000000)
+                                    | (last ? AHD_DMA_LAST_SEG : 0));
+                return (sg + 1);
+        }
+}
+
+static void
+ahd_setup_scb_common(struct ahd_softc *ahd, struct scb *scb)
+{
+        /* XXX Handle target mode SCBs. */
+        scb->crc_retry_count = 0;
+        if ((scb->flags & SCB_PACKETIZED) != 0) {
+                /* XXX what about ACA??  It is type 4, but TAG_TYPE == 0x3. */
+                scb->hscb->task_attribute = scb->hscb->control & SCB_TAG_TYPE;
+        } else {
+                if (ahd_get_transfer_length(scb) & 0x01)
+                        scb->hscb->task_attribute = SCB_XFERLEN_ODD;
+                else
+                        scb->hscb->task_attribute = 0;
+        }
+
+        if (scb->hscb->cdb_len <= MAX_CDB_LEN_WITH_SENSE_ADDR
+         || (scb->hscb->cdb_len & SCB_CDB_LEN_PTR) != 0)
+                scb->hscb->shared_data.idata.cdb_plus_saddr.sense_addr =
+                    ahd_htole32(scb->sense_busaddr);
+}
+
+static void
+ahd_setup_data_scb(struct ahd_softc *ahd, struct scb *scb)
+{
+        /*
+         * Copy the first SG into the "current" data ponter area.
+         */
+        if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
+                struct ahd_dma64_seg *sg;
+
+                sg = (struct ahd_dma64_seg *)scb->sg_list;
+                scb->hscb->dataptr = sg->addr;
+                scb->hscb->datacnt = sg->len;
+        } else {
+                struct ahd_dma_seg *sg;
+                uint32_t *dataptr_words;
+
+                sg = (struct ahd_dma_seg *)scb->sg_list;
+                dataptr_words = (uint32_t*)&scb->hscb->dataptr;
+                dataptr_words[0] = sg->addr;
+                dataptr_words[1] = 0;
+                if ((ahd->flags & AHD_39BIT_ADDRESSING) != 0) {
+                        uint64_t high_addr;
+
+                        high_addr = ahd_le32toh(sg->len) & 0x7F000000;
+                        scb->hscb->dataptr |= ahd_htole64(high_addr << 8);
+                }
+                scb->hscb->datacnt = sg->len;
+        }
+        /*
+         * Note where to find the SG entries in bus space.
+         * We also set the full residual flag which the
+         * sequencer will clear as soon as a data transfer
+         * occurs.
+         */
+        scb->hscb->sgptr = ahd_htole32(scb->sg_list_busaddr|SG_FULL_RESID);
+}
+
+static void
+ahd_setup_noxfer_scb(struct ahd_softc *ahd, struct scb *scb)
+{
+        scb->hscb->sgptr = ahd_htole32(SG_LIST_NULL);
+        scb->hscb->dataptr = 0;
+        scb->hscb->datacnt = 0;
+}
+
+/************************** Memory mapping routines ***************************/
+static void *
+ahd_sg_bus_to_virt(struct ahd_softc *ahd, struct scb *scb, uint32_t sg_busaddr)
+{
+        dma_addr_t sg_offset;
+
+        /* sg_list_phys points to entry 1, not 0 */
+        sg_offset = sg_busaddr - (scb->sg_list_busaddr - ahd_sg_size(ahd));
+        return ((uint8_t *)scb->sg_list + sg_offset);
+}
+
+static uint32_t
+ahd_sg_virt_to_bus(struct ahd_softc *ahd, struct scb *scb, void *sg)
+{
+        dma_addr_t sg_offset;
+
+        /* sg_list_phys points to entry 1, not 0 */
+        sg_offset = ((uint8_t *)sg - (uint8_t *)scb->sg_list)
+                  - ahd_sg_size(ahd);
+
+        return (scb->sg_list_busaddr + sg_offset);
+}
+
+static void
+ahd_sync_scb(struct ahd_softc *ahd, struct scb *scb, int op)
+{
+        ahd_dmamap_sync(ahd, ahd->scb_data.hscb_dmat,
+                        scb->hscb_map->dmamap,
+                        /*offset*/(uint8_t*)scb->hscb - scb->hscb_map->vaddr,
+                        /*len*/sizeof(*scb->hscb), op);
+}
+
+void
+ahd_sync_sglist(struct ahd_softc *ahd, struct scb *scb, int op)
+{
+        if (scb->sg_count == 0)
+                return;
+
+        ahd_dmamap_sync(ahd, ahd->scb_data.sg_dmat,
+                        scb->sg_map->dmamap,
+                        /*offset*/scb->sg_list_busaddr - ahd_sg_size(ahd),
+                        /*len*/ahd_sg_size(ahd) * scb->sg_count, op);
+}
+
+static void
+ahd_sync_sense(struct ahd_softc *ahd, struct scb *scb, int op)
+{
+        ahd_dmamap_sync(ahd, ahd->scb_data.sense_dmat,
+                        scb->sense_map->dmamap,
+                        /*offset*/scb->sense_busaddr,
+                        /*len*/AHD_SENSE_BUFSIZE, op);
+}
+
+#ifdef AHD_TARGET_MODE
+static uint32_t
+ahd_targetcmd_offset(struct ahd_softc *ahd, u_int index)
+{
+        return (((uint8_t *)&ahd->targetcmds[index])
+               - (uint8_t *)ahd->qoutfifo);
+}
+#endif
+
+/*********************** Miscelaneous Support Functions ***********************/
+/*
+ * Return pointers to the transfer negotiation information
+ * for the specified our_id/remote_id pair.
+ */
+struct ahd_initiator_tinfo *
+ahd_fetch_transinfo(struct ahd_softc *ahd, char channel, u_int our_id,
+                    u_int remote_id, struct ahd_tmode_tstate **tstate)
+{
+        /*
+         * Transfer data structures are stored from the perspective
+         * of the target role.  Since the parameters for a connection
+         * in the initiator role to a given target are the same as
+         * when the roles are reversed, we pretend we are the target.
+         */
+        if (channel == 'B')
+                our_id += 8;
+        *tstate = ahd->enabled_targets[our_id];
+        return (&(*tstate)->transinfo[remote_id]);
+}
+
+uint16_t
+ahd_inw(struct ahd_softc *ahd, u_int port)
+{
+        /*
+         * Read high byte first as some registers increment
+         * or have other side effects when the low byte is
+         * read.
+         */
+        uint16_t r = ahd_inb(ahd, port+1) << 8;
+        return r | ahd_inb(ahd, port);
+}
+
+void
+ahd_outw(struct ahd_softc *ahd, u_int port, u_int value)
+{
+        /*
+         * Write low byte first to accomodate registers
+         * such as PRGMCNT where the order maters.
+         */
+        ahd_outb(ahd, port, value & 0xFF);
+        ahd_outb(ahd, port+1, (value >> 8) & 0xFF);
+}
+
+uint32_t
+ahd_inl(struct ahd_softc *ahd, u_int port)
+{
+        return ((ahd_inb(ahd, port))
+              | (ahd_inb(ahd, port+1) << 8)
+              | (ahd_inb(ahd, port+2) << 16)
+              | (ahd_inb(ahd, port+3) << 24));
+}
+
+void
+ahd_outl(struct ahd_softc *ahd, u_int port, uint32_t value)
+{
+        ahd_outb(ahd, port, (value) & 0xFF);
+        ahd_outb(ahd, port+1, ((value) >> 8) & 0xFF);
+        ahd_outb(ahd, port+2, ((value) >> 16) & 0xFF);
+        ahd_outb(ahd, port+3, ((value) >> 24) & 0xFF);
+}
+
+uint64_t
+ahd_inq(struct ahd_softc *ahd, u_int port)
+{
+        return ((ahd_inb(ahd, port))
+              | (ahd_inb(ahd, port+1) << 8)
+              | (ahd_inb(ahd, port+2) << 16)
+              | (ahd_inb(ahd, port+3) << 24)
+              | (((uint64_t)ahd_inb(ahd, port+4)) << 32)
+              | (((uint64_t)ahd_inb(ahd, port+5)) << 40)
+              | (((uint64_t)ahd_inb(ahd, port+6)) << 48)
+              | (((uint64_t)ahd_inb(ahd, port+7)) << 56));
+}
+
+void
+ahd_outq(struct ahd_softc *ahd, u_int port, uint64_t value)
+{
+        ahd_outb(ahd, port, value & 0xFF);
+        ahd_outb(ahd, port+1, (value >> 8) & 0xFF);
+        ahd_outb(ahd, port+2, (value >> 16) & 0xFF);
+        ahd_outb(ahd, port+3, (value >> 24) & 0xFF);
+        ahd_outb(ahd, port+4, (value >> 32) & 0xFF);
+        ahd_outb(ahd, port+5, (value >> 40) & 0xFF);
+        ahd_outb(ahd, port+6, (value >> 48) & 0xFF);
+        ahd_outb(ahd, port+7, (value >> 56) & 0xFF);
+}
+
+u_int
+ahd_get_scbptr(struct ahd_softc *ahd)
+{
+        AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
+                         ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
+        return (ahd_inb(ahd, SCBPTR) | (ahd_inb(ahd, SCBPTR + 1) << 8));
+}
+
+void
+ahd_set_scbptr(struct ahd_softc *ahd, u_int scbptr)
+{
+        AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
+                         ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
+        ahd_outb(ahd, SCBPTR, scbptr & 0xFF);
+        ahd_outb(ahd, SCBPTR+1, (scbptr >> 8) & 0xFF);
+}
+
+#if 0 /* unused */
+static u_int
+ahd_get_hnscb_qoff(struct ahd_softc *ahd)
+{
+        return (ahd_inw_atomic(ahd, HNSCB_QOFF));
+}
+#endif
+
+static void
+ahd_set_hnscb_qoff(struct ahd_softc *ahd, u_int value)
+{
+        ahd_outw_atomic(ahd, HNSCB_QOFF, value);
+}
+
+#if 0 /* unused */
+static u_int
+ahd_get_hescb_qoff(struct ahd_softc *ahd)
+{
+        return (ahd_inb(ahd, HESCB_QOFF));
+}
+#endif
+
+static void
+ahd_set_hescb_qoff(struct ahd_softc *ahd, u_int value)
+{
+        ahd_outb(ahd, HESCB_QOFF, value);
+}
+
+static u_int
+ahd_get_snscb_qoff(struct ahd_softc *ahd)
+{
+        u_int oldvalue;
+
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        oldvalue = ahd_inw(ahd, SNSCB_QOFF);
+        ahd_outw(ahd, SNSCB_QOFF, oldvalue);
+        return (oldvalue);
+}
+
+static void
+ahd_set_snscb_qoff(struct ahd_softc *ahd, u_int value)
+{
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        ahd_outw(ahd, SNSCB_QOFF, value);
+}
+
+#if 0 /* unused */
+static u_int
+ahd_get_sescb_qoff(struct ahd_softc *ahd)
+{
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        return (ahd_inb(ahd, SESCB_QOFF));
+}
+#endif
+
+static void
+ahd_set_sescb_qoff(struct ahd_softc *ahd, u_int value)
+{
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        ahd_outb(ahd, SESCB_QOFF, value);
+}
+
+#if 0 /* unused */
+static u_int
+ahd_get_sdscb_qoff(struct ahd_softc *ahd)
+{
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        return (ahd_inb(ahd, SDSCB_QOFF) | (ahd_inb(ahd, SDSCB_QOFF + 1) << 8));
+}
+#endif
+
+static void
+ahd_set_sdscb_qoff(struct ahd_softc *ahd, u_int value)
+{
+        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
+        ahd_outb(ahd, SDSCB_QOFF, value & 0xFF);
+        ahd_outb(ahd, SDSCB_QOFF+1, (value >> 8) & 0xFF);
+}
+
+u_int
+ahd_inb_scbram(struct ahd_softc *ahd, u_int offset)
+{
+        u_int value;
+
+        /*
+         * Workaround PCI-X Rev A. hardware bug.
+         * After a host read of SCB memory, the chip
+         * may become confused into thinking prefetch
+         * was required.  This starts the discard timer
+         * running and can cause an unexpected discard
+         * timer interrupt.  The work around is to read
+         * a normal register prior to the exhaustion of
+         * the discard timer.  The mode pointer register
+         * has no side effects and so serves well for
+         * this purpose.
+         *
+         * Razor #528
+         */
+        value = ahd_inb(ahd, offset);
+        if ((ahd->bugs & AHD_PCIX_SCBRAM_RD_BUG) != 0)
+                ahd_inb(ahd, MODE_PTR);
+        return (value);
+}
+
+u_int
+ahd_inw_scbram(struct ahd_softc *ahd, u_int offset)
+{
+        return (ahd_inb_scbram(ahd, offset)
+              | (ahd_inb_scbram(ahd, offset+1) << 8));
+}
+
+static uint32_t
+ahd_inl_scbram(struct ahd_softc *ahd, u_int offset)
+{
+        return (ahd_inw_scbram(ahd, offset)
+              | (ahd_inw_scbram(ahd, offset+2) << 16));
+}
+
+static uint64_t
+ahd_inq_scbram(struct ahd_softc *ahd, u_int offset)
+{
+        return (ahd_inl_scbram(ahd, offset)
+              | ((uint64_t)ahd_inl_scbram(ahd, offset+4)) << 32);
+}
+
+struct scb *
+ahd_lookup_scb(struct ahd_softc *ahd, u_int tag)
+{
+        struct scb* scb;
+
+        if (tag >= AHD_SCB_MAX)
+                return (NULL);
+        scb = ahd->scb_data.scbindex[tag];
+        if (scb != NULL)
+                ahd_sync_scb(ahd, scb,
+                             BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+        return (scb);
+}
+
+static void
+ahd_swap_with_next_hscb(struct ahd_softc *ahd, struct scb *scb)
+{
+        struct   hardware_scb *q_hscb;
+        struct   map_node *q_hscb_map;
+        uint32_t saved_hscb_busaddr;
+
+        /*
+         * Our queuing method is a bit tricky.  The card
+         * knows in advance which HSCB (by address) to download,
+         * and we can't disappoint it.  To achieve this, the next
+         * HSCB to download is saved off in ahd->next_queued_hscb.
+         * When we are called to queue "an arbitrary scb",
+         * we copy the contents of the incoming HSCB to the one
+         * the sequencer knows about, swap HSCB pointers and
+         * finally assign the SCB to the tag indexed location
+         * in the scb_array.  This makes sure that we can still
+         * locate the correct SCB by SCB_TAG.
+         */
+        q_hscb = ahd->next_queued_hscb;
+        q_hscb_map = ahd->next_queued_hscb_map;
+        saved_hscb_busaddr = q_hscb->hscb_busaddr;
+        memcpy(q_hscb, scb->hscb, sizeof(*scb->hscb));
+        q_hscb->hscb_busaddr = saved_hscb_busaddr;
+        q_hscb->next_hscb_busaddr = scb->hscb->hscb_busaddr;
+
+        /* Now swap HSCB pointers. */
+        ahd->next_queued_hscb = scb->hscb;
+        ahd->next_queued_hscb_map = scb->hscb_map;
+        scb->hscb = q_hscb;
+        scb->hscb_map = q_hscb_map;
+
+        /* Now define the mapping from tag to SCB in the scbindex */
+        ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = scb;
+}
+
+/*
+ * Tell the sequencer about a new transaction to execute.
+ */
+void
+ahd_queue_scb(struct ahd_softc *ahd, struct scb *scb)
+{
+        ahd_swap_with_next_hscb(ahd, scb);
+
+        if (SCBID_IS_NULL(SCB_GET_TAG(scb)))
+                panic("Attempt to queue invalid SCB tag %x\n",
+                      SCB_GET_TAG(scb));
+
+        /*
+         * Keep a history of SCBs we've downloaded in the qinfifo.
+         */
+        ahd->qinfifo[AHD_QIN_WRAP(ahd->qinfifonext)] = SCB_GET_TAG(scb);
+        ahd->qinfifonext++;
+
+        if (scb->sg_count != 0)
+                ahd_setup_data_scb(ahd, scb);
+        else
+                ahd_setup_noxfer_scb(ahd, scb);
+        ahd_setup_scb_common(ahd, scb);
+
+        /*
+         * Make sure our data is consistent from the
+         * perspective of the adapter.
+         */
+        ahd_sync_scb(ahd, scb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+
+#ifdef AHD_DEBUG
+        if ((ahd_debug & AHD_SHOW_QUEUE) != 0) {
+                uint64_t host_dataptr;
+
+                host_dataptr = ahd_le64toh(scb->hscb->dataptr);
+                printf("%s: Queueing SCB %d:0x%x bus addr 0x%x - 0x%x%x/0x%x\n",
+                       ahd_name(ahd),
+                       SCB_GET_TAG(scb), scb->hscb->scsiid,
+                       ahd_le32toh(scb->hscb->hscb_busaddr),
+                       (u_int)((host_dataptr >> 32) & 0xFFFFFFFF),
+                       (u_int)(host_dataptr & 0xFFFFFFFF),
+                       ahd_le32toh(scb->hscb->datacnt));
+        }
+#endif
+        /* Tell the adapter about the newly queued SCB */
+        ahd_set_hnscb_qoff(ahd, ahd->qinfifonext);
+}
+
+/************************** Interrupt Processing ******************************/
+static void
+ahd_sync_qoutfifo(struct ahd_softc *ahd, int op)
+{
+        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
+                        /*offset*/0,
+                        /*len*/AHD_SCB_MAX * sizeof(struct ahd_completion), op);
+}
+
+static void
+ahd_sync_tqinfifo(struct ahd_softc *ahd, int op)
+{
+#ifdef AHD_TARGET_MODE
+        if ((ahd->flags & AHD_TARGETROLE) != 0) {
+                ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
+                                ahd->shared_data_map.dmamap,
+                                ahd_targetcmd_offset(ahd, 0),
+                                sizeof(struct target_cmd) * AHD_TMODE_CMDS,
+                                op);
+        }
+#endif
+}
+
+/*
+ * See if the firmware has posted any completed commands
+ * into our in-core command complete fifos.
+ */
+#define AHD_RUN_QOUTFIFO 0x1
+#define AHD_RUN_TQINFIFO 0x2
+static u_int
+ahd_check_cmdcmpltqueues(struct ahd_softc *ahd)
+{
+        u_int retval;
+
+        retval = 0;
+        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
+                        /*offset*/ahd->qoutfifonext * sizeof(*ahd->qoutfifo),
+                        /*len*/sizeof(*ahd->qoutfifo), BUS_DMASYNC_POSTREAD);
+        if (ahd->qoutfifo[ahd->qoutfifonext].valid_tag
+          == ahd->qoutfifonext_valid_tag)
+                retval |= AHD_RUN_QOUTFIFO;
+#ifdef AHD_TARGET_MODE
+        if ((ahd->flags & AHD_TARGETROLE) != 0
+         && (ahd->flags & AHD_TQINFIFO_BLOCKED) == 0) {
+                ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
+                                ahd->shared_data_map.dmamap,
+                                ahd_targetcmd_offset(ahd, ahd->tqinfifofnext),
+                                /*len*/sizeof(struct target_cmd),
+                                BUS_DMASYNC_POSTREAD);
+                if (ahd->targetcmds[ahd->tqinfifonext].cmd_valid != 0)
+                        retval |= AHD_RUN_TQINFIFO;
+        }
+#endif
+        return (retval);
+}
+
+/*
+ * Catch an interrupt from the adapter
+ */
+int
+ahd_intr(struct ahd_softc *ahd)
+{
+        u_int   intstat;
+
+        if ((ahd->pause & INTEN) == 0) {
+                /*
+                 * Our interrupt is not enabled on the chip
+                 * and may be disabled for re-entrancy reasons,
+                 * so just return.  This is likely just a shared
+                 * interrupt.
+                 */
+                return (0);
+        }
+
+        /*
+         * Instead of directly reading the interrupt status register,
+         * infer the cause of the interrupt by checking our in-core
+         * completion queues.  This avoids a costly PCI bus read in
+         * most cases.
+         */
+        if ((ahd->flags & AHD_ALL_INTERRUPTS) == 0
+         && (ahd_check_cmdcmpltqueues(ahd) != 0))
+                intstat = CMDCMPLT;
+        else
+                intstat = ahd_inb(ahd, INTSTAT);
+
+        if ((intstat & INT_PEND) == 0)
+                return (0);
+
+        if (intstat & CMDCMPLT) {
+                ahd_outb(ahd, CLRINT, CLRCMDINT);
+
+                /*
+                 * Ensure that the chip sees that we've cleared
+                 * this interrupt before we walk the output fifo.
+                 * Otherwise, we may, due to posted bus writes,
+                 * clear the interrupt after we finish the scan,
+                 * and after the sequencer has added new entries
+                 * and asserted the interrupt again.
+                 */
+                if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
+                        if (ahd_is_paused(ahd)) {
+                                /*
+                                 * Potentially lost SEQINT.
+                                 * If SEQINTCODE is non-zero,
+                                 * simulate the SEQINT.
+                                 */
+                                if (ahd_inb(ahd, SEQINTCODE) != NO_SEQINT)
+                                        intstat |= SEQINT;
+                        }
+                } else {
+                        ahd_flush_device_writes(ahd);
+                }
+                ahd_run_qoutfifo(ahd);
+                ahd->cmdcmplt_counts[ahd->cmdcmplt_bucket]++;
+                ahd->cmdcmplt_total++;
+#ifdef AHD_TARGET_MODE
+                if ((ahd->flags & AHD_TARGETROLE) != 0)
+                        ahd_run_tqinfifo(ahd, /*paused*/FALSE);
+#endif
+        }
+
+        /*
+         * Handle statuses that may invalidate our cached
+         * copy of INTSTAT separately.
+         */
+        if (intstat == 0xFF && (ahd->features & AHD_REMOVABLE) != 0) {
+                /* Hot eject.  Do nothing */
+        } else if (intstat & HWERRINT) {
+                ahd_handle_hwerrint(ahd);
+        } else if ((intstat & (PCIINT|SPLTINT)) != 0) {
+                ahd->bus_intr(ahd);
+        } else {
+
+                if ((intstat & SEQINT) != 0)
+                        ahd_handle_seqint(ahd, intstat);
+
+                if ((intstat & SCSIINT) != 0)
+                        ahd_handle_scsiint(ahd, intstat);
+        }
+        return (1);
+}
+
+/******************************** Private Inlines *****************************/
 static __inline void
 ahd_assert_atn(struct ahd_softc *ahd)
 {
@@ -280,7 +1046,7 @@ ahd_assert_atn(struct ahd_softc *ahd)
  * are currently in a packetized transfer.  We could
  * just as easily be sending or receiving a message.
  */
-static __inline int
+static int
 ahd_currently_packetized(struct ahd_softc *ahd)
 {
         ahd_mode_state   saved_modes;
@@ -896,7 +1662,7 @@ clrchn:
  * a copy of the first byte (little endian) of the sgptr
  * hscb field.
  */
-void
+static void
 ahd_run_qoutfifo(struct ahd_softc *ahd)
 {
         struct ahd_completion *completion;
@@ -935,7 +1701,7 @@ ahd_run_qoutfifo(struct ahd_softc *ahd)
 }
 
 /************************* Interrupt Handling *********************************/
-void
+static void
 ahd_handle_hwerrint(struct ahd_softc *ahd)
 {
         /*
@@ -1009,7 +1775,7 @@ ahd_dump_sglist(struct scb *scb)
 }
 #endif  /*  AHD_DEBUG  */
 
-void
+static void
 ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 {
         u_int seqintcode;
@@ -1621,7 +2387,7 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
         ahd_unpause(ahd);
 }
 
-void
+static void
 ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
 {
         struct scb      *scb;
@@ -3571,11 +4337,11 @@ ahd_print_devinfo(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
                devinfo->target, devinfo->lun);
 }
 
-static struct ahd_phase_table_entry*
+static const struct ahd_phase_table_entry*
 ahd_lookup_phase_entry(int phase)
 {
-        struct ahd_phase_table_entry *entry;
-        struct ahd_phase_table_entry *last_entry;
+        const struct ahd_phase_table_entry *entry;
+        const struct ahd_phase_table_entry *last_entry;
 
         /*
          * num_phases doesn't include the default entry which
@@ -3941,7 +4707,7 @@ ahd_clear_msg_state(struct ahd_softc *ahd)
  */
 static void
 ahd_handle_message_phase(struct ahd_softc *ahd)
-{ 
+{
         struct  ahd_devinfo devinfo;
         u_int   bus_phase;
         int     end_session;
@@ -5983,8 +6749,7 @@ found:
  */
 void
 ahd_free_scb(struct ahd_softc *ahd, struct scb *scb)
-{       
-
+{
         /* Clean up for the next user */
         scb->flags = SCB_FLAG_NONE;
         scb->hscb->control = 0;
@@ -6272,6 +7037,24 @@ static const char *termstat_strings[] = {
         "Not Configured"
 };
 
+/***************************** Timer Facilities *******************************/
+#define ahd_timer_init init_timer
+#define ahd_timer_stop del_timer_sync
+typedef void ahd_linux_callback_t (u_long);
+
+static void
+ahd_timer_reset(ahd_timer_t *timer, int usec, ahd_callback_t *func, void *arg)
+{
+        struct ahd_softc *ahd;
+
+        ahd = (struct ahd_softc *)arg;
+        del_timer(timer);
+        timer->data = (u_long)arg;
+        timer->expires = jiffies + (usec * HZ)/1000000;
+        timer->function = (ahd_linux_callback_t*)func;
+        add_timer(timer);
+}
+
 /*
  * Start the board, ready for normal operation
  */
@@ -7370,7 +8153,7 @@ ahd_qinfifo_count(struct ahd_softc *ahd)
                       + ARRAY_SIZE(ahd->qinfifo) - wrap_qinpos);
 }
 
-void
+static void
 ahd_reset_cmds_pending(struct ahd_softc *ahd)
 {
         struct          scb *scb;
@@ -8571,7 +9354,7 @@ ahd_loadseq(struct ahd_softc *ahd)
         struct  cs cs_table[num_critical_sections];
         u_int   begin_set[num_critical_sections];
         u_int   end_set[num_critical_sections];
-        struct  patch *cur_patch;
+        const struct patch *cur_patch;
         u_int   cs_count;
         u_int   cur_cs;
         u_int   i;
@@ -8726,11 +9509,11 @@ ahd_loadseq(struct ahd_softc *ahd)
 }
 
 static int
-ahd_check_patch(struct ahd_softc *ahd, struct patch **start_patch,
+ahd_check_patch(struct ahd_softc *ahd, const struct patch **start_patch,
                 u_int start_instr, u_int *skip_addr)
 {
-        struct  patch *cur_patch;
-        struct  patch *last_patch;
+        const struct patch *cur_patch;
+        const struct patch *last_patch;
         u_int   num_patches;
 
         num_patches = ARRAY_SIZE(patches);
@@ -8764,7 +9547,7 @@ ahd_check_patch(struct ahd_softc *ahd, struct patch **start_patch,
 static u_int
 ahd_resolve_seqaddr(struct ahd_softc *ahd, u_int address)
 {
-        struct patch *cur_patch;
+        const struct patch *cur_patch;
         int address_offset;
         u_int skip_addr;
         u_int i;
@@ -8895,7 +9678,7 @@ sized:
 }
 
 int
-ahd_print_register(ahd_reg_parse_entry_t *table, u_int num_entries,
+ahd_print_register(const ahd_reg_parse_entry_t *table, u_int num_entries,
                    const char *name, u_int address, u_int value,
                    u_int *cur_column, u_int wrap_point)
 {
@@ -9886,7 +10669,7 @@ ahd_update_scsiid(struct ahd_softc *ahd, u_int targid_mask)
 #endif
 }
 
-void
+static void
 ahd_run_tqinfifo(struct ahd_softc *ahd, int paused)
 {
         struct target_cmd *cmd;
diff --git a/drivers/scsi/aic7xxx/aic79xx_inline.h b/drivers/scsi/aic7xxx/aic79xx_inline.h
index 45e55575a0fa..5f12cf9d99d0 100644
--- a/drivers/scsi/aic7xxx/aic79xx_inline.h
+++ b/drivers/scsi/aic7xxx/aic79xx_inline.h
@@ -63,18 +63,15 @@ static __inline ahd_mode_state ahd_build_mode_state(struct ahd_softc *ahd,
 static __inline void ahd_extract_mode_state(struct ahd_softc *ahd,
                                             ahd_mode_state state,
                                             ahd_mode *src, ahd_mode *dst);
-static __inline void ahd_set_modes(struct ahd_softc *ahd, ahd_mode src,
-                                   ahd_mode dst);
-static __inline void ahd_update_modes(struct ahd_softc *ahd);
-static __inline void ahd_assert_modes(struct ahd_softc *ahd, ahd_mode srcmode,
-                                      ahd_mode dstmode, const char *file,
-                                      int line);
-static __inline ahd_mode_state ahd_save_modes(struct ahd_softc *ahd);
-static __inline void ahd_restore_modes(struct ahd_softc *ahd,
-                                       ahd_mode_state state);
-static __inline int  ahd_is_paused(struct ahd_softc *ahd);
-static __inline void ahd_pause(struct ahd_softc *ahd);
-static __inline void ahd_unpause(struct ahd_softc *ahd);
+
+void ahd_set_modes(struct ahd_softc *ahd, ahd_mode src,
+                   ahd_mode dst);
+ahd_mode_state ahd_save_modes(struct ahd_softc *ahd);
+void ahd_restore_modes(struct ahd_softc *ahd,
+                       ahd_mode_state state);
+int  ahd_is_paused(struct ahd_softc *ahd);
+void ahd_pause(struct ahd_softc *ahd);
+void ahd_unpause(struct ahd_softc *ahd);
 
 static __inline void
 ahd_known_modes(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)
@@ -99,256 +96,16 @@ ahd_extract_mode_state(struct ahd_softc *ahd, ahd_mode_state state,
         *dst = (state & DST_MODE) >> DST_MODE_SHIFT;
 }
 
-static __inline void
-ahd_set_modes(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)
-{
-        if (ahd->src_mode == src && ahd->dst_mode == dst)
-                return;
-#ifdef AHD_DEBUG
-        if (ahd->src_mode == AHD_MODE_UNKNOWN
-         || ahd->dst_mode == AHD_MODE_UNKNOWN)
-                panic("Setting mode prior to saving it.\n");
-        if ((ahd_debug & AHD_SHOW_MODEPTR) != 0)
-                printf("%s: Setting mode 0x%x\n", ahd_name(ahd),
-                       ahd_build_mode_state(ahd, src, dst));
-#endif
-        ahd_outb(ahd, MODE_PTR, ahd_build_mode_state(ahd, src, dst));
-        ahd->src_mode = src;
-        ahd->dst_mode = dst;
-}
-
-static __inline void
-ahd_update_modes(struct ahd_softc *ahd)
-{
-        ahd_mode_state mode_ptr;
-        ahd_mode src;
-        ahd_mode dst;
-
-        mode_ptr = ahd_inb(ahd, MODE_PTR);
-#ifdef AHD_DEBUG
-        if ((ahd_debug & AHD_SHOW_MODEPTR) != 0)
-                printf("Reading mode 0x%x\n", mode_ptr);
-#endif
-        ahd_extract_mode_state(ahd, mode_ptr, &src, &dst);
-        ahd_known_modes(ahd, src, dst);
-}
-
-static __inline void
-ahd_assert_modes(struct ahd_softc *ahd, ahd_mode srcmode,
-                 ahd_mode dstmode, const char *file, int line)
-{
-#ifdef AHD_DEBUG
-        if ((srcmode & AHD_MK_MSK(ahd->src_mode)) == 0
-         || (dstmode & AHD_MK_MSK(ahd->dst_mode)) == 0) {
-                panic("%s:%s:%d: Mode assertion failed.\n",
-                       ahd_name(ahd), file, line);
-        }
-#endif
-}
-
-static __inline ahd_mode_state
-ahd_save_modes(struct ahd_softc *ahd)
-{
-        if (ahd->src_mode == AHD_MODE_UNKNOWN
-         || ahd->dst_mode == AHD_MODE_UNKNOWN)
-                ahd_update_modes(ahd);
-
-        return (ahd_build_mode_state(ahd, ahd->src_mode, ahd->dst_mode));
-}
-
-static __inline void
-ahd_restore_modes(struct ahd_softc *ahd, ahd_mode_state state)
-{
-        ahd_mode src;
-        ahd_mode dst;
-
-        ahd_extract_mode_state(ahd, state, &src, &dst);
-        ahd_set_modes(ahd, src, dst);
-}
-
-#define AHD_ASSERT_MODES(ahd, source, dest) \
-        ahd_assert_modes(ahd, source, dest, __FILE__, __LINE__);
-
-/*
- * Determine whether the sequencer has halted code execution.
- * Returns non-zero status if the sequencer is stopped.
- */
-static __inline int
-ahd_is_paused(struct ahd_softc *ahd)
-{
-        return ((ahd_inb(ahd, HCNTRL) & PAUSE) != 0);
-}
-
-/*
- * Request that the sequencer stop and wait, indefinitely, for it
- * to stop.  The sequencer will only acknowledge that it is paused
- * once it has reached an instruction boundary and PAUSEDIS is
- * cleared in the SEQCTL register.  The sequencer may use PAUSEDIS
- * for critical sections.
- */
-static __inline void
-ahd_pause(struct ahd_softc *ahd)
-{
-        ahd_outb(ahd, HCNTRL, ahd->pause);
-
-        /*
-         * Since the sequencer can disable pausing in a critical section, we
-         * must loop until it actually stops.
-         */
-        while (ahd_is_paused(ahd) == 0)
-                ;
-}
-
-/*
- * Allow the sequencer to continue program execution.
- * We check here to ensure that no additional interrupt
- * sources that would cause the sequencer to halt have been
- * asserted.  If, for example, a SCSI bus reset is detected
- * while we are fielding a different, pausing, interrupt type,
- * we don't want to release the sequencer before going back
- * into our interrupt handler and dealing with this new
- * condition.
- */
-static __inline void
-ahd_unpause(struct ahd_softc *ahd)
-{
-        /*
-         * Automatically restore our modes to those saved
-         * prior to the first change of the mode.
-         */
-        if (ahd->saved_src_mode != AHD_MODE_UNKNOWN
-         && ahd->saved_dst_mode != AHD_MODE_UNKNOWN) {
-                if ((ahd->flags & AHD_UPDATE_PEND_CMDS) != 0)
-                        ahd_reset_cmds_pending(ahd);
-                ahd_set_modes(ahd, ahd->saved_src_mode, ahd->saved_dst_mode);
-        }
-
-        if ((ahd_inb(ahd, INTSTAT) & ~CMDCMPLT) == 0)
-                ahd_outb(ahd, HCNTRL, ahd->unpause);
-
-        ahd_known_modes(ahd, AHD_MODE_UNKNOWN, AHD_MODE_UNKNOWN);
-}
-
 /*********************** Scatter Gather List Handling *************************/
-static __inline void    *ahd_sg_setup(struct ahd_softc *ahd, struct scb *scb,
-                                      void *sgptr, dma_addr_t addr,
-                                      bus_size_t len, int last);
-static __inline void     ahd_setup_scb_common(struct ahd_softc *ahd,
-                                              struct scb *scb);
-static __inline void     ahd_setup_data_scb(struct ahd_softc *ahd,
-                                            struct scb *scb);
-static __inline void     ahd_setup_noxfer_scb(struct ahd_softc *ahd,
-                                              struct scb *scb);
-
-static __inline void *
-ahd_sg_setup(struct ahd_softc *ahd, struct scb *scb,
-             void *sgptr, dma_addr_t addr, bus_size_t len, int last)
-{
-        scb->sg_count++;
-        if (sizeof(dma_addr_t) > 4
-         && (ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
-                struct ahd_dma64_seg *sg;
-
-                sg = (struct ahd_dma64_seg *)sgptr;
-                sg->addr = ahd_htole64(addr);
-                sg->len = ahd_htole32(len | (last ? AHD_DMA_LAST_SEG : 0));
-                return (sg + 1);
-        } else {
-                struct ahd_dma_seg *sg;
-
-                sg = (struct ahd_dma_seg *)sgptr;
-                sg->addr = ahd_htole32(addr & 0xFFFFFFFF);
-                sg->len = ahd_htole32(len | ((addr >> 8) & 0x7F000000)
-                                    | (last ? AHD_DMA_LAST_SEG : 0));
-                return (sg + 1);
-        }
-}
-
-static __inline void
-ahd_setup_scb_common(struct ahd_softc *ahd, struct scb *scb)
-{
-        /* XXX Handle target mode SCBs. */
-        scb->crc_retry_count = 0;
-        if ((scb->flags & SCB_PACKETIZED) != 0) {
-                /* XXX what about ACA??  It is type 4, but TAG_TYPE == 0x3. */
-                scb->hscb->task_attribute = scb->hscb->control & SCB_TAG_TYPE;
-        } else {
-                if (ahd_get_transfer_length(scb) & 0x01)
-                        scb->hscb->task_attribute = SCB_XFERLEN_ODD;
-                else
-                        scb->hscb->task_attribute = 0;
-        }
-
-        if (scb->hscb->cdb_len <= MAX_CDB_LEN_WITH_SENSE_ADDR
-         || (scb->hscb->cdb_len & SCB_CDB_LEN_PTR) != 0)
-                scb->hscb->shared_data.idata.cdb_plus_saddr.sense_addr =
-                    ahd_htole32(scb->sense_busaddr);
-}
-
-static __inline void
-ahd_setup_data_scb(struct ahd_softc *ahd, struct scb *scb)
-{
-        /*
-         * Copy the first SG into the "current" data ponter area.
-         */
-        if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
-                struct ahd_dma64_seg *sg;
-
-                sg = (struct ahd_dma64_seg *)scb->sg_list;
-                scb->hscb->dataptr = sg->addr;
-                scb->hscb->datacnt = sg->len;
-        } else {
-                struct ahd_dma_seg *sg;
-                uint32_t *dataptr_words;
-
-                sg = (struct ahd_dma_seg *)scb->sg_list;
-                dataptr_words = (uint32_t*)&scb->hscb->dataptr;
-                dataptr_words[0] = sg->addr;
-                dataptr_words[1] = 0;
-                if ((ahd->flags & AHD_39BIT_ADDRESSING) != 0) {
-                        uint64_t high_addr;
-
-                        high_addr = ahd_le32toh(sg->len) & 0x7F000000;
-                        scb->hscb->dataptr |= ahd_htole64(high_addr << 8);
-                }
-                scb->hscb->datacnt = sg->len;
-        }
-        /*
-         * Note where to find the SG entries in bus space.
-         * We also set the full residual flag which the 
-         * sequencer will clear as soon as a data transfer
-         * occurs.
-         */
-        scb->hscb->sgptr = ahd_htole32(scb->sg_list_busaddr|SG_FULL_RESID);
-}
-
-static __inline void
-ahd_setup_noxfer_scb(struct ahd_softc *ahd, struct scb *scb)
-{
-        scb->hscb->sgptr = ahd_htole32(SG_LIST_NULL);
-        scb->hscb->dataptr = 0;
-        scb->hscb->datacnt = 0;
-}
+void    *ahd_sg_setup(struct ahd_softc *ahd, struct scb *scb,
+                      void *sgptr, dma_addr_t addr,
+                      bus_size_t len, int last);
 
 /************************** Memory mapping routines ***************************/
 static __inline size_t  ahd_sg_size(struct ahd_softc *ahd);
-static __inline void *
-                        ahd_sg_bus_to_virt(struct ahd_softc *ahd,
-                                           struct scb *scb,
-                                           uint32_t sg_busaddr);
-static __inline uint32_t
-                        ahd_sg_virt_to_bus(struct ahd_softc *ahd,
-                                           struct scb *scb,
-                                           void *sg);
-static __inline void    ahd_sync_scb(struct ahd_softc *ahd,
-                                     struct scb *scb, int op);
-static __inline void    ahd_sync_sglist(struct ahd_softc *ahd,
-                                        struct scb *scb, int op);
-static __inline void    ahd_sync_sense(struct ahd_softc *ahd,
-                                       struct scb *scb, int op);
-static __inline uint32_t
-                        ahd_targetcmd_offset(struct ahd_softc *ahd,
-                                             u_int index);
+
+void    ahd_sync_sglist(struct ahd_softc *ahd,
+                        struct scb *scb, int op);
 
 static __inline size_t
 ahd_sg_size(struct ahd_softc *ahd)
@@ -358,104 +115,32 @@ ahd_sg_size(struct ahd_softc *ahd)
         return (sizeof(struct ahd_dma_seg));
 }
 
-static __inline void *
-ahd_sg_bus_to_virt(struct ahd_softc *ahd, struct scb *scb, uint32_t sg_busaddr)
-{
-        dma_addr_t sg_offset;
-
-        /* sg_list_phys points to entry 1, not 0 */
-        sg_offset = sg_busaddr - (scb->sg_list_busaddr - ahd_sg_size(ahd));
-        return ((uint8_t *)scb->sg_list + sg_offset);
-}
-
-static __inline uint32_t
-ahd_sg_virt_to_bus(struct ahd_softc *ahd, struct scb *scb, void *sg)
-{
-        dma_addr_t sg_offset;
-
-        /* sg_list_phys points to entry 1, not 0 */
-        sg_offset = ((uint8_t *)sg - (uint8_t *)scb->sg_list)
-                  - ahd_sg_size(ahd);
-
-        return (scb->sg_list_busaddr + sg_offset);
-}
-
-static __inline void
-ahd_sync_scb(struct ahd_softc *ahd, struct scb *scb, int op)
-{
-        ahd_dmamap_sync(ahd, ahd->scb_data.hscb_dmat,
-                        scb->hscb_map->dmamap,
-                        /*offset*/(uint8_t*)scb->hscb - scb->hscb_map->vaddr,
-                        /*len*/sizeof(*scb->hscb), op);
-}
-
-static __inline void
-ahd_sync_sglist(struct ahd_softc *ahd, struct scb *scb, int op)
-{
-        if (scb->sg_count == 0)
-                return;
-
-        ahd_dmamap_sync(ahd, ahd->scb_data.sg_dmat,
-                        scb->sg_map->dmamap,
-                        /*offset*/scb->sg_list_busaddr - ahd_sg_size(ahd),
-                        /*len*/ahd_sg_size(ahd) * scb->sg_count, op);
-}
-
-static __inline void
-ahd_sync_sense(struct ahd_softc *ahd, struct scb *scb, int op)
-{
-        ahd_dmamap_sync(ahd, ahd->scb_data.sense_dmat,
-                        scb->sense_map->dmamap,
-                        /*offset*/scb->sense_busaddr,
-                        /*len*/AHD_SENSE_BUFSIZE, op);
-}
-
-static __inline uint32_t
-ahd_targetcmd_offset(struct ahd_softc *ahd, u_int index)
-{
-        return (((uint8_t *)&ahd->targetcmds[index])
-               - (uint8_t *)ahd->qoutfifo);
-}
-
 /*********************** Miscellaneous Support Functions ***********************/
-static __inline struct ahd_initiator_tinfo *
-                        ahd_fetch_transinfo(struct ahd_softc *ahd,
-                                            char channel, u_int our_id,
-                                            u_int remote_id,
-                                            struct ahd_tmode_tstate **tstate);
-static __inline uint16_t
-                        ahd_inw(struct ahd_softc *ahd, u_int port);
-static __inline void    ahd_outw(struct ahd_softc *ahd, u_int port,
-                                 u_int value);
-static __inline uint32_t
-                        ahd_inl(struct ahd_softc *ahd, u_int port);
-static __inline void    ahd_outl(struct ahd_softc *ahd, u_int port,
-                                 uint32_t value);
-static __inline uint64_t
-                        ahd_inq(struct ahd_softc *ahd, u_int port);
-static __inline void    ahd_outq(struct ahd_softc *ahd, u_int port,
-                                 uint64_t value);
-static __inline u_int   ahd_get_scbptr(struct ahd_softc *ahd);
-static __inline void    ahd_set_scbptr(struct ahd_softc *ahd, u_int scbptr);
-static __inline u_int   ahd_get_hnscb_qoff(struct ahd_softc *ahd);
-static __inline void    ahd_set_hnscb_qoff(struct ahd_softc *ahd, u_int value);
-static __inline u_int   ahd_get_hescb_qoff(struct ahd_softc *ahd);
-static __inline void    ahd_set_hescb_qoff(struct ahd_softc *ahd, u_int value);
-static __inline u_int   ahd_get_snscb_qoff(struct ahd_softc *ahd);
-static __inline void    ahd_set_snscb_qoff(struct ahd_softc *ahd, u_int value);
-static __inline u_int   ahd_get_sescb_qoff(struct ahd_softc *ahd);
-static __inline void    ahd_set_sescb_qoff(struct ahd_softc *ahd, u_int value);
-static __inline u_int   ahd_get_sdscb_qoff(struct ahd_softc *ahd);
-static __inline void    ahd_set_sdscb_qoff(struct ahd_softc *ahd, u_int value);
-static __inline u_int   ahd_inb_scbram(struct ahd_softc *ahd, u_int offset);
-static __inline u_int   ahd_inw_scbram(struct ahd_softc *ahd, u_int offset);
-static __inline uint32_t
-                        ahd_inl_scbram(struct ahd_softc *ahd, u_int offset);
-static __inline uint64_t
-                        ahd_inq_scbram(struct ahd_softc *ahd, u_int offset);
-static __inline void    ahd_swap_with_next_hscb(struct ahd_softc *ahd,
-                                                struct scb *scb);
-static __inline void    ahd_queue_scb(struct ahd_softc *ahd, struct scb *scb);
+struct ahd_initiator_tinfo *
+        ahd_fetch_transinfo(struct ahd_softc *ahd,
+                            char channel, u_int our_id,
+                            u_int remote_id,
+                            struct ahd_tmode_tstate **tstate);
+uint16_t
+        ahd_inw(struct ahd_softc *ahd, u_int port);
+void    ahd_outw(struct ahd_softc *ahd, u_int port,
+                 u_int value);
+uint32_t
+        ahd_inl(struct ahd_softc *ahd, u_int port);
+void    ahd_outl(struct ahd_softc *ahd, u_int port,
+                 uint32_t value);
+uint64_t
+        ahd_inq(struct ahd_softc *ahd, u_int port);
+void    ahd_outq(struct ahd_softc *ahd, u_int port,
+                 uint64_t value);
+u_int   ahd_get_scbptr(struct ahd_softc *ahd);
+void    ahd_set_scbptr(struct ahd_softc *ahd, u_int scbptr);
+u_int   ahd_inb_scbram(struct ahd_softc *ahd, u_int offset);
+u_int   ahd_inw_scbram(struct ahd_softc *ahd, u_int offset);
+struct scb *
+        ahd_lookup_scb(struct ahd_softc *ahd, u_int tag);
+void    ahd_queue_scb(struct ahd_softc *ahd, struct scb *scb);
+
 static __inline uint8_t *
                         ahd_get_sense_buf(struct ahd_softc *ahd,
                                           struct scb *scb);
@@ -463,25 +148,7 @@ static __inline uint32_t
                         ahd_get_sense_bufaddr(struct ahd_softc *ahd,
                                               struct scb *scb);
 
-/*
- * Return pointers to the transfer negotiation information
- * for the specified our_id/remote_id pair.
- */
-static __inline struct ahd_initiator_tinfo *
-ahd_fetch_transinfo(struct ahd_softc *ahd, char channel, u_int our_id,
-                    u_int remote_id, struct ahd_tmode_tstate **tstate)
-{
-        /*
-         * Transfer data structures are stored from the perspective
-         * of the target role.  Since the parameters for a connection
-         * in the initiator role to a given target are the same as
-         * when the roles are reversed, we pretend we are the target.
-         */
-        if (channel == 'B')
-                our_id += 8;
-        *tstate = ahd->enabled_targets[our_id];
-        return (&(*tstate)->transinfo[remote_id]);
-}
+#if 0 /* unused */
 
 #define AHD_COPY_COL_IDX(dst, src)                              \
 do {                                                            \
@@ -489,304 +156,7 @@ do {								\
         dst->hscb->lun = src->hscb->lun;                        \
 } while (0)
 
-static __inline uint16_t
-ahd_inw(struct ahd_softc *ahd, u_int port)
-{
-        /*
-         * Read high byte first as some registers increment
-         * or have other side effects when the low byte is
-         * read.
-         */
-        uint16_t r = ahd_inb(ahd, port+1) << 8;
-        return r | ahd_inb(ahd, port);
-}
-
-static __inline void
-ahd_outw(struct ahd_softc *ahd, u_int port, u_int value)
-{
-        /*
-         * Write low byte first to accomodate registers
-         * such as PRGMCNT where the order maters.
-         */
-        ahd_outb(ahd, port, value & 0xFF);
-        ahd_outb(ahd, port+1, (value >> 8) & 0xFF);
-}
-
-static __inline uint32_t
-ahd_inl(struct ahd_softc *ahd, u_int port)
-{
-        return ((ahd_inb(ahd, port))
-              | (ahd_inb(ahd, port+1) << 8)
-              | (ahd_inb(ahd, port+2) << 16)
-              | (ahd_inb(ahd, port+3) << 24));
-}
-
-static __inline void
-ahd_outl(struct ahd_softc *ahd, u_int port, uint32_t value)
-{
-        ahd_outb(ahd, port, (value) & 0xFF);
-        ahd_outb(ahd, port+1, ((value) >> 8) & 0xFF);
-        ahd_outb(ahd, port+2, ((value) >> 16) & 0xFF);
-        ahd_outb(ahd, port+3, ((value) >> 24) & 0xFF);
-}
-
-static __inline uint64_t
-ahd_inq(struct ahd_softc *ahd, u_int port)
-{
-        return ((ahd_inb(ahd, port))
-              | (ahd_inb(ahd, port+1) << 8)
-              | (ahd_inb(ahd, port+2) << 16)
-              | (ahd_inb(ahd, port+3) << 24)
-              | (((uint64_t)ahd_inb(ahd, port+4)) << 32)
-              | (((uint64_t)ahd_inb(ahd, port+5)) << 40)
-              | (((uint64_t)ahd_inb(ahd, port+6)) << 48)
-              | (((uint64_t)ahd_inb(ahd, port+7)) << 56));
-}
-
-static __inline void
-ahd_outq(struct ahd_softc *ahd, u_int port, uint64_t value)
-{
-        ahd_outb(ahd, port, value & 0xFF);
-        ahd_outb(ahd, port+1, (value >> 8) & 0xFF);
-        ahd_outb(ahd, port+2, (value >> 16) & 0xFF);
-        ahd_outb(ahd, port+3, (value >> 24) & 0xFF);
-        ahd_outb(ahd, port+4, (value >> 32) & 0xFF);
-        ahd_outb(ahd, port+5, (value >> 40) & 0xFF);
-        ahd_outb(ahd, port+6, (value >> 48) & 0xFF);
-        ahd_outb(ahd, port+7, (value >> 56) & 0xFF);
-}
-
-static __inline u_int
-ahd_get_scbptr(struct ahd_softc *ahd)
-{
-        AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
-                         ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
-        return (ahd_inb(ahd, SCBPTR) | (ahd_inb(ahd, SCBPTR + 1) << 8));
-}
-
-static __inline void
-ahd_set_scbptr(struct ahd_softc *ahd, u_int scbptr)
-{
-        AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
-                         ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
-        ahd_outb(ahd, SCBPTR, scbptr & 0xFF);
-        ahd_outb(ahd, SCBPTR+1, (scbptr >> 8) & 0xFF);
-}
-
-static __inline u_int
-ahd_get_hnscb_qoff(struct ahd_softc *ahd)
-{
-        return (ahd_inw_atomic(ahd, HNSCB_QOFF));
-}
-
-static __inline void
-ahd_set_hnscb_qoff(struct ahd_softc *ahd, u_int value)
-{
-        ahd_outw_atomic(ahd, HNSCB_QOFF, value);
-}
-
-static __inline u_int
-ahd_get_hescb_qoff(struct ahd_softc *ahd)
-{
-        return (ahd_inb(ahd, HESCB_QOFF));
-}
-
-static __inline void
-ahd_set_hescb_qoff(struct ahd_softc *ahd, u_int value)
-{
-        ahd_outb(ahd, HESCB_QOFF, value);
-}
-
-static __inline u_int
-ahd_get_snscb_qoff(struct ahd_softc *ahd)
-{
-        u_int oldvalue;
-
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        oldvalue = ahd_inw(ahd, SNSCB_QOFF);
-        ahd_outw(ahd, SNSCB_QOFF, oldvalue);
-        return (oldvalue);
-}
-
-static __inline void
-ahd_set_snscb_qoff(struct ahd_softc *ahd, u_int value)
-{
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        ahd_outw(ahd, SNSCB_QOFF, value);
-}
-
-static __inline u_int
-ahd_get_sescb_qoff(struct ahd_softc *ahd)
-{
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        return (ahd_inb(ahd, SESCB_QOFF));
-}
-
-static __inline void
-ahd_set_sescb_qoff(struct ahd_softc *ahd, u_int value)
-{
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        ahd_outb(ahd, SESCB_QOFF, value);
-}
-
-static __inline u_int
-ahd_get_sdscb_qoff(struct ahd_softc *ahd)
-{
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        return (ahd_inb(ahd, SDSCB_QOFF) | (ahd_inb(ahd, SDSCB_QOFF + 1) << 8));
-}
-
-static __inline void
-ahd_set_sdscb_qoff(struct ahd_softc *ahd, u_int value)
-{
-        AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
-        ahd_outb(ahd, SDSCB_QOFF, value & 0xFF);
-        ahd_outb(ahd, SDSCB_QOFF+1, (value >> 8) & 0xFF);
-}
-
-static __inline u_int
-ahd_inb_scbram(struct ahd_softc *ahd, u_int offset)
-{
-        u_int value;
-
-        /*
-         * Workaround PCI-X Rev A. hardware bug.
-         * After a host read of SCB memory, the chip
-         * may become confused into thinking prefetch
-         * was required.  This starts the discard timer
-         * running and can cause an unexpected discard
-         * timer interrupt.  The work around is to read
-         * a normal register prior to the exhaustion of
-         * the discard timer.  The mode pointer register
-         * has no side effects and so serves well for
-         * this purpose.
-         *
-         * Razor #528
-         */
-        value = ahd_inb(ahd, offset);
-        if ((ahd->bugs & AHD_PCIX_SCBRAM_RD_BUG) != 0)
-                ahd_inb(ahd, MODE_PTR);
-        return (value);
-}
-
-static __inline u_int
-ahd_inw_scbram(struct ahd_softc *ahd, u_int offset)
-{
-        return (ahd_inb_scbram(ahd, offset)
-              | (ahd_inb_scbram(ahd, offset+1) << 8));
-}
-
-static __inline uint32_t
-ahd_inl_scbram(struct ahd_softc *ahd, u_int offset)
-{
-        return (ahd_inw_scbram(ahd, offset)
-              | (ahd_inw_scbram(ahd, offset+2) << 16));
-}
-
-static __inline uint64_t
-ahd_inq_scbram(struct ahd_softc *ahd, u_int offset)
-{
-        return (ahd_inl_scbram(ahd, offset)
-              | ((uint64_t)ahd_inl_scbram(ahd, offset+4)) << 32);
-}
-
-static __inline struct scb *
-ahd_lookup_scb(struct ahd_softc *ahd, u_int tag)
-{
-        struct scb* scb;
-
-        if (tag >= AHD_SCB_MAX)
-                return (NULL);
-        scb = ahd->scb_data.scbindex[tag];
-        if (scb != NULL)
-                ahd_sync_scb(ahd, scb,
-                             BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
-        return (scb);
-}
-
-static __inline void
-ahd_swap_with_next_hscb(struct ahd_softc *ahd, struct scb *scb)
-{
-        struct   hardware_scb *q_hscb;
-        struct   map_node *q_hscb_map;
-        uint32_t saved_hscb_busaddr;
-
-        /*
-         * Our queuing method is a bit tricky.  The card
-         * knows in advance which HSCB (by address) to download,
-         * and we can't disappoint it.  To achieve this, the next
-         * HSCB to download is saved off in ahd->next_queued_hscb.
-         * When we are called to queue "an arbitrary scb",
-         * we copy the contents of the incoming HSCB to the one
-         * the sequencer knows about, swap HSCB pointers and
-         * finally assign the SCB to the tag indexed location
-         * in the scb_array.  This makes sure that we can still
-         * locate the correct SCB by SCB_TAG.
-         */
-        q_hscb = ahd->next_queued_hscb;
-        q_hscb_map = ahd->next_queued_hscb_map;
-        saved_hscb_busaddr = q_hscb->hscb_busaddr;
-        memcpy(q_hscb, scb->hscb, sizeof(*scb->hscb));
-        q_hscb->hscb_busaddr = saved_hscb_busaddr;
-        q_hscb->next_hscb_busaddr = scb->hscb->hscb_busaddr;
-
-        /* Now swap HSCB pointers. */
-        ahd->next_queued_hscb = scb->hscb;
-        ahd->next_queued_hscb_map = scb->hscb_map;
-        scb->hscb = q_hscb;
-        scb->hscb_map = q_hscb_map;
-
-        /* Now define the mapping from tag to SCB in the scbindex */
-        ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = scb;
-}
-
-/*
- * Tell the sequencer about a new transaction to execute.
- */
-static __inline void
-ahd_queue_scb(struct ahd_softc *ahd, struct scb *scb)
-{
-        ahd_swap_with_next_hscb(ahd, scb);
-
-        if (SCBID_IS_NULL(SCB_GET_TAG(scb)))
-                panic("Attempt to queue invalid SCB tag %x\n",
-                      SCB_GET_TAG(scb));
-
-        /*
-         * Keep a history of SCBs we've downloaded in the qinfifo.
-         */
-        ahd->qinfifo[AHD_QIN_WRAP(ahd->qinfifonext)] = SCB_GET_TAG(scb);
-        ahd->qinfifonext++;
-
-        if (scb->sg_count != 0)
-                ahd_setup_data_scb(ahd, scb);
-        else
-                ahd_setup_noxfer_scb(ahd, scb);
-        ahd_setup_scb_common(ahd, scb);
-
-        /*
-         * Make sure our data is consistent from the
-         * perspective of the adapter.
-         */
-        ahd_sync_scb(ahd, scb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
-
-#ifdef AHD_DEBUG
-        if ((ahd_debug & AHD_SHOW_QUEUE) != 0) {
-                uint64_t host_dataptr;
-
-                host_dataptr = ahd_le64toh(scb->hscb->dataptr);
-                printf("%s: Queueing SCB %d:0x%x bus addr 0x%x - 0x%x%x/0x%x\n",
-                       ahd_name(ahd),
-                       SCB_GET_TAG(scb), scb->hscb->scsiid,
-                       ahd_le32toh(scb->hscb->hscb_busaddr),
-                       (u_int)((host_dataptr >> 32) & 0xFFFFFFFF),
-                       (u_int)(host_dataptr & 0xFFFFFFFF),
-                       ahd_le32toh(scb->hscb->datacnt));
-        }
 #endif
-        /* Tell the adapter about the newly queued SCB */
-        ahd_set_hnscb_qoff(ahd, ahd->qinfifonext);
-}
 
 static __inline uint8_t *
 ahd_get_sense_buf(struct ahd_softc *ahd, struct scb *scb)
@@ -801,151 +171,6 @@ ahd_get_sense_bufaddr(struct ahd_softc *ahd, struct scb *scb)
 }
 
 /************************** Interrupt Processing ******************************/
-static __inline void    ahd_sync_qoutfifo(struct ahd_softc *ahd, int op);
-static __inline void    ahd_sync_tqinfifo(struct ahd_softc *ahd, int op);
-static __inline u_int   ahd_check_cmdcmpltqueues(struct ahd_softc *ahd);
-static __inline int     ahd_intr(struct ahd_softc *ahd);
-
-static __inline void
-ahd_sync_qoutfifo(struct ahd_softc *ahd, int op)
-{
-        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
-                        /*offset*/0,
-                        /*len*/AHD_SCB_MAX * sizeof(struct ahd_completion), op);
-}
-
-static __inline void
-ahd_sync_tqinfifo(struct ahd_softc *ahd, int op)
-{
-#ifdef AHD_TARGET_MODE
-        if ((ahd->flags & AHD_TARGETROLE) != 0) {
-                ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
-                                ahd->shared_data_map.dmamap,
-                                ahd_targetcmd_offset(ahd, 0),
-                                sizeof(struct target_cmd) * AHD_TMODE_CMDS,
-                                op);
-        }
-#endif
-}
-
-/*
- * See if the firmware has posted any completed commands
- * into our in-core command complete fifos.
- */
-#define AHD_RUN_QOUTFIFO 0x1
-#define AHD_RUN_TQINFIFO 0x2
-static __inline u_int
-ahd_check_cmdcmpltqueues(struct ahd_softc *ahd)
-{
-        u_int retval;
-
-        retval = 0;
-        ahd_dmamap_sync(ahd, ahd->shared_data_dmat, ahd->shared_data_map.dmamap,
-                        /*offset*/ahd->qoutfifonext * sizeof(*ahd->qoutfifo),
-                        /*len*/sizeof(*ahd->qoutfifo), BUS_DMASYNC_POSTREAD);
-        if (ahd->qoutfifo[ahd->qoutfifonext].valid_tag
-          == ahd->qoutfifonext_valid_tag)
-                retval |= AHD_RUN_QOUTFIFO;
-#ifdef AHD_TARGET_MODE
-        if ((ahd->flags & AHD_TARGETROLE) != 0
-         && (ahd->flags & AHD_TQINFIFO_BLOCKED) == 0) {
-                ahd_dmamap_sync(ahd, ahd->shared_data_dmat,
-                                ahd->shared_data_map.dmamap,
-                                ahd_targetcmd_offset(ahd, ahd->tqinfifofnext),
-                                /*len*/sizeof(struct target_cmd),
-                                BUS_DMASYNC_POSTREAD);
-                if (ahd->targetcmds[ahd->tqinfifonext].cmd_valid != 0)
-                        retval |= AHD_RUN_TQINFIFO;
-        }
-#endif
-        return (retval);
-}
-
-/*
- * Catch an interrupt from the adapter
- */
-static __inline int
-ahd_intr(struct ahd_softc *ahd)
-{
-        u_int   intstat;
-
-        if ((ahd->pause & INTEN) == 0) {
-                /*
-                 * Our interrupt is not enabled on the chip
-                 * and may be disabled for re-entrancy reasons,
-                 * so just return.  This is likely just a shared
-                 * interrupt.
-                 */
-                return (0);
-        }
-
-        /*
-         * Instead of directly reading the interrupt status register,
-         * infer the cause of the interrupt by checking our in-core
-         * completion queues.  This avoids a costly PCI bus read in
-         * most cases.
-         */
-        if ((ahd->flags & AHD_ALL_INTERRUPTS) == 0
-         && (ahd_check_cmdcmpltqueues(ahd) != 0))
-                intstat = CMDCMPLT;
-        else
-                intstat = ahd_inb(ahd, INTSTAT);
-
-        if ((intstat & INT_PEND) == 0)
-                return (0);
-
-        if (intstat & CMDCMPLT) {
-                ahd_outb(ahd, CLRINT, CLRCMDINT);
-
-                /*
-                 * Ensure that the chip sees that we've cleared
-                 * this interrupt before we walk the output fifo.
-                 * Otherwise, we may, due to posted bus writes,
-                 * clear the interrupt after we finish the scan,
-                 * and after the sequencer has added new entries
-                 * and asserted the interrupt again.
-                 */
-                if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
-                        if (ahd_is_paused(ahd)) {
-                                /*
-                                 * Potentially lost SEQINT.
-                                 * If SEQINTCODE is non-zero,
-                                 * simulate the SEQINT.
-                                 */
-                                if (ahd_inb(ahd, SEQINTCODE) != NO_SEQINT)
-                                        intstat |= SEQINT;
-                        }
-                } else {
-                        ahd_flush_device_writes(ahd);
-                }
-                ahd_run_qoutfifo(ahd);
-                ahd->cmdcmplt_counts[ahd->cmdcmplt_bucket]++;
-                ahd->cmdcmplt_total++;
-#ifdef AHD_TARGET_MODE
-                if ((ahd->flags & AHD_TARGETROLE) != 0)
-                        ahd_run_tqinfifo(ahd, /*paused*/FALSE);
-#endif
-        }
-
-        /*
-         * Handle statuses that may invalidate our cached
-         * copy of INTSTAT separately.
-         */
-        if (intstat == 0xFF && (ahd->features & AHD_REMOVABLE) != 0) {
-                /* Hot eject.  Do nothing */
-        } else if (intstat & HWERRINT) {
-                ahd_handle_hwerrint(ahd);
-        } else if ((intstat & (PCIINT|SPLTINT)) != 0) {
-                ahd->bus_intr(ahd);
-        } else {
-
-                if ((intstat & SEQINT) != 0)
-                        ahd_handle_seqint(ahd, intstat);
-
-                if ((intstat & SCSIINT) != 0)
-                        ahd_handle_scsiint(ahd, intstat);
-        }
-        return (1);
-}
+int     ahd_intr(struct ahd_softc *ahd);
 
 #endif  /* _AIC79XX_INLINE_H_ */
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 0081aa357c8b..0f829b3b8ab7 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -193,7 +193,7 @@ struct ahd_linux_iocell_opts
 #define AIC79XX_PRECOMP_INDEX   0
 #define AIC79XX_SLEWRATE_INDEX  1
 #define AIC79XX_AMPLITUDE_INDEX 2
-static struct ahd_linux_iocell_opts aic79xx_iocell_info[] =
+static const struct ahd_linux_iocell_opts aic79xx_iocell_info[] =
 {
         AIC79XX_DEFAULT_IOOPTS,
         AIC79XX_DEFAULT_IOOPTS,
@@ -369,10 +369,167 @@ static void ahd_release_simq(struct ahd_softc *ahd);
 static int ahd_linux_unit;
 
 
+/************************** OS Utility Wrappers *******************************/
+void ahd_delay(long);
+void
+ahd_delay(long usec)
+{
+        /*
+         * udelay on Linux can have problems for
+         * multi-millisecond waits.  Wait at most
+         * 1024us per call.
+         */
+        while (usec > 0) {
+                udelay(usec % 1024);
+                usec -= 1024;
+        }
+}
+
+
+/***************************** Low Level I/O **********************************/
+uint8_t ahd_inb(struct ahd_softc * ahd, long port);
+void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val);
+void ahd_outw_atomic(struct ahd_softc * ahd,
+                                     long port, uint16_t val);
+void ahd_outsb(struct ahd_softc * ahd, long port,
+                               uint8_t *, int count);
+void ahd_insb(struct ahd_softc * ahd, long port,
+                               uint8_t *, int count);
+
+uint8_t
+ahd_inb(struct ahd_softc * ahd, long port)
+{
+        uint8_t x;
+
+        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
+                x = readb(ahd->bshs[0].maddr + port);
+        } else {
+                x = inb(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
+        }
+        mb();
+        return (x);
+}
+
+#if 0 /* unused */
+static uint16_t
+ahd_inw_atomic(struct ahd_softc * ahd, long port)
+{
+        uint8_t x;
+
+        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
+                x = readw(ahd->bshs[0].maddr + port);
+        } else {
+                x = inw(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
+        }
+        mb();
+        return (x);
+}
+#endif
+
+void
+ahd_outb(struct ahd_softc * ahd, long port, uint8_t val)
+{
+        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
+                writeb(val, ahd->bshs[0].maddr + port);
+        } else {
+                outb(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
+        }
+        mb();
+}
+
+void
+ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val)
+{
+        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
+                writew(val, ahd->bshs[0].maddr + port);
+        } else {
+                outw(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
+        }
+        mb();
+}
+
+void
+ahd_outsb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
+{
+        int i;
+
+        /*
+         * There is probably a more efficient way to do this on Linux
+         * but we don't use this for anything speed critical and this
+         * should work.
+         */
+        for (i = 0; i < count; i++)
+                ahd_outb(ahd, port, *array++);
+}
+
+void
+ahd_insb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
+{
+        int i;
+
+        /*
+         * There is probably a more efficient way to do this on Linux
+         * but we don't use this for anything speed critical and this
+         * should work.
+         */
+        for (i = 0; i < count; i++)
+                *array++ = ahd_inb(ahd, port);
+}
+
+/******************************* PCI Routines *********************************/
+uint32_t
+ahd_pci_read_config(ahd_dev_softc_t pci, int reg, int width)
+{
+        switch (width) {
+        case 1:
+        {
+                uint8_t retval;
+
+                pci_read_config_byte(pci, reg, &retval);
+                return (retval);
+        }
+        case 2:
+        {
+                uint16_t retval;
+                pci_read_config_word(pci, reg, &retval);
+                return (retval);
+        }
+        case 4:
+        {
+                uint32_t retval;
+                pci_read_config_dword(pci, reg, &retval);
+                return (retval);
+        }
+        default:
+                panic("ahd_pci_read_config: Read size too big");
+                /* NOTREACHED */
+                return (0);
+        }
+}
+
+void
+ahd_pci_write_config(ahd_dev_softc_t pci, int reg, uint32_t value, int width)
+{
+        switch (width) {
+        case 1:
+                pci_write_config_byte(pci, reg, value);
+                break;
+        case 2:
+                pci_write_config_word(pci, reg, value);
+                break;
+        case 4:
+                pci_write_config_dword(pci, reg, value);
+                break;
+        default:
+                panic("ahd_pci_write_config: Write size too big");
+                /* NOTREACHED */
+        }
+}
+
 /****************************** Inlines ***************************************/
-static __inline void ahd_linux_unmap_scb(struct ahd_softc*, struct scb*);
+static void ahd_linux_unmap_scb(struct ahd_softc*, struct scb*);
 
-static __inline void
+static void
 ahd_linux_unmap_scb(struct ahd_softc *ahd, struct scb *scb)
 {
         struct scsi_cmnd *cmd;
@@ -400,13 +557,11 @@ ahd_linux_info(struct Scsi_Host *host)
         bp = &buffer[0];
         ahd = *(struct ahd_softc **)host->hostdata;
         memset(bp, 0, sizeof(buffer));
-        strcpy(bp, "Adaptec AIC79XX PCI-X SCSI HBA DRIVER, Rev ");
-        strcat(bp, AIC79XX_DRIVER_VERSION);
-        strcat(bp, "\n");
-        strcat(bp, "        <");
+        strcpy(bp, "Adaptec AIC79XX PCI-X SCSI HBA DRIVER, Rev " AIC79XX_DRIVER_VERSION "\n"
+                        "        <");
         strcat(bp, ahd->description);
-        strcat(bp, ">\n");
-        strcat(bp, "        ");
+        strcat(bp, ">\n"
+                        "        ");
         ahd_controller_info(ahd, ahd_info);
         strcat(bp, ahd_info);
 
@@ -432,7 +587,7 @@ ahd_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))
         return rtn;
 }
 
-static inline struct scsi_target **
+static struct scsi_target **
 ahd_linux_target_in_softc(struct scsi_target *starget)
 {
         struct  ahd_softc *ahd =
@@ -991,7 +1146,7 @@ aic79xx_setup(char *s)
         char   *p;
         char   *end;
 
-        static struct {
+        static const struct {
                 const char *name;
                 uint32_t *flag;
         } options[] = {
@@ -1223,7 +1378,7 @@ ahd_platform_init(struct ahd_softc *ahd)
          * Lookup and commit any modified IO Cell options.
          */
         if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
-                struct ahd_linux_iocell_opts *iocell_opts;
+                const struct ahd_linux_iocell_opts *iocell_opts;
 
                 iocell_opts = &aic79xx_iocell_info[ahd->unit];
                 if (iocell_opts->precomp != AIC79XX_DEFAULT_PRECOMP)
@@ -2613,7 +2768,7 @@ static void ahd_linux_set_pcomp_en(struct scsi_target *starget, int pcomp)
                 uint8_t precomp;
 
                 if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
-                        struct ahd_linux_iocell_opts *iocell_opts;
+                        const struct ahd_linux_iocell_opts *iocell_opts;
 
                         iocell_opts = &aic79xx_iocell_info[ahd->unit];
                         precomp = iocell_opts->precomp;
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.h b/drivers/scsi/aic7xxx/aic79xx_osm.h
index 853998be1474..8d6612c19922 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.h
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.h
@@ -222,22 +222,6 @@ typedef struct timer_list ahd_timer_t;
 /***************************** Timer Facilities *******************************/
 #define ahd_timer_init init_timer
 #define ahd_timer_stop del_timer_sync
-typedef void ahd_linux_callback_t (u_long);  
-static __inline void ahd_timer_reset(ahd_timer_t *timer, int usec,
-                                     ahd_callback_t *func, void *arg);
-
-static __inline void
-ahd_timer_reset(ahd_timer_t *timer, int usec, ahd_callback_t *func, void *arg)
-{
-        struct ahd_softc *ahd;
-
-        ahd = (struct ahd_softc *)arg;
-        del_timer(timer);
-        timer->data = (u_long)arg;
-        timer->expires = jiffies + (usec * HZ)/1000000;
-        timer->function = (ahd_linux_callback_t*)func;
-        add_timer(timer);
-}
 
 /***************************** SMP support ************************************/
 #include <linux/spinlock.h>
@@ -376,7 +360,7 @@ struct ahd_platform_data {
 #define AHD_LINUX_NOIRQ ((uint32_t)~0)
         uint32_t                 irq;           /* IRQ for this adapter */
         uint32_t                 bios_address;
-        uint32_t                 mem_busaddr;   /* Mem Base Addr */
+        resource_size_t          mem_busaddr;   /* Mem Base Addr */
 };
 
 /************************** OS Utility Wrappers *******************************/
@@ -386,111 +370,18 @@ struct ahd_platform_data {
 #define malloc(size, type, flags) kmalloc(size, flags)
 #define free(ptr, type) kfree(ptr)
 
-static __inline void ahd_delay(long);
-static __inline void
-ahd_delay(long usec)
-{
-        /*
-         * udelay on Linux can have problems for
-         * multi-millisecond waits.  Wait at most
-         * 1024us per call.
-         */
-        while (usec > 0) {
-                udelay(usec % 1024);
-                usec -= 1024;
-        }
-}
-
+void ahd_delay(long);
 
 /***************************** Low Level I/O **********************************/
-static __inline uint8_t ahd_inb(struct ahd_softc * ahd, long port);
-static __inline uint16_t ahd_inw_atomic(struct ahd_softc * ahd, long port);
-static __inline void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val);
-static __inline void ahd_outw_atomic(struct ahd_softc * ahd,
+uint8_t ahd_inb(struct ahd_softc * ahd, long port);
+void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val);
+void ahd_outw_atomic(struct ahd_softc * ahd,
                                      long port, uint16_t val);
-static __inline void ahd_outsb(struct ahd_softc * ahd, long port,
+void ahd_outsb(struct ahd_softc * ahd, long port,
                                uint8_t *, int count);
-static __inline void ahd_insb(struct ahd_softc * ahd, long port,
+void ahd_insb(struct ahd_softc * ahd, long port,
                                uint8_t *, int count);
 
-static __inline uint8_t
-ahd_inb(struct ahd_softc * ahd, long port)
-{
-        uint8_t x;
-
-        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
-                x = readb(ahd->bshs[0].maddr + port);
-        } else {
-                x = inb(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
-        }
-        mb();
-        return (x);
-}
-
-static __inline uint16_t
-ahd_inw_atomic(struct ahd_softc * ahd, long port)
-{
-        uint8_t x;
-
-        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
-                x = readw(ahd->bshs[0].maddr + port);
-        } else {
-                x = inw(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF));
-        }
-        mb();
-        return (x);
-}
-
-static __inline void
-ahd_outb(struct ahd_softc * ahd, long port, uint8_t val)
-{
-        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
-                writeb(val, ahd->bshs[0].maddr + port);
-        } else {
-                outb(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
-        }
-        mb();
-}
-
-static __inline void
-ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val)
-{
-        if (ahd->tags[0] == BUS_SPACE_MEMIO) {
-                writew(val, ahd->bshs[0].maddr + port);
-        } else {
-                outw(val, ahd->bshs[(port) >> 8].ioport + (port & 0xFF));
-        }
-        mb();
-}
-
-static __inline void
-ahd_outsb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
-{
-        int i;
-
-        /*
-         * There is probably a more efficient way to do this on Linux
-         * but we don't use this for anything speed critical and this
-         * should work.
-         */
-        for (i = 0; i < count; i++)
-                ahd_outb(ahd, port, *array++);
-}
-
-static __inline void
-ahd_insb(struct ahd_softc * ahd, long port, uint8_t *array, int count)
-{
-        int i;
-
-        /*
-         * There is probably a more efficient way to do this on Linux
-         * but we don't use this for anything speed critical and this
-         * should work.
-         */
-        for (i = 0; i < count; i++)
-                *array++ = ahd_inb(ahd, port);
-}
-
 /**************************** Initialization **********************************/
 int             ahd_linux_register_host(struct ahd_softc *,
                                         struct scsi_host_template *);
@@ -593,62 +484,12 @@ void			 ahd_linux_pci_exit(void);
 int                      ahd_pci_map_registers(struct ahd_softc *ahd);
 int                      ahd_pci_map_int(struct ahd_softc *ahd);
 
-static __inline uint32_t ahd_pci_read_config(ahd_dev_softc_t pci,
+uint32_t                 ahd_pci_read_config(ahd_dev_softc_t pci,
                                              int reg, int width);
-
-static __inline uint32_t
-ahd_pci_read_config(ahd_dev_softc_t pci, int reg, int width)
-{
-        switch (width) {
-        case 1:
-        {
-                uint8_t retval;
-
-                pci_read_config_byte(pci, reg, &retval);
-                return (retval);
-        }
-        case 2:
-        {
-                uint16_t retval;
-                pci_read_config_word(pci, reg, &retval);
-                return (retval);
-        }
-        case 4:
-        {
-                uint32_t retval;
-                pci_read_config_dword(pci, reg, &retval);
-                return (retval);
-        }
-        default:
-                panic("ahd_pci_read_config: Read size too big");
-                /* NOTREACHED */
-                return (0);
-        }
-}
-
-static __inline void ahd_pci_write_config(ahd_dev_softc_t pci,
+void                     ahd_pci_write_config(ahd_dev_softc_t pci,
                                           int reg, uint32_t value,
                                           int width);
 
-static __inline void
-ahd_pci_write_config(ahd_dev_softc_t pci, int reg, uint32_t value, int width)
-{
-        switch (width) {
-        case 1:
-                pci_write_config_byte(pci, reg, value);
-                break;
-        case 2:
-                pci_write_config_word(pci, reg, value);
-                break;
-        case 4:
-                pci_write_config_dword(pci, reg, value);
-                break;
-        default:
-                panic("ahd_pci_write_config: Write size too big");
-                /* NOTREACHED */
-        }
-}
-
 static __inline int ahd_get_pci_function(ahd_dev_softc_t);
 static __inline int
 ahd_get_pci_function(ahd_dev_softc_t pci)
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
index dfaaae5e73ae..6593056867f6 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
@@ -49,7 +49,7 @@
         ID2C(x),         \
         ID2C(IDIROC(x))
 
-static struct pci_device_id ahd_linux_pci_id_table[] = {
+static const struct pci_device_id ahd_linux_pci_id_table[] = {
         /* aic7901 based controllers */
         ID(ID_AHA_29320A),
         ID(ID_AHA_29320ALP),
@@ -159,7 +159,7 @@ ahd_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         char             buf[80];
         struct           ahd_softc *ahd;
         ahd_dev_softc_t  pci;
-        struct           ahd_pci_identity *entry;
+        const struct ahd_pci_identity *entry;
         char            *name;
         int              error;
         struct device   *dev = &pdev->dev;
@@ -249,8 +249,8 @@ ahd_linux_pci_exit(void)
 }
 
 static int
-ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd, u_long *base,
-                                 u_long *base2)
+ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd, resource_size_t *base,
+                                 resource_size_t *base2)
 {
         *base = pci_resource_start(ahd->dev_softc, 0);
         /*
@@ -272,11 +272,11 @@ ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd, u_long *base,
 
 static int
 ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd,
-                                 u_long *bus_addr,
+                                 resource_size_t *bus_addr,
                                  uint8_t __iomem **maddr)
 {
-        u_long  start;
-        u_long  base_page;
+        resource_size_t start;
+        resource_size_t base_page;
         u_long  base_offset;
         int     error = 0;
 
@@ -310,7 +310,7 @@ int
 ahd_pci_map_registers(struct ahd_softc *ahd)
 {
         uint32_t command;
-        u_long   base;
+        resource_size_t base;
         uint8_t __iomem *maddr;
         int      error;
 
@@ -346,31 +346,32 @@ ahd_pci_map_registers(struct ahd_softc *ahd)
                 } else
                         command |= PCIM_CMD_MEMEN;
         } else if (bootverbose) {
-                printf("aic79xx: PCI%d:%d:%d MEM region 0x%lx "
+                printf("aic79xx: PCI%d:%d:%d MEM region 0x%llx "
                        "unavailable. Cannot memory map device.\n",
                        ahd_get_pci_bus(ahd->dev_softc),
                        ahd_get_pci_slot(ahd->dev_softc),
                        ahd_get_pci_function(ahd->dev_softc),
-                       base);
+                       (unsigned long long)base);
         }
 
         if (maddr == NULL) {
-                u_long   base2;
+                resource_size_t base2;
 
                 error = ahd_linux_pci_reserve_io_regions(ahd, &base, &base2);
                 if (error == 0) {
                         ahd->tags[0] = BUS_SPACE_PIO;
                         ahd->tags[1] = BUS_SPACE_PIO;
-                        ahd->bshs[0].ioport = base;
-                        ahd->bshs[1].ioport = base2;
+                        ahd->bshs[0].ioport = (u_long)base;
+                        ahd->bshs[1].ioport = (u_long)base2;
                         command |= PCIM_CMD_PORTEN;
                 } else {
-                        printf("aic79xx: PCI%d:%d:%d IO regions 0x%lx and 0x%lx"
-                               "unavailable. Cannot map device.\n",
+                        printf("aic79xx: PCI%d:%d:%d IO regions 0x%llx and "
+                               "0x%llx unavailable. Cannot map device.\n",
                                ahd_get_pci_bus(ahd->dev_softc),
                                ahd_get_pci_slot(ahd->dev_softc),
                                ahd_get_pci_function(ahd->dev_softc),
-                               base, base2);
+                               (unsigned long long)base,
+                               (unsigned long long)base2);
                 }
         }
         ahd_pci_write_config(ahd->dev_softc, PCIR_COMMAND, command, 4);
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index c9f79fdf9131..c25b6adffbf9 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -97,7 +97,7 @@ static ahd_device_setup_t ahd_aic7901A_setup;
 static ahd_device_setup_t ahd_aic7902_setup;
 static ahd_device_setup_t ahd_aic790X_setup;
 
-static struct ahd_pci_identity ahd_pci_ident_table [] =
+static const struct ahd_pci_identity ahd_pci_ident_table[] =
 {
         /* aic7901 based controllers */
         {
@@ -253,7 +253,7 @@ static void	ahd_configure_termination(struct ahd_softc *ahd,
 static void     ahd_pci_split_intr(struct ahd_softc *ahd, u_int intstat);
 static void     ahd_pci_intr(struct ahd_softc *ahd);
 
-struct ahd_pci_identity *
+const struct ahd_pci_identity *
 ahd_find_pci_device(ahd_dev_softc_t pci)
 {
         uint64_t  full_id;
@@ -261,7 +261,7 @@ ahd_find_pci_device(ahd_dev_softc_t pci)
         uint16_t  vendor;
         uint16_t  subdevice;
         uint16_t  subvendor;
-        struct    ahd_pci_identity *entry;
+        const struct ahd_pci_identity *entry;
         u_int     i;
 
         vendor = ahd_pci_read_config(pci, PCIR_DEVVENDOR, /*bytes*/2);
@@ -292,7 +292,7 @@ ahd_find_pci_device(ahd_dev_softc_t pci)
 }
 
 int
-ahd_pci_config(struct ahd_softc *ahd, struct ahd_pci_identity *entry)
+ahd_pci_config(struct ahd_softc *ahd, const struct ahd_pci_identity *entry)
 {
         struct scb_data *shared_scb_data;
         u_int            command;
diff --git a/drivers/scsi/aic7xxx/aic79xx_proc.c b/drivers/scsi/aic7xxx/aic79xx_proc.c
index 6b28bebcbca0..014bed716e7c 100644
--- a/drivers/scsi/aic7xxx/aic79xx_proc.c
+++ b/drivers/scsi/aic7xxx/aic79xx_proc.c
@@ -57,7 +57,7 @@ static int	ahd_proc_write_seeprom(struct ahd_softc *ahd,
  * Table of syncrates that don't follow the "divisible by 4"
  * rule. This table will be expanded in future SCSI specs.
  */
-static struct {
+static const struct {
         u_int period_factor;
         u_int period;   /* in 100ths of ns */
 } scsi_syncrates[] = {
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
index 2068e00d2c75..c21ceab8e913 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg.h_shipped
@@ -48,13 +48,6 @@ ahd_reg_print_t ahd_error_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrerr_print;
-#else
-#define ahd_clrerr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRERR", 0x04, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_hcntrl_print;
 #else
 #define ahd_hcntrl_print(regvalue, cur_col, wrap) \
@@ -167,13 +160,6 @@ ahd_reg_print_t ahd_sg_cache_shadow_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_arbctl_print;
-#else
-#define ahd_arbctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ARBCTL", 0x1b, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_sg_cache_pre_print;
 #else
 #define ahd_sg_cache_pre_print(regvalue, cur_col, wrap) \
@@ -188,20 +174,6 @@ ahd_reg_print_t ahd_lqin_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_typeptr_print;
-#else
-#define ahd_typeptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "TYPEPTR", 0x20, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_tagptr_print;
-#else
-#define ahd_tagptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "TAGPTR", 0x21, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lunptr_print;
 #else
 #define ahd_lunptr_print(regvalue, cur_col, wrap) \
@@ -209,20 +181,6 @@ ahd_reg_print_t ahd_lunptr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_datalenptr_print;
-#else
-#define ahd_datalenptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DATALENPTR", 0x23, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_statlenptr_print;
-#else
-#define ahd_statlenptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "STATLENPTR", 0x24, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_cmdlenptr_print;
 #else
 #define ahd_cmdlenptr_print(regvalue, cur_col, wrap) \
@@ -258,13 +216,6 @@ ahd_reg_print_t ahd_qnextptr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_idptr_print;
-#else
-#define ahd_idptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "IDPTR", 0x2a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_abrtbyteptr_print;
 #else
 #define ahd_abrtbyteptr_print(regvalue, cur_col, wrap) \
@@ -279,27 +230,6 @@ ahd_reg_print_t ahd_abrtbitptr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_maxcmdbytes_print;
-#else
-#define ahd_maxcmdbytes_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MAXCMDBYTES", 0x2d, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_maxcmd2rcv_print;
-#else
-#define ahd_maxcmd2rcv_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MAXCMD2RCV", 0x2e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_shortthresh_print;
-#else
-#define ahd_shortthresh_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SHORTTHRESH", 0x2f, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lunlen_print;
 #else
 #define ahd_lunlen_print(regvalue, cur_col, wrap) \
@@ -328,41 +258,6 @@ ahd_reg_print_t ahd_maxcmdcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqrsvd01_print;
-#else
-#define ahd_lqrsvd01_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQRSVD01", 0x34, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqrsvd16_print;
-#else
-#define ahd_lqrsvd16_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQRSVD16", 0x35, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqrsvd17_print;
-#else
-#define ahd_lqrsvd17_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQRSVD17", 0x36, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmdrsvd0_print;
-#else
-#define ahd_cmdrsvd0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMDRSVD0", 0x37, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqctl0_print;
-#else
-#define ahd_lqctl0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQCTL0", 0x38, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lqctl1_print;
 #else
 #define ahd_lqctl1_print(regvalue, cur_col, wrap) \
@@ -370,13 +265,6 @@ ahd_reg_print_t ahd_lqctl1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsbist0_print;
-#else
-#define ahd_scsbist0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSBIST0", 0x39, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_lqctl2_print;
 #else
 #define ahd_lqctl2_print(regvalue, cur_col, wrap) \
@@ -384,13 +272,6 @@ ahd_reg_print_t ahd_lqctl2_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsbist1_print;
-#else
-#define ahd_scsbist1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSBIST1", 0x3a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scsiseq0_print;
 #else
 #define ahd_scsiseq0_print(regvalue, cur_col, wrap) \
@@ -412,20 +293,6 @@ ahd_reg_print_t ahd_sxfrctl0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dlcount_print;
-#else
-#define ahd_dlcount_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DLCOUNT", 0x3c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_businitid_print;
-#else
-#define ahd_businitid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BUSINITID", 0x3c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_sxfrctl1_print;
 #else
 #define ahd_sxfrctl1_print(regvalue, cur_col, wrap) \
@@ -433,20 +300,6 @@ ahd_reg_print_t ahd_sxfrctl1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_bustargid_print;
-#else
-#define ahd_bustargid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BUSTARGID", 0x3e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sxfrctl2_print;
-#else
-#define ahd_sxfrctl2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SXFRCTL2", 0x3e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dffstat_print;
 #else
 #define ahd_dffstat_print(regvalue, cur_col, wrap) \
@@ -454,17 +307,17 @@ ahd_reg_print_t ahd_dffstat_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsisigo_print;
+ahd_reg_print_t ahd_multargid_print;
 #else
-#define ahd_scsisigo_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSISIGO", 0x40, regvalue, cur_col, wrap)
+#define ahd_multargid_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "MULTARGID", 0x40, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_multargid_print;
+ahd_reg_print_t ahd_scsisigo_print;
 #else
-#define ahd_multargid_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MULTARGID", 0x40, regvalue, cur_col, wrap)
+#define ahd_scsisigo_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SCSISIGO", 0x40, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -482,13 +335,6 @@ ahd_reg_print_t ahd_scsiphase_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsidat0_img_print;
-#else
-#define ahd_scsidat0_img_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSIDAT0_IMG", 0x43, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scsidat_print;
 #else
 #define ahd_scsidat_print(regvalue, cur_col, wrap) \
@@ -531,13 +377,6 @@ ahd_reg_print_t ahd_sblkctl_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrsint0_print;
-#else
-#define ahd_clrsint0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRSINT0", 0x4b, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_sstat0_print;
 #else
 #define ahd_sstat0_print(regvalue, cur_col, wrap) \
@@ -552,10 +391,10 @@ ahd_reg_print_t ahd_simode0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrsint1_print;
+ahd_reg_print_t ahd_clrsint0_print;
 #else
-#define ahd_clrsint1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRSINT1", 0x4c, regvalue, cur_col, wrap)
+#define ahd_clrsint0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CLRSINT0", 0x4b, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -566,17 +405,17 @@ ahd_reg_print_t ahd_sstat1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sstat2_print;
+ahd_reg_print_t ahd_clrsint1_print;
 #else
-#define ahd_sstat2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SSTAT2", 0x4d, regvalue, cur_col, wrap)
+#define ahd_clrsint1_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CLRSINT1", 0x4c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_simode2_print;
+ahd_reg_print_t ahd_sstat2_print;
 #else
-#define ahd_simode2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SIMODE2", 0x4d, regvalue, cur_col, wrap)
+#define ahd_sstat2_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SSTAT2", 0x4d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -622,17 +461,17 @@ ahd_reg_print_t ahd_lqistat0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_clrlqiint0_print;
+ahd_reg_print_t ahd_lqimode0_print;
 #else
-#define ahd_clrlqiint0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CLRLQIINT0", 0x50, regvalue, cur_col, wrap)
+#define ahd_lqimode0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "LQIMODE0", 0x50, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lqimode0_print;
+ahd_reg_print_t ahd_clrlqiint0_print;
 #else
-#define ahd_lqimode0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LQIMODE0", 0x50, regvalue, cur_col, wrap)
+#define ahd_clrlqiint0_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CLRLQIINT0", 0x50, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -790,13 +629,6 @@ ahd_reg_print_t ahd_seqintsrc_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_currscb_print;
-#else
-#define ahd_currscb_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CURRSCB", 0x5c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_seqimode_print;
 #else
 #define ahd_seqimode_print(regvalue, cur_col, wrap) \
@@ -804,24 +636,17 @@ ahd_reg_print_t ahd_seqimode_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_mdffstat_print;
-#else
-#define ahd_mdffstat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MDFFSTAT", 0x5d, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_crccontrol_print;
+ahd_reg_print_t ahd_currscb_print;
 #else
-#define ahd_crccontrol_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CRCCONTROL", 0x5d, regvalue, cur_col, wrap)
+#define ahd_currscb_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "CURRSCB", 0x5c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfftag_print;
+ahd_reg_print_t ahd_mdffstat_print;
 #else
-#define ahd_dfftag_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFFTAG", 0x5e, regvalue, cur_col, wrap)
+#define ahd_mdffstat_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "MDFFSTAT", 0x5d, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -832,20 +657,6 @@ ahd_reg_print_t ahd_lastscb_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scsitest_print;
-#else
-#define ahd_scsitest_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCSITEST", 0x5e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_iopdnctl_print;
-#else
-#define ahd_iopdnctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "IOPDNCTL", 0x5f, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_shaddr_print;
 #else
 #define ahd_shaddr_print(regvalue, cur_col, wrap) \
@@ -860,13 +671,6 @@ ahd_reg_print_t ahd_negoaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dgrpcrci_print;
-#else
-#define ahd_dgrpcrci_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DGRPCRCI", 0x60, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_negperiod_print;
 #else
 #define ahd_negperiod_print(regvalue, cur_col, wrap) \
@@ -874,13 +678,6 @@ ahd_reg_print_t ahd_negperiod_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_packcrci_print;
-#else
-#define ahd_packcrci_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PACKCRCI", 0x62, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_negoffset_print;
 #else
 #define ahd_negoffset_print(regvalue, cur_col, wrap) \
@@ -930,13 +727,6 @@ ahd_reg_print_t ahd_iownid_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll960ctl0_print;
-#else
-#define ahd_pll960ctl0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL960CTL0", 0x68, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_shcnt_print;
 #else
 #define ahd_shcnt_print(regvalue, cur_col, wrap) \
@@ -951,27 +741,6 @@ ahd_reg_print_t ahd_townid_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll960ctl1_print;
-#else
-#define ahd_pll960ctl1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL960CTL1", 0x69, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll960cnt0_print;
-#else
-#define ahd_pll960cnt0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL960CNT0", 0x6a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_xsig_print;
-#else
-#define ahd_xsig_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "XSIG", 0x6a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_seloid_print;
 #else
 #define ahd_seloid_print(regvalue, cur_col, wrap) \
@@ -979,41 +748,6 @@ ahd_reg_print_t ahd_seloid_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll400ctl0_print;
-#else
-#define ahd_pll400ctl0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL400CTL0", 0x6c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_fairness_print;
-#else
-#define ahd_fairness_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FAIRNESS", 0x6c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll400ctl1_print;
-#else
-#define ahd_pll400ctl1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL400CTL1", 0x6d, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_unfairness_print;
-#else
-#define ahd_unfairness_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "UNFAIRNESS", 0x6e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_pll400cnt0_print;
-#else
-#define ahd_pll400cnt0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLL400CNT0", 0x6e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_haddr_print;
 #else
 #define ahd_haddr_print(regvalue, cur_col, wrap) \
@@ -1021,27 +755,6 @@ ahd_reg_print_t ahd_haddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_plldelay_print;
-#else
-#define ahd_plldelay_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "PLLDELAY", 0x70, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_hodmaadr_print;
-#else
-#define ahd_hodmaadr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "HODMAADR", 0x70, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_hodmacnt_print;
-#else
-#define ahd_hodmacnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "HODMACNT", 0x78, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_hcnt_print;
 #else
 #define ahd_hcnt_print(regvalue, cur_col, wrap) \
@@ -1049,10 +762,10 @@ ahd_reg_print_t ahd_hcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_hodmaen_print;
+ahd_reg_print_t ahd_sghaddr_print;
 #else
-#define ahd_hodmaen_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "HODMAEN", 0x7a, regvalue, cur_col, wrap)
+#define ahd_sghaddr_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SGHADDR", 0x7c, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1063,10 +776,10 @@ ahd_reg_print_t ahd_scbhaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sghaddr_print;
+ahd_reg_print_t ahd_sghcnt_print;
 #else
-#define ahd_sghaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGHADDR", 0x7c, regvalue, cur_col, wrap)
+#define ahd_sghcnt_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SGHCNT", 0x84, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -1077,13 +790,6 @@ ahd_reg_print_t ahd_scbhcnt_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sghcnt_print;
-#else
-#define ahd_sghcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGHCNT", 0x84, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dff_thrsh_print;
 #else
 #define ahd_dff_thrsh_print(regvalue, cur_col, wrap) \
@@ -1091,132 +797,6 @@ ahd_reg_print_t ahd_dff_thrsh_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_romaddr_print;
-#else
-#define ahd_romaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ROMADDR", 0x8a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_romcntrl_print;
-#else
-#define ahd_romcntrl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ROMCNTRL", 0x8d, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_romdata_print;
-#else
-#define ahd_romdata_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ROMDATA", 0x8e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcrxmsg0_print;
-#else
-#define ahd_cmcrxmsg0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCRXMSG0", 0x90, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_roenable_print;
-#else
-#define ahd_roenable_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "ROENABLE", 0x90, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg0_print;
-#else
-#define ahd_ovlyrxmsg0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG0", 0x90, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg0_print;
-#else
-#define ahd_dchrxmsg0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG0", 0x90, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg1_print;
-#else
-#define ahd_ovlyrxmsg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG1", 0x91, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_nsenable_print;
-#else
-#define ahd_nsenable_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "NSENABLE", 0x91, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcrxmsg1_print;
-#else
-#define ahd_cmcrxmsg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCRXMSG1", 0x91, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg1_print;
-#else
-#define ahd_dchrxmsg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG1", 0x91, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg2_print;
-#else
-#define ahd_dchrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG2", 0x92, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcrxmsg2_print;
-#else
-#define ahd_cmcrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCRXMSG2", 0x92, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ost_print;
-#else
-#define ahd_ost_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OST", 0x92, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg2_print;
-#else
-#define ahd_ovlyrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG2", 0x92, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchrxmsg3_print;
-#else
-#define ahd_dchrxmsg3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHRXMSG3", 0x93, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyrxmsg3_print;
-#else
-#define ahd_ovlyrxmsg3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYRXMSG3", 0x93, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcrxmsg3_print;
-#else
-#define ahd_cmcrxmsg3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCRXMSG3", 0x93, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_pcixctl_print;
 #else
 #define ahd_pcixctl_print(regvalue, cur_col, wrap) \
@@ -1224,34 +804,6 @@ ahd_reg_print_t ahd_pcixctl_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyseqbcnt_print;
-#else
-#define ahd_ovlyseqbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYSEQBCNT", 0x94, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dchseqbcnt_print;
-#else
-#define ahd_dchseqbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DCHSEQBCNT", 0x94, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcseqbcnt_print;
-#else
-#define ahd_cmcseqbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCSEQBCNT", 0x94, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcspltstat0_print;
-#else
-#define ahd_cmcspltstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dchspltstat0_print;
 #else
 #define ahd_dchspltstat0_print(regvalue, cur_col, wrap) \
@@ -1259,27 +811,6 @@ ahd_reg_print_t ahd_dchspltstat0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyspltstat0_print;
-#else
-#define ahd_ovlyspltstat0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYSPLTSTAT0", 0x96, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcspltstat1_print;
-#else
-#define ahd_cmcspltstat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCSPLTSTAT1", 0x97, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyspltstat1_print;
-#else
-#define ahd_ovlyspltstat1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYSPLTSTAT1", 0x97, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dchspltstat1_print;
 #else
 #define ahd_dchspltstat1_print(regvalue, cur_col, wrap) \
@@ -1287,90 +818,6 @@ ahd_reg_print_t ahd_dchspltstat1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgrxmsg0_print;
-#else
-#define ahd_sgrxmsg0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGRXMSG0", 0x98, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutadr0_print;
-#else
-#define ahd_slvspltoutadr0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTADR0", 0x98, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgrxmsg1_print;
-#else
-#define ahd_sgrxmsg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGRXMSG1", 0x99, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutadr1_print;
-#else
-#define ahd_slvspltoutadr1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTADR1", 0x99, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgrxmsg2_print;
-#else
-#define ahd_sgrxmsg2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGRXMSG2", 0x9a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutadr2_print;
-#else
-#define ahd_slvspltoutadr2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTADR2", 0x9a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgrxmsg3_print;
-#else
-#define ahd_sgrxmsg3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGRXMSG3", 0x9b, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutadr3_print;
-#else
-#define ahd_slvspltoutadr3_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTADR3", 0x9b, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgseqbcnt_print;
-#else
-#define ahd_sgseqbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGSEQBCNT", 0x9c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutattr0_print;
-#else
-#define ahd_slvspltoutattr0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTATTR0", 0x9c, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutattr1_print;
-#else
-#define ahd_slvspltoutattr1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTATTR1", 0x9d, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_slvspltoutattr2_print;
-#else
-#define ahd_slvspltoutattr2_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SLVSPLTOUTATTR2", 0x9e, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_sgspltstat0_print;
 #else
 #define ahd_sgspltstat0_print(regvalue, cur_col, wrap) \
@@ -1385,13 +832,6 @@ ahd_reg_print_t ahd_sgspltstat1_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sfunct_print;
-#else
-#define ahd_sfunct_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SFUNCT", 0x9f, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_df0pcistat_print;
 #else
 #define ahd_df0pcistat_print(regvalue, cur_col, wrap) \
@@ -1406,41 +846,6 @@ ahd_reg_print_t ahd_reg0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_df1pcistat_print;
-#else
-#define ahd_df1pcistat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DF1PCISTAT", 0xa1, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sgpcistat_print;
-#else
-#define ahd_sgpcistat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SGPCISTAT", 0xa2, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_reg1_print;
-#else
-#define ahd_reg1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "REG1", 0xa2, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmcpcistat_print;
-#else
-#define ahd_cmcpcistat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMCPCISTAT", 0xa3, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlypcistat_print;
-#else
-#define ahd_ovlypcistat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYPCISTAT", 0xa4, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_reg_isr_print;
 #else
 #define ahd_reg_isr_print(regvalue, cur_col, wrap) \
@@ -1455,13 +860,6 @@ ahd_reg_print_t ahd_sg_state_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_msipcistat_print;
-#else
-#define ahd_msipcistat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "MSIPCISTAT", 0xa6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_targpcistat_print;
 #else
 #define ahd_targpcistat_print(regvalue, cur_col, wrap) \
@@ -1469,13 +867,6 @@ ahd_reg_print_t ahd_targpcistat_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_data_count_odd_print;
-#else
-#define ahd_data_count_odd_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DATA_COUNT_ODD", 0xa7, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scbptr_print;
 #else
 #define ahd_scbptr_print(regvalue, cur_col, wrap) \
@@ -1483,13 +874,6 @@ ahd_reg_print_t ahd_scbptr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbacnt_print;
-#else
-#define ahd_ccscbacnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBACNT", 0xab, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scbautoptr_print;
 #else
 #define ahd_scbautoptr_print(regvalue, cur_col, wrap) \
@@ -1504,13 +888,6 @@ ahd_reg_print_t ahd_ccsgaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ccscbadr_bk_print;
-#else
-#define ahd_ccscbadr_bk_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CCSCBADR_BK", 0xac, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_ccscbaddr_print;
 #else
 #define ahd_ccscbaddr_print(regvalue, cur_col, wrap) \
@@ -1518,13 +895,6 @@ ahd_reg_print_t ahd_ccscbaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_cmc_rambist_print;
-#else
-#define ahd_cmc_rambist_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "CMC_RAMBIST", 0xad, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_ccscbctl_print;
 #else
 #define ahd_ccscbctl_print(regvalue, cur_col, wrap) \
@@ -1546,13 +916,6 @@ ahd_reg_print_t ahd_ccsgram_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_flexadr_print;
-#else
-#define ahd_flexadr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FLEXADR", 0xb0, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_ccscbram_print;
 #else
 #define ahd_ccscbram_print(regvalue, cur_col, wrap) \
@@ -1560,27 +923,6 @@ ahd_reg_print_t ahd_ccscbram_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_flexcnt_print;
-#else
-#define ahd_flexcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FLEXCNT", 0xb3, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_flexdmastat_print;
-#else
-#define ahd_flexdmastat_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FLEXDMASTAT", 0xb5, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_flexdata_print;
-#else
-#define ahd_flexdata_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FLEXDATA", 0xb6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_brddat_print;
 #else
 #define ahd_brddat_print(regvalue, cur_col, wrap) \
@@ -1623,27 +965,6 @@ ahd_reg_print_t ahd_seestat_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scbcnt_print;
-#else
-#define ahd_scbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCBCNT", 0xbf, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfwaddr_print;
-#else
-#define ahd_dfwaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFWADDR", 0xc0, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dspfltrctl_print;
-#else
-#define ahd_dspfltrctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DSPFLTRCTL", 0xc0, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dspdatactl_print;
 #else
 #define ahd_dspdatactl_print(regvalue, cur_col, wrap) \
@@ -1651,27 +972,6 @@ ahd_reg_print_t ahd_dspdatactl_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfraddr_print;
-#else
-#define ahd_dfraddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFRADDR", 0xc2, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dspreqctl_print;
-#else
-#define ahd_dspreqctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DSPREQCTL", 0xc2, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dspackctl_print;
-#else
-#define ahd_dspackctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DSPACKCTL", 0xc3, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_dfdat_print;
 #else
 #define ahd_dfdat_print(regvalue, cur_col, wrap) \
@@ -1693,76 +993,6 @@ ahd_reg_print_t ahd_wrtbiasctl_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_rcvrbiosctl_print;
-#else
-#define ahd_rcvrbiosctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "RCVRBIOSCTL", 0xc6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_wrtbiascalc_print;
-#else
-#define ahd_wrtbiascalc_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "WRTBIASCALC", 0xc7, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_rcvrbiascalc_print;
-#else
-#define ahd_rcvrbiascalc_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "RCVRBIASCALC", 0xc8, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfptrs_print;
-#else
-#define ahd_dfptrs_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFPTRS", 0xc8, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_skewcalc_print;
-#else
-#define ahd_skewcalc_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SKEWCALC", 0xc9, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfbkptr_print;
-#else
-#define ahd_dfbkptr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFBKPTR", 0xc9, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfdbctl_print;
-#else
-#define ahd_dfdbctl_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFDBCTL", 0xcb, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfscnt_print;
-#else
-#define ahd_dfscnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFSCNT", 0xcc, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_dfbcnt_print;
-#else
-#define ahd_dfbcnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "DFBCNT", 0xce, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ovlyaddr_print;
-#else
-#define ahd_ovlyaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "OVLYADDR", 0xd4, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_seqctl0_print;
 #else
 #define ahd_seqctl0_print(regvalue, cur_col, wrap) \
@@ -1770,13 +1000,6 @@ ahd_reg_print_t ahd_seqctl0_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_seqctl1_print;
-#else
-#define ahd_seqctl1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SEQCTL1", 0xd7, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_flags_print;
 #else
 #define ahd_flags_print(regvalue, cur_col, wrap) \
@@ -1826,20 +1049,6 @@ ahd_reg_print_t ahd_dindex_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_brkaddr0_print;
-#else
-#define ahd_brkaddr0_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BRKADDR0", 0xe6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_brkaddr1_print;
-#else
-#define ahd_brkaddr1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "BRKADDR1", 0xe6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_allones_print;
 #else
 #define ahd_allones_print(regvalue, cur_col, wrap) \
@@ -1875,13 +1084,6 @@ ahd_reg_print_t ahd_dindir_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_function1_print;
-#else
-#define ahd_function1_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "FUNCTION1", 0xf0, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_stack_print;
 #else
 #define ahd_stack_print(regvalue, cur_col, wrap) \
@@ -1903,13 +1105,6 @@ ahd_reg_print_t ahd_curaddr_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_lastaddr_print;
-#else
-#define ahd_lastaddr_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "LASTADDR", 0xf6, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_intvec2_addr_print;
 #else
 #define ahd_intvec2_addr_print(regvalue, cur_col, wrap) \
@@ -1931,24 +1126,17 @@ ahd_reg_print_t ahd_accum_save_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_waiting_scb_tails_print;
-#else
-#define ahd_waiting_scb_tails_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "WAITING_SCB_TAILS", 0x100, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_ahd_pci_config_base_print;
+ahd_reg_print_t ahd_sram_base_print;
 #else
-#define ahd_ahd_pci_config_base_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "AHD_PCI_CONFIG_BASE", 0x100, regvalue, cur_col, wrap)
+#define ahd_sram_base_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SRAM_BASE", 0x100, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_sram_base_print;
+ahd_reg_print_t ahd_waiting_scb_tails_print;
 #else
-#define ahd_sram_base_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SRAM_BASE", 0x100, regvalue, cur_col, wrap)
+#define ahd_waiting_scb_tails_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "WAITING_SCB_TAILS", 0x100, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -2218,17 +1406,17 @@ ahd_reg_print_t ahd_mk_message_scsiid_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_base_print;
+ahd_reg_print_t ahd_scb_residual_datacnt_print;
 #else
-#define ahd_scb_base_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_BASE", 0x180, regvalue, cur_col, wrap)
+#define ahd_scb_residual_datacnt_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT", 0x180, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_residual_datacnt_print;
+ahd_reg_print_t ahd_scb_base_print;
 #else
-#define ahd_scb_residual_datacnt_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT", 0x180, regvalue, cur_col, wrap)
+#define ahd_scb_base_print(regvalue, cur_col, wrap) \
+    ahd_print_register(NULL, 0, "SCB_BASE", 0x180, regvalue, cur_col, wrap)
 #endif
 
 #if AIC_DEBUG_REGISTERS
@@ -2246,27 +1434,6 @@ ahd_reg_print_t ahd_scb_scsi_status_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_target_phases_print;
-#else
-#define ahd_scb_target_phases_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_TARGET_PHASES", 0x189, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_target_data_dir_print;
-#else
-#define ahd_scb_target_data_dir_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_TARGET_DATA_DIR", 0x18a, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_target_itag_print;
-#else
-#define ahd_scb_target_itag_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_TARGET_ITAG", 0x18b, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scb_sense_busaddr_print;
 #else
 #define ahd_scb_sense_busaddr_print(regvalue, cur_col, wrap) \
@@ -2365,13 +1532,6 @@ ahd_reg_print_t ahd_scb_next2_print;
 #endif
 
 #if AIC_DEBUG_REGISTERS
-ahd_reg_print_t ahd_scb_spare_print;
-#else
-#define ahd_scb_spare_print(regvalue, cur_col, wrap) \
-    ahd_print_register(NULL, 0, "SCB_SPARE", 0x1b0, regvalue, cur_col, wrap)
-#endif
-
-#if AIC_DEBUG_REGISTERS
 ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #else
 #define ahd_scb_disconnected_lists_print(regvalue, cur_col, wrap) \
@@ -2557,10 +1717,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define SG_CACHE_PRE                    0x1b
 
-#define LQIN                            0x20
-
 #define TYPEPTR                         0x20
 
+#define LQIN                            0x20
+
 #define TAGPTR                          0x21
 
 #define LUNPTR                          0x22
@@ -2620,14 +1780,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         SINGLECMD               0x02
 #define         ABORTPENDING            0x01
 
-#define SCSBIST0                        0x39
-#define         GSBISTERR               0x40
-#define         GSBISTDONE              0x20
-#define         GSBISTRUN               0x10
-#define         OSBISTERR               0x04
-#define         OSBISTDONE              0x02
-#define         OSBISTRUN               0x01
-
 #define LQCTL2                          0x39
 #define         LQIRETRY                0x80
 #define         LQICONTINUE             0x40
@@ -2638,10 +1790,13 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         LQOTOIDLE               0x02
 #define         LQOPAUSE                0x01
 
-#define SCSBIST1                        0x3a
-#define         NTBISTERR               0x04
-#define         NTBISTDONE              0x02
-#define         NTBISTRUN               0x01
+#define SCSBIST0                        0x39
+#define         GSBISTERR               0x40
+#define         GSBISTDONE              0x20
+#define         GSBISTRUN               0x10
+#define         OSBISTERR               0x04
+#define         OSBISTDONE              0x02
+#define         OSBISTRUN               0x01
 
 #define SCSISEQ0                        0x3a
 #define         TEMODEO                 0x80
@@ -2650,8 +1805,15 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         FORCEBUSFREE            0x10
 #define         SCSIRSTO                0x01
 
+#define SCSBIST1                        0x3a
+#define         NTBISTERR               0x04
+#define         NTBISTDONE              0x02
+#define         NTBISTRUN               0x01
+
 #define SCSISEQ1                        0x3b
 
+#define BUSINITID                       0x3c
+
 #define SXFRCTL0                        0x3c
 #define         DFON                    0x80
 #define         DFPEXP                  0x40
@@ -2660,8 +1822,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define DLCOUNT                         0x3c
 
-#define BUSINITID                       0x3c
-
 #define SXFRCTL1                        0x3d
 #define         BITBUCKET               0x80
 #define         ENSACHK                 0x40
@@ -2686,6 +1846,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CURRFIFO_1              0x01
 #define         CURRFIFO_0              0x00
 
+#define MULTARGID                       0x40
+
 #define SCSISIGO                        0x40
 #define         CDO                     0x80
 #define         IOO                     0x40
@@ -2696,8 +1858,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         REQO                    0x02
 #define         ACKO                    0x01
 
-#define MULTARGID                       0x40
-
 #define SCSISIGI                        0x41
 #define         ATNI                    0x10
 #define         SELI                    0x08
@@ -2744,15 +1904,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENAB20                  0x04
 #define         SELWIDE                 0x02
 
-#define CLRSINT0                        0x4b
-#define         CLRSELDO                0x40
-#define         CLRSELDI                0x20
-#define         CLRSELINGO              0x10
-#define         CLRIOERR                0x08
-#define         CLROVERRUN              0x04
-#define         CLRSPIORDY              0x02
-#define         CLRARBDO                0x01
-
 #define SSTAT0                          0x4b
 #define         TARGET                  0x80
 #define         SELDO                   0x40
@@ -2772,14 +1923,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENSPIORDY               0x02
 #define         ENARBDO                 0x01
 
-#define CLRSINT1                        0x4c
-#define         CLRSELTIMEO             0x80
-#define         CLRATNO                 0x40
-#define         CLRSCSIRSTI             0x20
-#define         CLRBUSFREE              0x08
-#define         CLRSCSIPERR             0x04
-#define         CLRSTRB2FAST            0x02
-#define         CLRREQINIT              0x01
+#define CLRSINT0                        0x4b
+#define         CLRSELDO                0x40
+#define         CLRSELDI                0x20
+#define         CLRSELINGO              0x10
+#define         CLRIOERR                0x08
+#define         CLROVERRUN              0x04
+#define         CLRSPIORDY              0x02
+#define         CLRARBDO                0x01
 
 #define SSTAT1                          0x4c
 #define         SELTO                   0x80
@@ -2791,6 +1942,15 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         STRB2FAST               0x02
 #define         REQINIT                 0x01
 
+#define CLRSINT1                        0x4c
+#define         CLRSELTIMEO             0x80
+#define         CLRATNO                 0x40
+#define         CLRSCSIRSTI             0x20
+#define         CLRBUSFREE              0x08
+#define         CLRSCSIPERR             0x04
+#define         CLRSTRB2FAST            0x02
+#define         CLRREQINIT              0x01
+
 #define SSTAT2                          0x4d
 #define         BUSFREETIME             0xc0
 #define         NONPACKREQ              0x20
@@ -2838,14 +1998,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         LQIATNLQ                0x02
 #define         LQIATNCMD               0x01
 
-#define CLRLQIINT0                      0x50
-#define         CLRLQIATNQAS            0x20
-#define         CLRLQICRCT1             0x10
-#define         CLRLQICRCT2             0x08
-#define         CLRLQIBADLQT            0x04
-#define         CLRLQIATNLQ             0x02
-#define         CLRLQIATNCMD            0x01
-
 #define LQIMODE0                        0x50
 #define         ENLQIATNQASK            0x20
 #define         ENLQICRCT1              0x10
@@ -2854,6 +2006,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENLQIATNLQ              0x02
 #define         ENLQIATNCMD             0x01
 
+#define CLRLQIINT0                      0x50
+#define         CLRLQIATNQAS            0x20
+#define         CLRLQICRCT1             0x10
+#define         CLRLQICRCT2             0x08
+#define         CLRLQIBADLQT            0x04
+#define         CLRLQIATNLQ             0x02
+#define         CLRLQIATNCMD            0x01
+
 #define LQIMODE1                        0x51
 #define         ENLQIPHASE_LQ           0x80
 #define         ENLQIPHASE_NLQ          0x40
@@ -2976,6 +2136,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define LQOSCSCTL                       0x5a
 #define         LQOH2A_VERSION          0x80
+#define         LQOBUSETDLY             0x40
+#define         LQONOHOLDLACK           0x02
 #define         LQONOCHKOVER            0x01
 
 #define NEXTSCB                         0x5a
@@ -2998,8 +2160,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         CFG4ICMD                0x02
 #define         CFG4TCMD                0x01
 
-#define CURRSCB                         0x5c
-
 #define SEQIMODE                        0x5c
 #define         ENCTXTDONE              0x40
 #define         ENSAVEPTRS              0x20
@@ -3009,6 +2169,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         ENCFG4ICMD              0x02
 #define         ENCFG4TCMD              0x01
 
+#define CURRSCB                         0x5c
+
 #define MDFFSTAT                        0x5d
 #define         SHCNTNEGATIVE           0x40
 #define         SHCNTMINUS1             0x20
@@ -3023,29 +2185,29 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define DFFTAG                          0x5e
 
-#define LASTSCB                         0x5e
-
 #define SCSITEST                        0x5e
 #define         CNTRTEST                0x08
 #define         SEL_TXPLL_DEBUG         0x04
 
+#define LASTSCB                         0x5e
+
 #define IOPDNCTL                        0x5f
 #define         DISABLE_OE              0x80
 #define         PDN_IDIST               0x04
 #define         PDN_DIFFSENSE           0x01
 
+#define DGRPCRCI                        0x60
+
 #define SHADDR                          0x60
 
 #define NEGOADDR                        0x60
 
-#define DGRPCRCI                        0x60
-
 #define NEGPERIOD                       0x61
 
-#define PACKCRCI                        0x62
-
 #define NEGOFFSET                       0x62
 
+#define PACKCRCI                        0x62
+
 #define NEGPPROPTS                      0x63
 #define         PPROPT_PACE             0x08
 #define         PPROPT_QAS              0x04
@@ -3066,6 +2228,7 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define ANNEXDAT                        0x66
 
 #define SCSCHKN                         0x66
+#define         BIDICHKDIS              0x80
 #define         STSELSKIDDIS            0x40
 #define         CURRFIFODEF             0x20
 #define         WIDERESEN               0x10
@@ -3090,6 +2253,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define SELOID                          0x6b
 
+#define FAIRNESS                        0x6c
+
 #define PLL400CTL0                      0x6c
 #define         PLL_VCOSEL              0x80
 #define         PLL_PWDN                0x40
@@ -3099,8 +2264,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         PLL_DLPF                0x02
 #define         PLL_ENFBM               0x01
 
-#define FAIRNESS                        0x6c
-
 #define PLL400CTL1                      0x6d
 #define         PLL_CNTEN               0x80
 #define         PLL_CNTCLR              0x40
@@ -3112,25 +2275,25 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define HADDR                           0x70
 
+#define HODMAADR                        0x70
+
 #define PLLDELAY                        0x70
 #define         SPLIT_DROP_REQ          0x80
 
-#define HODMAADR                        0x70
+#define HCNT                            0x78
 
 #define HODMACNT                        0x78
 
-#define HCNT                            0x78
-
 #define HODMAEN                         0x7a
 
-#define SCBHADDR                        0x7c
-
 #define SGHADDR                         0x7c
 
-#define SCBHCNT                         0x84
+#define SCBHADDR                        0x7c
 
 #define SGHCNT                          0x84
 
+#define SCBHCNT                         0x84
+
 #define DFF_THRSH                       0x88
 #define         WR_DFTHRSH              0x70
 #define         RD_DFTHRSH              0x07
@@ -3163,6 +2326,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define CMCRXMSG0                       0x90
 
+#define OVLYRXMSG0                      0x90
+
+#define DCHRXMSG0                       0x90
+
 #define ROENABLE                        0x90
 #define         MSIROEN                 0x20
 #define         OVLYROEN                0x10
@@ -3171,11 +2338,11 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         DCH1ROEN                0x02
 #define         DCH0ROEN                0x01
 
-#define OVLYRXMSG0                      0x90
+#define OVLYRXMSG1                      0x91
 
-#define DCHRXMSG0                       0x90
+#define CMCRXMSG1                       0x91
 
-#define OVLYRXMSG1                      0x91
+#define DCHRXMSG1                       0x91
 
 #define NSENABLE                        0x91
 #define         MSINSEN                 0x20
@@ -3185,10 +2352,6 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         DCH1NSEN                0x02
 #define         DCH0NSEN                0x01
 
-#define CMCRXMSG1                       0x91
-
-#define DCHRXMSG1                       0x91
-
 #define DCHRXMSG2                       0x92
 
 #define CMCRXMSG2                       0x92
@@ -3212,24 +2375,24 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         TSCSERREN               0x02
 #define         CMPABCDIS               0x01
 
+#define CMCSEQBCNT                      0x94
+
 #define OVLYSEQBCNT                     0x94
 
 #define DCHSEQBCNT                      0x94
 
-#define CMCSEQBCNT                      0x94
-
-#define CMCSPLTSTAT0                    0x96
-
 #define DCHSPLTSTAT0                    0x96
 
 #define OVLYSPLTSTAT0                   0x96
 
-#define CMCSPLTSTAT1                    0x97
+#define CMCSPLTSTAT0                    0x96
 
 #define OVLYSPLTSTAT1                   0x97
 
 #define DCHSPLTSTAT1                    0x97
 
+#define CMCSPLTSTAT1                    0x97
+
 #define SGRXMSG0                        0x98
 #define         CDNUM                   0xf8
 #define         CFNUM                   0x07
@@ -3257,18 +2420,15 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         TAG_NUM                 0x1f
 #define         RLXORD                  0x10
 
-#define SGSEQBCNT                       0x9c
-
 #define SLVSPLTOUTATTR0                 0x9c
 #define         LOWER_BCNT              0xff
 
+#define SGSEQBCNT                       0x9c
+
 #define SLVSPLTOUTATTR1                 0x9d
 #define         CMPLT_DNUM              0xf8
 #define         CMPLT_FNUM              0x07
 
-#define SLVSPLTOUTATTR2                 0x9e
-#define         CMPLT_BNUM              0xff
-
 #define SGSPLTSTAT0                     0x9e
 #define         STAETERM                0x80
 #define         SCBCERR                 0x40
@@ -3279,6 +2439,9 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         RXSCEMSG                0x02
 #define         RXSPLTRSP               0x01
 
+#define SLVSPLTOUTATTR2                 0x9e
+#define         CMPLT_BNUM              0xff
+
 #define SGSPLTSTAT1                     0x9f
 #define         RXDATABUCKET            0x01
 
@@ -3334,10 +2497,10 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define CCSGADDR                        0xac
 
-#define CCSCBADR_BK                     0xac
-
 #define CCSCBADDR                       0xac
 
+#define CCSCBADR_BK                     0xac
+
 #define CMC_RAMBIST                     0xad
 #define         SG_ELEMENT_SIZE         0x80
 #define         SCBRAMBIST_FAIL         0x40
@@ -3391,9 +2554,9 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SEEDAT                          0xbc
 
 #define SEECTL                          0xbe
+#define         SEEOP_EWDS              0x40
 #define         SEEOP_WALL              0x40
 #define         SEEOP_EWEN              0x40
-#define         SEEOP_EWDS              0x40
 #define         SEEOPCODE               0x70
 #define         SEERST                  0x02
 #define         SEESTART                0x01
@@ -3410,25 +2573,25 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define SCBCNT                          0xbf
 
-#define DFWADDR                         0xc0
-
 #define DSPFLTRCTL                      0xc0
 #define         FLTRDISABLE             0x20
 #define         EDGESENSE               0x10
 #define         DSPFCNTSEL              0x0f
 
+#define DFWADDR                         0xc0
+
 #define DSPDATACTL                      0xc1
 #define         BYPASSENAB              0x80
 #define         DESQDIS                 0x10
 #define         RCVROFFSTDIS            0x04
 #define         XMITOFFSTDIS            0x02
 
-#define DFRADDR                         0xc2
-
 #define DSPREQCTL                       0xc2
 #define         MANREQCTL               0xc0
 #define         MANREQDLY               0x3f
 
+#define DFRADDR                         0xc2
+
 #define DSPACKCTL                       0xc3
 #define         MANACKCTL               0xc0
 #define         MANACKDLY               0x3f
@@ -3449,14 +2612,14 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define WRTBIASCALC                     0xc7
 
-#define RCVRBIASCALC                    0xc8
-
 #define DFPTRS                          0xc8
 
-#define SKEWCALC                        0xc9
+#define RCVRBIASCALC                    0xc8
 
 #define DFBKPTR                         0xc9
 
+#define SKEWCALC                        0xc9
+
 #define DFDBCTL                         0xcb
 #define         DFF_CIO_WR_RDY          0x20
 #define         DFF_CIO_RD_RDY          0x10
@@ -3541,12 +2704,12 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define ACCUM_SAVE                      0xfa
 
-#define WAITING_SCB_TAILS               0x100
-
 #define AHD_PCI_CONFIG_BASE             0x100
 
 #define SRAM_BASE                       0x100
 
+#define WAITING_SCB_TAILS               0x100
+
 #define WAITING_TID_HEAD                0x120
 
 #define WAITING_TID_TAIL                0x122
@@ -3575,8 +2738,8 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define         PRELOADEN               0x80
 #define         WIDEODD                 0x40
 #define         SCSIEN                  0x20
-#define         SDMAEN                  0x10
 #define         SDMAENACK               0x10
+#define         SDMAEN                  0x10
 #define         HDMAEN                  0x08
 #define         HDMAENACK               0x08
 #define         DIRECTION               0x04
@@ -3674,12 +2837,12 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 
 #define MK_MESSAGE_SCSIID               0x162
 
-#define SCB_BASE                        0x180
-
 #define SCB_RESIDUAL_DATACNT            0x180
 #define SCB_CDB_STORE                   0x180
 #define SCB_HOST_CDB_PTR                0x180
 
+#define SCB_BASE                        0x180
+
 #define SCB_RESIDUAL_SGPTR              0x184
 #define         SG_ADDR_MASK            0xf8
 #define         SG_OVERRUN_RESID        0x02
@@ -3747,6 +2910,17 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define SCB_DISCONNECTED_LISTS          0x1b8
 
 
+#define CMD_GROUP_CODE_SHIFT    0x05
+#define STIMESEL_MIN    0x18
+#define STIMESEL_SHIFT  0x03
+#define INVALID_ADDR    0x80
+#define AHD_PRECOMP_MASK        0x07
+#define TARGET_DATA_IN  0x01
+#define CCSCBADDR_MAX   0x80
+#define NUMDSPS         0x14
+#define SEEOP_EWEN_ADDR 0xc0
+#define AHD_ANNEXCOL_PER_DEV0   0x04
+#define DST_MODE_SHIFT  0x04
 #define AHD_TIMER_MAX_US        0x18ffe7
 #define AHD_TIMER_MAX_TICKS     0xffff
 #define AHD_SENSE_BUFSIZE       0x100
@@ -3781,43 +2955,32 @@ ahd_reg_print_t ahd_scb_disconnected_lists_print;
 #define LUNLEN_SINGLE_LEVEL_LUN 0x0f
 #define NVRAM_SCB_OFFSET        0x2c
 #define STATUS_PKT_SENSE        0xff
-#define CMD_GROUP_CODE_SHIFT    0x05
 #define MAX_OFFSET_PACED_BUG    0x7f
 #define STIMESEL_BUG_ADJ        0x08
-#define STIMESEL_MIN    0x18
-#define STIMESEL_SHIFT  0x03
 #define CCSGRAM_MAXSEGS 0x10
-#define INVALID_ADDR    0x80
 #define SEEOP_ERAL_ADDR 0x80
 #define AHD_SLEWRATE_DEF_REVB   0x08
 #define AHD_PRECOMP_CUTBACK_17  0x04
-#define AHD_PRECOMP_MASK        0x07
 #define SRC_MODE_SHIFT  0x00
 #define PKT_OVERRUN_BUFSIZE     0x200
 #define SCB_TRANSFER_SIZE_1BYTE_LUN     0x30
-#define TARGET_DATA_IN  0x01
 #define HOST_MSG        0xff
 #define MAX_OFFSET      0xfe
 #define BUS_16_BIT      0x01
-#define CCSCBADDR_MAX   0x80
-#define NUMDSPS         0x14
-#define SEEOP_EWEN_ADDR 0xc0
-#define AHD_ANNEXCOL_PER_DEV0   0x04
-#define DST_MODE_SHIFT  0x04
 
 
 /* Downloaded Constant Definitions */
+#define SG_SIZEOF       0x04
+#define SG_PREFETCH_ALIGN_MASK  0x02
+#define SG_PREFETCH_CNT_LIMIT   0x01
 #define CACHELINE_MASK  0x07
 #define SCB_TRANSFER_SIZE       0x06
 #define PKT_OVERRUN_BUFOFFSET   0x05
-#define SG_SIZEOF       0x04
 #define SG_PREFETCH_ADDR_MASK   0x03
-#define SG_PREFETCH_ALIGN_MASK  0x02
-#define SG_PREFETCH_CNT_LIMIT   0x01
 #define SG_PREFETCH_CNT 0x00
 #define DOWNLOAD_CONST_COUNT    0x08
 
 
 /* Exported Labels */
-#define LABEL_seq_isr   0x28f
 #define LABEL_timer_isr 0x28b
+#define LABEL_seq_isr   0x28f
diff --git a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
index db38a61a8cb4..c4c8a96bf5a3 100644
--- a/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
@@ -8,7 +8,7 @@
 
 #include "aic79xx_osm.h"
 
-static ahd_reg_parse_entry_t MODE_PTR_parse_table[] = {
+static const ahd_reg_parse_entry_t MODE_PTR_parse_table[] = {
         { "SRC_MODE",           0x07, 0x07 },
         { "DST_MODE",           0x70, 0x70 }
 };
@@ -20,7 +20,7 @@ ahd_mode_ptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x00, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
         { "SPLTINT",            0x01, 0x01 },
         { "CMDCMPLT",           0x02, 0x02 },
         { "SEQINT",             0x04, 0x04 },
@@ -39,7 +39,7 @@ ahd_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x01, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQINTCODE_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQINTCODE_parse_table[] = {
         { "NO_SEQINT",          0x00, 0xff },
         { "BAD_PHASE",          0x01, 0xff },
         { "SEND_REJECT",        0x02, 0xff },
@@ -76,7 +76,7 @@ ahd_seqintcode_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x02, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRINT_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRINT_parse_table[] = {
         { "CLRSPLTINT",         0x01, 0x01 },
         { "CLRCMDINT",          0x02, 0x02 },
         { "CLRSEQINT",          0x04, 0x04 },
@@ -94,7 +94,7 @@ ahd_clrint_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x03, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t ERROR_parse_table[] = {
+static const ahd_reg_parse_entry_t ERROR_parse_table[] = {
         { "DSCTMOUT",           0x02, 0x02 },
         { "ILLOPCODE",          0x04, 0x04 },
         { "SQPARERR",           0x08, 0x08 },
@@ -111,24 +111,7 @@ ahd_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x04, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRERR_parse_table[] = {
-        { "CLRDSCTMOUT",        0x02, 0x02 },
-        { "CLRILLOPCODE",       0x04, 0x04 },
-        { "CLRSQPARERR",        0x08, 0x08 },
-        { "CLRDPARERR",         0x10, 0x10 },
-        { "CLRMPARERR",         0x20, 0x20 },
-        { "CLRCIOACCESFAIL",    0x40, 0x40 },
-        { "CLRCIOPARERR",       0x80, 0x80 }
-};
-
-int
-ahd_clrerr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CLRERR_parse_table, 7, "CLRERR",
-            0x04, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t HCNTRL_parse_table[] = {
+static const ahd_reg_parse_entry_t HCNTRL_parse_table[] = {
         { "CHIPRST",            0x01, 0x01 },
         { "CHIPRSTACK",         0x01, 0x01 },
         { "INTEN",              0x02, 0x02 },
@@ -160,7 +143,7 @@ ahd_hescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x08, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
+static const ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
         { "ENINT_COALESCE",     0x40, 0x40 },
         { "HOST_TQINPOS",       0x80, 0x80 }
 };
@@ -172,7 +155,7 @@ ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
         { "SEQ_SPLTINT",        0x01, 0x01 },
         { "SEQ_PCIINT",         0x02, 0x02 },
         { "SEQ_SCSIINT",        0x04, 0x04 },
@@ -187,7 +170,7 @@ ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0c, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
         { "CLRSEQ_SPLTINT",     0x01, 0x01 },
         { "CLRSEQ_PCIINT",      0x02, 0x02 },
         { "CLRSEQ_SCSIINT",     0x04, 0x04 },
@@ -230,7 +213,7 @@ ahd_sdscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x14, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
+static const ahd_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
         { "SCB_QSIZE_4",        0x00, 0x0f },
         { "SCB_QSIZE_8",        0x01, 0x0f },
         { "SCB_QSIZE_16",       0x02, 0x0f },
@@ -258,7 +241,7 @@ ahd_qoff_ctlsta_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x16, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t INTCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t INTCTL_parse_table[] = {
         { "SPLTINTEN",          0x01, 0x01 },
         { "SEQINTEN",           0x02, 0x02 },
         { "SCSIINTEN",          0x04, 0x04 },
@@ -276,7 +259,7 @@ ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x18, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
+static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
         { "DIRECTIONEN",        0x01, 0x01 },
         { "FIFOFLUSH",          0x02, 0x02 },
         { "FIFOFLUSHACK",       0x02, 0x02 },
@@ -297,7 +280,7 @@ ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x19, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
+static const ahd_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
         { "CIOPARCKEN",         0x01, 0x01 },
         { "DISABLE_TWATE",      0x02, 0x02 },
         { "EXTREQLCK",          0x10, 0x10 },
@@ -313,7 +296,7 @@ ahd_dscommand0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x19, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
+static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
         { "FIFOEMP",            0x01, 0x01 },
         { "FIFOFULL",           0x02, 0x02 },
         { "DFTHRESH",           0x04, 0x04 },
@@ -330,7 +313,7 @@ ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
+static const ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
         { "LAST_SEG_DONE",      0x01, 0x01 },
         { "LAST_SEG",           0x02, 0x02 },
         { "ODD_SEG",            0x04, 0x04 },
@@ -344,20 +327,7 @@ ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t ARBCTL_parse_table[] = {
-        { "USE_TIME",           0x07, 0x07 },
-        { "RETRY_SWEN",         0x08, 0x08 },
-        { "RESET_HARB",         0x80, 0x80 }
-};
-
-int
-ahd_arbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(ARBCTL_parse_table, 3, "ARBCTL",
-            0x1b, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
+static const ahd_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
         { "LAST_SEG",           0x02, 0x02 },
         { "ODD_SEG",            0x04, 0x04 },
         { "SG_ADDR_MASK",       0xf8, 0xf8 }
@@ -378,20 +348,6 @@ ahd_lqin_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_typeptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "TYPEPTR",
-            0x20, regvalue, cur_col, wrap));
-}
-
-int
-ahd_tagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "TAGPTR",
-            0x21, regvalue, cur_col, wrap));
-}
-
-int
 ahd_lunptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "LUNPTR",
@@ -399,20 +355,6 @@ ahd_lunptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_datalenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DATALENPTR",
-            0x23, regvalue, cur_col, wrap));
-}
-
-int
-ahd_statlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "STATLENPTR",
-            0x24, regvalue, cur_col, wrap));
-}
-
-int
 ahd_cmdlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "CMDLENPTR",
@@ -448,13 +390,6 @@ ahd_qnextptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_idptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "IDPTR",
-            0x2a, regvalue, cur_col, wrap));
-}
-
-int
 ahd_abrtbyteptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "ABRTBYTEPTR",
@@ -468,28 +403,7 @@ ahd_abrtbitptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x2c, regvalue, cur_col, wrap));
 }
 
-int
-ahd_maxcmdbytes_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "MAXCMDBYTES",
-            0x2d, regvalue, cur_col, wrap));
-}
-
-int
-ahd_maxcmd2rcv_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "MAXCMD2RCV",
-            0x2e, regvalue, cur_col, wrap));
-}
-
-int
-ahd_shortthresh_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SHORTTHRESH",
-            0x2f, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t LUNLEN_parse_table[] = {
+static const ahd_reg_parse_entry_t LUNLEN_parse_table[] = {
         { "ILUNLEN",            0x0f, 0x0f },
         { "TLUNLEN",            0xf0, 0xf0 }
 };
@@ -522,49 +436,7 @@ ahd_maxcmdcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x33, regvalue, cur_col, wrap));
 }
 
-int
-ahd_lqrsvd01_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "LQRSVD01",
-            0x34, regvalue, cur_col, wrap));
-}
-
-int
-ahd_lqrsvd16_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "LQRSVD16",
-            0x35, regvalue, cur_col, wrap));
-}
-
-int
-ahd_lqrsvd17_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "LQRSVD17",
-            0x36, regvalue, cur_col, wrap));
-}
-
-int
-ahd_cmdrsvd0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "CMDRSVD0",
-            0x37, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t LQCTL0_parse_table[] = {
-        { "LQ0INITGCLT",        0x03, 0x03 },
-        { "LQ0TARGCLT",         0x0c, 0x0c },
-        { "LQIINITGCLT",        0x30, 0x30 },
-        { "LQITARGCLT",         0xc0, 0xc0 }
-};
-
-int
-ahd_lqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(LQCTL0_parse_table, 4, "LQCTL0",
-            0x38, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t LQCTL1_parse_table[] = {
+static const ahd_reg_parse_entry_t LQCTL1_parse_table[] = {
         { "ABORTPENDING",       0x01, 0x01 },
         { "SINGLECMD",          0x02, 0x02 },
         { "PCI2PCI",            0x04, 0x04 }
@@ -577,23 +449,7 @@ ahd_lqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x38, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSBIST0_parse_table[] = {
-        { "OSBISTRUN",          0x01, 0x01 },
-        { "OSBISTDONE",         0x02, 0x02 },
-        { "OSBISTERR",          0x04, 0x04 },
-        { "GSBISTRUN",          0x10, 0x10 },
-        { "GSBISTDONE",         0x20, 0x20 },
-        { "GSBISTERR",          0x40, 0x40 }
-};
-
-int
-ahd_scsbist0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SCSBIST0_parse_table, 6, "SCSBIST0",
-            0x39, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t LQCTL2_parse_table[] = {
+static const ahd_reg_parse_entry_t LQCTL2_parse_table[] = {
         { "LQOPAUSE",           0x01, 0x01 },
         { "LQOTOIDLE",          0x02, 0x02 },
         { "LQOCONTINUE",        0x04, 0x04 },
@@ -611,20 +467,7 @@ ahd_lqctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x39, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSBIST1_parse_table[] = {
-        { "NTBISTRUN",          0x01, 0x01 },
-        { "NTBISTDONE",         0x02, 0x02 },
-        { "NTBISTERR",          0x04, 0x04 }
-};
-
-int
-ahd_scsbist1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SCSBIST1_parse_table, 3, "SCSBIST1",
-            0x3a, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
         { "SCSIRSTO",           0x01, 0x01 },
         { "FORCEBUSFREE",       0x10, 0x10 },
         { "ENARBO",             0x20, 0x20 },
@@ -639,7 +482,7 @@ ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
         { "ALTSTIM",            0x01, 0x01 },
         { "ENAUTOATNP",         0x02, 0x02 },
         { "MANUALP",            0x0c, 0x0c },
@@ -655,7 +498,7 @@ ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SXFRCTL0_parse_table[] = {
+static const ahd_reg_parse_entry_t SXFRCTL0_parse_table[] = {
         { "SPIOEN",             0x08, 0x08 },
         { "BIOSCANCELEN",       0x10, 0x10 },
         { "DFPEXP",             0x40, 0x40 },
@@ -669,21 +512,7 @@ ahd_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3c, regvalue, cur_col, wrap));
 }
 
-int
-ahd_dlcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DLCOUNT",
-            0x3c, regvalue, cur_col, wrap));
-}
-
-int
-ahd_businitid_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "BUSINITID",
-            0x3c, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SXFRCTL1_parse_table[] = {
+static const ahd_reg_parse_entry_t SXFRCTL1_parse_table[] = {
         { "STPWEN",             0x01, 0x01 },
         { "ACTNEGEN",           0x02, 0x02 },
         { "ENSTIMER",           0x04, 0x04 },
@@ -700,27 +529,7 @@ ahd_sxfrctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3d, regvalue, cur_col, wrap));
 }
 
-int
-ahd_bustargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "BUSTARGID",
-            0x3e, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SXFRCTL2_parse_table[] = {
-        { "ASU",                0x07, 0x07 },
-        { "CMDDMAEN",           0x08, 0x08 },
-        { "AUTORSTDIS",         0x10, 0x10 }
-};
-
-int
-ahd_sxfrctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SXFRCTL2_parse_table, 3, "SXFRCTL2",
-            0x3e, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
         { "CURRFIFO_0",         0x00, 0x03 },
         { "CURRFIFO_1",         0x01, 0x03 },
         { "CURRFIFO_NONE",      0x03, 0x03 },
@@ -736,7 +545,14 @@ ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3f, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSISIGO_parse_table[] = {
+int
+ahd_multargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "MULTARGID",
+            0x40, regvalue, cur_col, wrap));
+}
+
+static const ahd_reg_parse_entry_t SCSISIGO_parse_table[] = {
         { "P_DATAOUT",          0x00, 0xe0 },
         { "P_DATAOUT_DT",       0x20, 0xe0 },
         { "P_DATAIN",           0x40, 0xe0 },
@@ -763,14 +579,7 @@ ahd_scsisigo_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x40, regvalue, cur_col, wrap));
 }
 
-int
-ahd_multargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "MULTARGID",
-            0x40, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
         { "P_DATAOUT",          0x00, 0xe0 },
         { "P_DATAOUT_DT",       0x20, 0xe0 },
         { "P_DATAIN",           0x40, 0xe0 },
@@ -797,7 +606,7 @@ ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x41, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
         { "DATA_OUT_PHASE",     0x01, 0x03 },
         { "DATA_IN_PHASE",      0x02, 0x03 },
         { "DATA_PHASE_MASK",    0x03, 0x03 },
@@ -815,13 +624,6 @@ ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_scsidat0_img_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCSIDAT0_IMG",
-            0x43, regvalue, cur_col, wrap));
-}
-
-int
 ahd_scsidat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SCSIDAT",
@@ -835,7 +637,7 @@ ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x46, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t TARGIDIN_parse_table[] = {
+static const ahd_reg_parse_entry_t TARGIDIN_parse_table[] = {
         { "TARGID",             0x0f, 0x0f },
         { "CLKOUT",             0x80, 0x80 }
 };
@@ -847,7 +649,7 @@ ahd_targidin_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x48, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SELID_parse_table[] = {
+static const ahd_reg_parse_entry_t SELID_parse_table[] = {
         { "ONEBIT",             0x08, 0x08 },
         { "SELID_MASK",         0xf0, 0xf0 }
 };
@@ -859,7 +661,7 @@ ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x49, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
+static const ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
         { "AUTO_MSGOUT_DE",     0x02, 0x02 },
         { "ENDGFORMCHK",        0x04, 0x04 },
         { "BUSFREEREV",         0x10, 0x10 },
@@ -876,7 +678,7 @@ ahd_optionmode_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
         { "SELWIDE",            0x02, 0x02 },
         { "ENAB20",             0x04, 0x04 },
         { "ENAB40",             0x08, 0x08 },
@@ -891,24 +693,7 @@ ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
-        { "CLRARBDO",           0x01, 0x01 },
-        { "CLRSPIORDY",         0x02, 0x02 },
-        { "CLROVERRUN",         0x04, 0x04 },
-        { "CLRIOERR",           0x08, 0x08 },
-        { "CLRSELINGO",         0x10, 0x10 },
-        { "CLRSELDI",           0x20, 0x20 },
-        { "CLRSELDO",           0x40, 0x40 }
-};
-
-int
-ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CLRSINT0_parse_table, 7, "CLRSINT0",
-            0x4b, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
+static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
         { "ARBDO",              0x01, 0x01 },
         { "SPIORDY",            0x02, 0x02 },
         { "OVERRUN",            0x04, 0x04 },
@@ -926,7 +711,7 @@ ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
+static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
         { "ENARBDO",            0x01, 0x01 },
         { "ENSPIORDY",          0x02, 0x02 },
         { "ENOVERRUN",          0x04, 0x04 },
@@ -943,24 +728,24 @@ ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSINT1_parse_table[] = {
-        { "CLRREQINIT",         0x01, 0x01 },
-        { "CLRSTRB2FAST",       0x02, 0x02 },
-        { "CLRSCSIPERR",        0x04, 0x04 },
-        { "CLRBUSFREE",         0x08, 0x08 },
-        { "CLRSCSIRSTI",        0x20, 0x20 },
-        { "CLRATNO",            0x40, 0x40 },
-        { "CLRSELTIMEO",        0x80, 0x80 }
+static const ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
+        { "CLRARBDO",           0x01, 0x01 },
+        { "CLRSPIORDY",         0x02, 0x02 },
+        { "CLROVERRUN",         0x04, 0x04 },
+        { "CLRIOERR",           0x08, 0x08 },
+        { "CLRSELINGO",         0x10, 0x10 },
+        { "CLRSELDI",           0x20, 0x20 },
+        { "CLRSELDO",           0x40, 0x40 }
 };
 
 int
-ahd_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(CLRSINT1_parse_table, 7, "CLRSINT1",
-            0x4c, regvalue, cur_col, wrap));
+        return (ahd_print_register(CLRSINT0_parse_table, 7, "CLRSINT0",
+            0x4b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
+static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
         { "REQINIT",            0x01, 0x01 },
         { "STRB2FAST",          0x02, 0x02 },
         { "SCSIPERR",           0x04, 0x04 },
@@ -978,7 +763,24 @@ ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4c, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRSINT1_parse_table[] = {
+        { "CLRREQINIT",         0x01, 0x01 },
+        { "CLRSTRB2FAST",       0x02, 0x02 },
+        { "CLRSCSIPERR",        0x04, 0x04 },
+        { "CLRBUSFREE",         0x08, 0x08 },
+        { "CLRSCSIRSTI",        0x20, 0x20 },
+        { "CLRATNO",            0x40, 0x40 },
+        { "CLRSELTIMEO",        0x80, 0x80 }
+};
+
+int
+ahd_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(CLRSINT1_parse_table, 7, "CLRSINT1",
+            0x4c, regvalue, cur_col, wrap));
+}
+
+static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
         { "BUSFREE_LQO",        0x40, 0xc0 },
         { "BUSFREE_DFF0",       0x80, 0xc0 },
         { "BUSFREE_DFF1",       0xc0, 0xc0 },
@@ -998,20 +800,7 @@ ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4d, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SIMODE2_parse_table[] = {
-        { "ENDMADONE",          0x01, 0x01 },
-        { "ENSDONE",            0x02, 0x02 },
-        { "ENWIDE_RES",         0x04, 0x04 }
-};
-
-int
-ahd_simode2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SIMODE2_parse_table, 3, "SIMODE2",
-            0x4d, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
         { "CLRDMADONE",         0x01, 0x01 },
         { "CLRSDONE",           0x02, 0x02 },
         { "CLRWIDE_RES",        0x04, 0x04 },
@@ -1025,7 +814,7 @@ ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4d, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
+static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
         { "DTERR",              0x01, 0x01 },
         { "DGFORMERR",          0x02, 0x02 },
         { "CRCERR",             0x04, 0x04 },
@@ -1064,7 +853,7 @@ ahd_lqostate_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x4f, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
+static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
         { "LQIATNCMD",          0x01, 0x01 },
         { "LQIATNLQ",           0x02, 0x02 },
         { "LQIBADLQT",          0x04, 0x04 },
@@ -1080,23 +869,7 @@ ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x50, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRLQIINT0_parse_table[] = {
-        { "CLRLQIATNCMD",       0x01, 0x01 },
-        { "CLRLQIATNLQ",        0x02, 0x02 },
-        { "CLRLQIBADLQT",       0x04, 0x04 },
-        { "CLRLQICRCT2",        0x08, 0x08 },
-        { "CLRLQICRCT1",        0x10, 0x10 },
-        { "CLRLQIATNQAS",       0x20, 0x20 }
-};
-
-int
-ahd_clrlqiint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CLRLQIINT0_parse_table, 6, "CLRLQIINT0",
-            0x50, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t LQIMODE0_parse_table[] = {
+static const ahd_reg_parse_entry_t LQIMODE0_parse_table[] = {
         { "ENLQIATNCMD",        0x01, 0x01 },
         { "ENLQIATNLQ",         0x02, 0x02 },
         { "ENLQIBADLQT",        0x04, 0x04 },
@@ -1112,7 +885,23 @@ ahd_lqimode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x50, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQIMODE1_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRLQIINT0_parse_table[] = {
+        { "CLRLQIATNCMD",       0x01, 0x01 },
+        { "CLRLQIATNLQ",        0x02, 0x02 },
+        { "CLRLQIBADLQT",       0x04, 0x04 },
+        { "CLRLQICRCT2",        0x08, 0x08 },
+        { "CLRLQICRCT1",        0x10, 0x10 },
+        { "CLRLQIATNQAS",       0x20, 0x20 }
+};
+
+int
+ahd_clrlqiint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(CLRLQIINT0_parse_table, 6, "CLRLQIINT0",
+            0x50, regvalue, cur_col, wrap));
+}
+
+static const ahd_reg_parse_entry_t LQIMODE1_parse_table[] = {
         { "ENLQIOVERI_NLQ",     0x01, 0x01 },
         { "ENLQIOVERI_LQ",      0x02, 0x02 },
         { "ENLQIBADLQI",        0x04, 0x04 },
@@ -1130,7 +919,7 @@ ahd_lqimode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x51, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
+static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
         { "LQIOVERI_NLQ",       0x01, 0x01 },
         { "LQIOVERI_LQ",        0x02, 0x02 },
         { "LQIBADLQI",          0x04, 0x04 },
@@ -1148,7 +937,7 @@ ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x51, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRLQIINT1_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRLQIINT1_parse_table[] = {
         { "CLRLQIOVERI_NLQ",    0x01, 0x01 },
         { "CLRLQIOVERI_LQ",     0x02, 0x02 },
         { "CLRLQIBADLQI",       0x04, 0x04 },
@@ -1166,7 +955,7 @@ ahd_clrlqiint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x51, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
+static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
         { "LQIGSAVAIL",         0x01, 0x01 },
         { "LQISTOPCMD",         0x02, 0x02 },
         { "LQISTOPLQ",          0x04, 0x04 },
@@ -1184,7 +973,7 @@ ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x52, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
+static const ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
         { "OSRAMPERR",          0x01, 0x01 },
         { "NTRAMPERR",          0x02, 0x02 }
 };
@@ -1196,7 +985,7 @@ ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x53, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SIMODE3_parse_table[] = {
+static const ahd_reg_parse_entry_t SIMODE3_parse_table[] = {
         { "ENOSRAMPERR",        0x01, 0x01 },
         { "ENNTRAMPERR",        0x02, 0x02 }
 };
@@ -1208,7 +997,7 @@ ahd_simode3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x53, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSINT3_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRSINT3_parse_table[] = {
         { "CLROSRAMPERR",       0x01, 0x01 },
         { "CLRNTRAMPERR",       0x02, 0x02 }
 };
@@ -1220,7 +1009,7 @@ ahd_clrsint3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x53, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
         { "LQOTCRC",            0x01, 0x01 },
         { "LQOATNPKT",          0x02, 0x02 },
         { "LQOATNLQ",           0x04, 0x04 },
@@ -1235,7 +1024,7 @@ ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x54, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRLQOINT0_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRLQOINT0_parse_table[] = {
         { "CLRLQOTCRC",         0x01, 0x01 },
         { "CLRLQOATNPKT",       0x02, 0x02 },
         { "CLRLQOATNLQ",        0x04, 0x04 },
@@ -1250,7 +1039,7 @@ ahd_clrlqoint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x54, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
         { "ENLQOTCRC",          0x01, 0x01 },
         { "ENLQOATNPKT",        0x02, 0x02 },
         { "ENLQOATNLQ",         0x04, 0x04 },
@@ -1265,7 +1054,7 @@ ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x54, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
         { "ENLQOPHACHGINPKT",   0x01, 0x01 },
         { "ENLQOBUSFREE",       0x02, 0x02 },
         { "ENLQOBADQAS",        0x04, 0x04 },
@@ -1280,7 +1069,7 @@ ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x55, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
         { "LQOPHACHGINPKT",     0x01, 0x01 },
         { "LQOBUSFREE",         0x02, 0x02 },
         { "LQOBADQAS",          0x04, 0x04 },
@@ -1295,7 +1084,7 @@ ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x55, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRLQOINT1_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRLQOINT1_parse_table[] = {
         { "CLRLQOPHACHGINPKT",  0x01, 0x01 },
         { "CLRLQOBUSFREE",      0x02, 0x02 },
         { "CLRLQOBADQAS",       0x04, 0x04 },
@@ -1310,7 +1099,7 @@ ahd_clrlqoint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x55, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
         { "LQOSTOP0",           0x01, 0x01 },
         { "LQOPHACHGOUTPKT",    0x02, 0x02 },
         { "LQOWAITFIFO",        0x10, 0x10 },
@@ -1331,7 +1120,7 @@ ahd_os_space_cnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x56, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
+static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
         { "ENREQINIT",          0x01, 0x01 },
         { "ENSTRB2FAST",        0x02, 0x02 },
         { "ENSCSIPERR",         0x04, 0x04 },
@@ -1356,7 +1145,7 @@ ahd_gsfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x58, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
         { "RSTCHN",             0x01, 0x01 },
         { "CLRCHN",             0x02, 0x02 },
         { "CLRSHCNT",           0x04, 0x04 },
@@ -1370,15 +1159,17 @@ ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LQOSCSCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t LQOSCSCTL_parse_table[] = {
         { "LQONOCHKOVER",       0x01, 0x01 },
+        { "LQONOHOLDLACK",      0x02, 0x02 },
+        { "LQOBUSETDLY",        0x40, 0x40 },
         { "LQOH2A_VERSION",     0x80, 0x80 }
 };
 
 int
 ahd_lqoscsctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(LQOSCSCTL_parse_table, 2, "LQOSCSCTL",
+        return (ahd_print_register(LQOSCSCTL_parse_table, 4, "LQOSCSCTL",
             0x5a, regvalue, cur_col, wrap));
 }
 
@@ -1389,7 +1180,7 @@ ahd_nextscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CLRSEQINTSRC_parse_table[] = {
+static const ahd_reg_parse_entry_t CLRSEQINTSRC_parse_table[] = {
         { "CLRCFG4TCMD",        0x01, 0x01 },
         { "CLRCFG4ICMD",        0x02, 0x02 },
         { "CLRCFG4TSTAT",       0x04, 0x04 },
@@ -1406,7 +1197,7 @@ ahd_clrseqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
         { "CFG4TCMD",           0x01, 0x01 },
         { "CFG4ICMD",           0x02, 0x02 },
         { "CFG4TSTAT",          0x04, 0x04 },
@@ -1423,14 +1214,7 @@ ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5b, regvalue, cur_col, wrap));
 }
 
-int
-ahd_currscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "CURRSCB",
-            0x5c, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
         { "ENCFG4TCMD",         0x01, 0x01 },
         { "ENCFG4ICMD",         0x02, 0x02 },
         { "ENCFG4TSTAT",        0x04, 0x04 },
@@ -1447,7 +1231,14 @@ ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5c, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
+int
+ahd_currscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
+{
+        return (ahd_print_register(NULL, 0, "CURRSCB",
+            0x5c, regvalue, cur_col, wrap));
+}
+
+static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
         { "FIFOFREE",           0x01, 0x01 },
         { "DATAINFIFO",         0x02, 0x02 },
         { "DLZERO",             0x04, 0x04 },
@@ -1464,24 +1255,6 @@ ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5d, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CRCCONTROL_parse_table[] = {
-        { "CRCVALCHKEN",        0x40, 0x40 }
-};
-
-int
-ahd_crccontrol_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CRCCONTROL_parse_table, 1, "CRCCONTROL",
-            0x5d, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfftag_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFFTAG",
-            0x5e, regvalue, cur_col, wrap));
-}
-
 int
 ahd_lastscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1489,31 +1262,6 @@ ahd_lastscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5e, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSITEST_parse_table[] = {
-        { "SEL_TXPLL_DEBUG",    0x04, 0x04 },
-        { "CNTRTEST",           0x08, 0x08 }
-};
-
-int
-ahd_scsitest_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SCSITEST_parse_table, 2, "SCSITEST",
-            0x5e, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t IOPDNCTL_parse_table[] = {
-        { "PDN_DIFFSENSE",      0x01, 0x01 },
-        { "PDN_IDIST",          0x04, 0x04 },
-        { "DISABLE_OE",         0x80, 0x80 }
-};
-
-int
-ahd_iopdnctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(IOPDNCTL_parse_table, 3, "IOPDNCTL",
-            0x5f, regvalue, cur_col, wrap));
-}
-
 int
 ahd_shaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1529,13 +1277,6 @@ ahd_negoaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_dgrpcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DGRPCRCI",
-            0x60, regvalue, cur_col, wrap));
-}
-
-int
 ahd_negperiod_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "NEGPERIOD",
@@ -1543,20 +1284,13 @@ ahd_negperiod_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_packcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "PACKCRCI",
-            0x62, regvalue, cur_col, wrap));
-}
-
-int
 ahd_negoffset_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "NEGOFFSET",
             0x62, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t NEGPPROPTS_parse_table[] = {
+static const ahd_reg_parse_entry_t NEGPPROPTS_parse_table[] = {
         { "PPROPT_IUT",         0x01, 0x01 },
         { "PPROPT_DT",          0x02, 0x02 },
         { "PPROPT_QAS",         0x04, 0x04 },
@@ -1570,7 +1304,7 @@ ahd_negppropts_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x63, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t NEGCONOPTS_parse_table[] = {
+static const ahd_reg_parse_entry_t NEGCONOPTS_parse_table[] = {
         { "WIDEXFER",           0x01, 0x01 },
         { "ENAUTOATNO",         0x02, 0x02 },
         { "ENAUTOATNI",         0x04, 0x04 },
@@ -1601,20 +1335,21 @@ ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x66, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
         { "LSTSGCLRDIS",        0x01, 0x01 },
         { "SHVALIDSTDIS",       0x02, 0x02 },
         { "DFFACTCLR",          0x04, 0x04 },
         { "SDONEMSKDIS",        0x08, 0x08 },
         { "WIDERESEN",          0x10, 0x10 },
         { "CURRFIFODEF",        0x20, 0x20 },
-        { "STSELSKIDDIS",       0x40, 0x40 }
+        { "STSELSKIDDIS",       0x40, 0x40 },
+        { "BIDICHKDIS",         0x80, 0x80 }
 };
 
 int
 ahd_scschkn_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(SCSCHKN_parse_table, 7, "SCSCHKN",
+        return (ahd_print_register(SCSCHKN_parse_table, 8, "SCSCHKN",
             0x66, regvalue, cur_col, wrap));
 }
 
@@ -1625,23 +1360,6 @@ ahd_iownid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x67, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t PLL960CTL0_parse_table[] = {
-        { "PLL_ENFBM",          0x01, 0x01 },
-        { "PLL_DLPF",           0x02, 0x02 },
-        { "PLL_ENLPF",          0x04, 0x04 },
-        { "PLL_ENLUD",          0x08, 0x08 },
-        { "PLL_NS",             0x30, 0x30 },
-        { "PLL_PWDN",           0x40, 0x40 },
-        { "PLL_VCOSEL",         0x80, 0x80 }
-};
-
-int
-ahd_pll960ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(PLL960CTL0_parse_table, 7, "PLL960CTL0",
-            0x68, regvalue, cur_col, wrap));
-}
-
 int
 ahd_shcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1656,33 +1374,6 @@ ahd_townid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x69, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t PLL960CTL1_parse_table[] = {
-        { "PLL_RST",            0x01, 0x01 },
-        { "PLL_CNTCLR",         0x40, 0x40 },
-        { "PLL_CNTEN",          0x80, 0x80 }
-};
-
-int
-ahd_pll960ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(PLL960CTL1_parse_table, 3, "PLL960CTL1",
-            0x69, regvalue, cur_col, wrap));
-}
-
-int
-ahd_pll960cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "PLL960CNT0",
-            0x6a, regvalue, cur_col, wrap));
-}
-
-int
-ahd_xsig_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "XSIG",
-            0x6a, regvalue, cur_col, wrap));
-}
-
 int
 ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1690,57 +1381,6 @@ ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x6b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t PLL400CTL0_parse_table[] = {
-        { "PLL_ENFBM",          0x01, 0x01 },
-        { "PLL_DLPF",           0x02, 0x02 },
-        { "PLL_ENLPF",          0x04, 0x04 },
-        { "PLL_ENLUD",          0x08, 0x08 },
-        { "PLL_NS",             0x30, 0x30 },
-        { "PLL_PWDN",           0x40, 0x40 },
-        { "PLL_VCOSEL",         0x80, 0x80 }
-};
-
-int
-ahd_pll400ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(PLL400CTL0_parse_table, 7, "PLL400CTL0",
-            0x6c, regvalue, cur_col, wrap));
-}
-
-int
-ahd_fairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "FAIRNESS",
-            0x6c, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t PLL400CTL1_parse_table[] = {
-        { "PLL_RST",            0x01, 0x01 },
-        { "PLL_CNTCLR",         0x40, 0x40 },
-        { "PLL_CNTEN",          0x80, 0x80 }
-};
-
-int
-ahd_pll400ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(PLL400CTL1_parse_table, 3, "PLL400CTL1",
-            0x6d, regvalue, cur_col, wrap));
-}
-
-int
-ahd_unfairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "UNFAIRNESS",
-            0x6e, regvalue, cur_col, wrap));
-}
-
-int
-ahd_pll400cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "PLL400CNT0",
-            0x6e, regvalue, cur_col, wrap));
-}
-
 int
 ahd_haddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1748,31 +1388,6 @@ ahd_haddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x70, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t PLLDELAY_parse_table[] = {
-        { "SPLIT_DROP_REQ",     0x80, 0x80 }
-};
-
-int
-ahd_plldelay_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(PLLDELAY_parse_table, 1, "PLLDELAY",
-            0x70, regvalue, cur_col, wrap));
-}
-
-int
-ahd_hodmaadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "HODMAADR",
-            0x70, regvalue, cur_col, wrap));
-}
-
-int
-ahd_hodmacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "HODMACNT",
-            0x78, regvalue, cur_col, wrap));
-}
-
 int
 ahd_hcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -1781,10 +1396,10 @@ ahd_hcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_hodmaen_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "HODMAEN",
-            0x7a, regvalue, cur_col, wrap));
+        return (ahd_print_register(NULL, 0, "SGHADDR",
+            0x7c, regvalue, cur_col, wrap));
 }
 
 int
@@ -1795,10 +1410,10 @@ ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SGHADDR",
-            0x7c, regvalue, cur_col, wrap));
+        return (ahd_print_register(NULL, 0, "SGHCNT",
+            0x84, regvalue, cur_col, wrap));
 }
 
 int
@@ -1808,14 +1423,7 @@ ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x84, regvalue, cur_col, wrap));
 }
 
-int
-ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SGHCNT",
-            0x84, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DFF_THRSH_parse_table[] = {
+static const ahd_reg_parse_entry_t DFF_THRSH_parse_table[] = {
         { "WR_DFTHRSH_MIN",     0x00, 0x70 },
         { "RD_DFTHRSH_MIN",     0x00, 0x07 },
         { "RD_DFTHRSH_25",      0x01, 0x07 },
@@ -1843,209 +1451,7 @@ ahd_dff_thrsh_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x88, regvalue, cur_col, wrap));
 }
 
-int
-ahd_romaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "ROMADDR",
-            0x8a, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t ROMCNTRL_parse_table[] = {
-        { "RDY",                0x01, 0x01 },
-        { "REPEAT",             0x02, 0x02 },
-        { "ROMSPD",             0x18, 0x18 },
-        { "ROMOP",              0xe0, 0xe0 }
-};
-
-int
-ahd_romcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(ROMCNTRL_parse_table, 4, "ROMCNTRL",
-            0x8d, regvalue, cur_col, wrap));
-}
-
-int
-ahd_romdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "ROMDATA",
-            0x8e, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCRXMSG0_parse_table[] = {
-        { "CFNUM",              0x07, 0x07 },
-        { "CDNUM",              0xf8, 0xf8 }
-};
-
-int
-ahd_cmcrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCRXMSG0_parse_table, 2, "CMCRXMSG0",
-            0x90, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t ROENABLE_parse_table[] = {
-        { "DCH0ROEN",           0x01, 0x01 },
-        { "DCH1ROEN",           0x02, 0x02 },
-        { "SGROEN",             0x04, 0x04 },
-        { "CMCROEN",            0x08, 0x08 },
-        { "OVLYROEN",           0x10, 0x10 },
-        { "MSIROEN",            0x20, 0x20 }
-};
-
-int
-ahd_roenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(ROENABLE_parse_table, 6, "ROENABLE",
-            0x90, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYRXMSG0_parse_table[] = {
-        { "CFNUM",              0x07, 0x07 },
-        { "CDNUM",              0xf8, 0xf8 }
-};
-
-int
-ahd_ovlyrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG0_parse_table, 2, "OVLYRXMSG0",
-            0x90, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHRXMSG0_parse_table[] = {
-        { "CFNUM",              0x07, 0x07 },
-        { "CDNUM",              0xf8, 0xf8 }
-};
-
-int
-ahd_dchrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DCHRXMSG0_parse_table, 2, "DCHRXMSG0",
-            0x90, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYRXMSG1_parse_table[] = {
-        { "CBNUM",              0xff, 0xff }
-};
-
-int
-ahd_ovlyrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG1_parse_table, 1, "OVLYRXMSG1",
-            0x91, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t NSENABLE_parse_table[] = {
-        { "DCH0NSEN",           0x01, 0x01 },
-        { "DCH1NSEN",           0x02, 0x02 },
-        { "SGNSEN",             0x04, 0x04 },
-        { "CMCNSEN",            0x08, 0x08 },
-        { "OVLYNSEN",           0x10, 0x10 },
-        { "MSINSEN",            0x20, 0x20 }
-};
-
-int
-ahd_nsenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NSENABLE_parse_table, 6, "NSENABLE",
-            0x91, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCRXMSG1_parse_table[] = {
-        { "CBNUM",              0xff, 0xff }
-};
-
-int
-ahd_cmcrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCRXMSG1_parse_table, 1, "CMCRXMSG1",
-            0x91, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHRXMSG1_parse_table[] = {
-        { "CBNUM",              0xff, 0xff }
-};
-
-int
-ahd_dchrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DCHRXMSG1_parse_table, 1, "DCHRXMSG1",
-            0x91, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHRXMSG2_parse_table[] = {
-        { "MINDEX",             0xff, 0xff }
-};
-
-int
-ahd_dchrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DCHRXMSG2_parse_table, 1, "DCHRXMSG2",
-            0x92, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCRXMSG2_parse_table[] = {
-        { "MINDEX",             0xff, 0xff }
-};
-
-int
-ahd_cmcrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCRXMSG2_parse_table, 1, "CMCRXMSG2",
-            0x92, regvalue, cur_col, wrap));
-}
-
-int
-ahd_ost_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "OST",
-            0x92, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYRXMSG2_parse_table[] = {
-        { "MINDEX",             0xff, 0xff }
-};
-
-int
-ahd_ovlyrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG2_parse_table, 1, "OVLYRXMSG2",
-            0x92, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHRXMSG3_parse_table[] = {
-        { "MCLASS",             0x0f, 0x0f }
-};
-
-int
-ahd_dchrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DCHRXMSG3_parse_table, 1, "DCHRXMSG3",
-            0x93, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYRXMSG3_parse_table[] = {
-        { "MCLASS",             0x0f, 0x0f }
-};
-
-int
-ahd_ovlyrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYRXMSG3_parse_table, 1, "OVLYRXMSG3",
-            0x93, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCRXMSG3_parse_table[] = {
-        { "MCLASS",             0x0f, 0x0f }
-};
-
-int
-ahd_cmcrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCRXMSG3_parse_table, 1, "CMCRXMSG3",
-            0x93, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t PCIXCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t PCIXCTL_parse_table[] = {
         { "CMPABCDIS",          0x01, 0x01 },
         { "TSCSERREN",          0x02, 0x02 },
         { "SRSPDPEEN",          0x04, 0x04 },
@@ -2062,46 +1468,7 @@ ahd_pcixctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x93, regvalue, cur_col, wrap));
 }
 
-int
-ahd_ovlyseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "OVLYSEQBCNT",
-            0x94, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dchseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DCHSEQBCNT",
-            0x94, regvalue, cur_col, wrap));
-}
-
-int
-ahd_cmcseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "CMCSEQBCNT",
-            0x94, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCSPLTSTAT0_parse_table[] = {
-        { "RXSPLTRSP",          0x01, 0x01 },
-        { "RXSCEMSG",           0x02, 0x02 },
-        { "RXOVRUN",            0x04, 0x04 },
-        { "CNTNOTCMPLT",        0x08, 0x08 },
-        { "SCDATBUCKET",        0x10, 0x10 },
-        { "SCADERR",            0x20, 0x20 },
-        { "SCBCERR",            0x40, 0x40 },
-        { "STAETERM",           0x80, 0x80 }
-};
-
-int
-ahd_cmcspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCSPLTSTAT0_parse_table, 8, "CMCSPLTSTAT0",
-            0x96, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
+static const ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
         { "RXSPLTRSP",          0x01, 0x01 },
         { "RXSCEMSG",           0x02, 0x02 },
         { "RXOVRUN",            0x04, 0x04 },
@@ -2119,47 +1486,7 @@ ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x96, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
-        { "RXSPLTRSP",          0x01, 0x01 },
-        { "RXSCEMSG",           0x02, 0x02 },
-        { "RXOVRUN",            0x04, 0x04 },
-        { "CNTNOTCMPLT",        0x08, 0x08 },
-        { "SCDATBUCKET",        0x10, 0x10 },
-        { "SCADERR",            0x20, 0x20 },
-        { "SCBCERR",            0x40, 0x40 },
-        { "STAETERM",           0x80, 0x80 }
-};
-
-int
-ahd_ovlyspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYSPLTSTAT0_parse_table, 8, "OVLYSPLTSTAT0",
-            0x96, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCSPLTSTAT1_parse_table[] = {
-        { "RXDATABUCKET",       0x01, 0x01 }
-};
-
-int
-ahd_cmcspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCSPLTSTAT1_parse_table, 1, "CMCSPLTSTAT1",
-            0x97, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYSPLTSTAT1_parse_table[] = {
-        { "RXDATABUCKET",       0x01, 0x01 }
-};
-
-int
-ahd_ovlyspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYSPLTSTAT1_parse_table, 1, "OVLYSPLTSTAT1",
-            0x97, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
+static const ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
         { "RXDATABUCKET",       0x01, 0x01 }
 };
 
@@ -2170,139 +1497,7 @@ ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x97, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SGRXMSG0_parse_table[] = {
-        { "CFNUM",              0x07, 0x07 },
-        { "CDNUM",              0xf8, 0xf8 }
-};
-
-int
-ahd_sgrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SGRXMSG0_parse_table, 2, "SGRXMSG0",
-            0x98, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTADR0_parse_table[] = {
-        { "LOWER_ADDR",         0x7f, 0x7f }
-};
-
-int
-ahd_slvspltoutadr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTADR0_parse_table, 1, "SLVSPLTOUTADR0",
-            0x98, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SGRXMSG1_parse_table[] = {
-        { "CBNUM",              0xff, 0xff }
-};
-
-int
-ahd_sgrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SGRXMSG1_parse_table, 1, "SGRXMSG1",
-            0x99, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTADR1_parse_table[] = {
-        { "REQ_FNUM",           0x07, 0x07 },
-        { "REQ_DNUM",           0xf8, 0xf8 }
-};
-
-int
-ahd_slvspltoutadr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTADR1_parse_table, 2, "SLVSPLTOUTADR1",
-            0x99, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SGRXMSG2_parse_table[] = {
-        { "MINDEX",             0xff, 0xff }
-};
-
-int
-ahd_sgrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SGRXMSG2_parse_table, 1, "SGRXMSG2",
-            0x9a, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTADR2_parse_table[] = {
-        { "REQ_BNUM",           0xff, 0xff }
-};
-
-int
-ahd_slvspltoutadr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTADR2_parse_table, 1, "SLVSPLTOUTADR2",
-            0x9a, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SGRXMSG3_parse_table[] = {
-        { "MCLASS",             0x0f, 0x0f }
-};
-
-int
-ahd_sgrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SGRXMSG3_parse_table, 1, "SGRXMSG3",
-            0x9b, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTADR3_parse_table[] = {
-        { "RLXORD",             0x10, 0x10 },
-        { "TAG_NUM",            0x1f, 0x1f }
-};
-
-int
-ahd_slvspltoutadr3_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTADR3_parse_table, 2, "SLVSPLTOUTADR3",
-            0x9b, regvalue, cur_col, wrap));
-}
-
-int
-ahd_sgseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SGSEQBCNT",
-            0x9c, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTATTR0_parse_table[] = {
-        { "LOWER_BCNT",         0xff, 0xff }
-};
-
-int
-ahd_slvspltoutattr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTATTR0_parse_table, 1, "SLVSPLTOUTATTR0",
-            0x9c, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTATTR1_parse_table[] = {
-        { "CMPLT_FNUM",         0x07, 0x07 },
-        { "CMPLT_DNUM",         0xf8, 0xf8 }
-};
-
-int
-ahd_slvspltoutattr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTATTR1_parse_table, 2, "SLVSPLTOUTATTR1",
-            0x9d, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SLVSPLTOUTATTR2_parse_table[] = {
-        { "CMPLT_BNUM",         0xff, 0xff }
-};
-
-int
-ahd_slvspltoutattr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SLVSPLTOUTATTR2_parse_table, 1, "SLVSPLTOUTATTR2",
-            0x9e, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SGSPLTSTAT0_parse_table[] = {
+static const ahd_reg_parse_entry_t SGSPLTSTAT0_parse_table[] = {
         { "RXSPLTRSP",          0x01, 0x01 },
         { "RXSCEMSG",           0x02, 0x02 },
         { "RXOVRUN",            0x04, 0x04 },
@@ -2320,7 +1515,7 @@ ahd_sgspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x9e, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
+static const ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
         { "RXDATABUCKET",       0x01, 0x01 }
 };
 
@@ -2331,19 +1526,7 @@ ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x9f, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SFUNCT_parse_table[] = {
-        { "TEST_NUM",           0x0f, 0x0f },
-        { "TEST_GROUP",         0xf0, 0xf0 }
-};
-
-int
-ahd_sfunct_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SFUNCT_parse_table, 2, "SFUNCT",
-            0x9f, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DF0PCISTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t DF0PCISTAT_parse_table[] = {
         { "DPR",                0x01, 0x01 },
         { "TWATERR",            0x02, 0x02 },
         { "RDPERR",             0x04, 0x04 },
@@ -2368,83 +1551,6 @@ ahd_reg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xa0, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DF1PCISTAT_parse_table[] = {
-        { "DPR",                0x01, 0x01 },
-        { "TWATERR",            0x02, 0x02 },
-        { "RDPERR",             0x04, 0x04 },
-        { "SCAAPERR",           0x08, 0x08 },
-        { "RTA",                0x10, 0x10 },
-        { "RMA",                0x20, 0x20 },
-        { "SSE",                0x40, 0x40 },
-        { "DPE",                0x80, 0x80 }
-};
-
-int
-ahd_df1pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DF1PCISTAT_parse_table, 8, "DF1PCISTAT",
-            0xa1, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SGPCISTAT_parse_table[] = {
-        { "DPR",                0x01, 0x01 },
-        { "RDPERR",             0x04, 0x04 },
-        { "SCAAPERR",           0x08, 0x08 },
-        { "RTA",                0x10, 0x10 },
-        { "RMA",                0x20, 0x20 },
-        { "SSE",                0x40, 0x40 },
-        { "DPE",                0x80, 0x80 }
-};
-
-int
-ahd_sgpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SGPCISTAT_parse_table, 7, "SGPCISTAT",
-            0xa2, regvalue, cur_col, wrap));
-}
-
-int
-ahd_reg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "REG1",
-            0xa2, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CMCPCISTAT_parse_table[] = {
-        { "DPR",                0x01, 0x01 },
-        { "TWATERR",            0x02, 0x02 },
-        { "RDPERR",             0x04, 0x04 },
-        { "SCAAPERR",           0x08, 0x08 },
-        { "RTA",                0x10, 0x10 },
-        { "RMA",                0x20, 0x20 },
-        { "SSE",                0x40, 0x40 },
-        { "DPE",                0x80, 0x80 }
-};
-
-int
-ahd_cmcpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMCPCISTAT_parse_table, 8, "CMCPCISTAT",
-            0xa3, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t OVLYPCISTAT_parse_table[] = {
-        { "DPR",                0x01, 0x01 },
-        { "RDPERR",             0x04, 0x04 },
-        { "SCAAPERR",           0x08, 0x08 },
-        { "RTA",                0x10, 0x10 },
-        { "RMA",                0x20, 0x20 },
-        { "SSE",                0x40, 0x40 },
-        { "DPE",                0x80, 0x80 }
-};
-
-int
-ahd_ovlypcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(OVLYPCISTAT_parse_table, 7, "OVLYPCISTAT",
-            0xa4, regvalue, cur_col, wrap));
-}
-
 int
 ahd_reg_isr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -2452,7 +1558,7 @@ ahd_reg_isr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xa4, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
+static const ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
         { "SEGS_AVAIL",         0x01, 0x01 },
         { "LOADING_NEEDED",     0x02, 0x02 },
         { "FETCH_INPROG",       0x04, 0x04 }
@@ -2465,23 +1571,7 @@ ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xa6, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t MSIPCISTAT_parse_table[] = {
-        { "DPR",                0x01, 0x01 },
-        { "TWATERR",            0x02, 0x02 },
-        { "CLRPENDMSI",         0x08, 0x08 },
-        { "RTA",                0x10, 0x10 },
-        { "RMA",                0x20, 0x20 },
-        { "SSE",                0x40, 0x40 }
-};
-
-int
-ahd_msipcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(MSIPCISTAT_parse_table, 6, "MSIPCISTAT",
-            0xa6, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t TARGPCISTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t TARGPCISTAT_parse_table[] = {
         { "TWATERR",            0x02, 0x02 },
         { "STA",                0x08, 0x08 },
         { "SSE",                0x40, 0x40 },
@@ -2496,27 +1586,13 @@ ahd_targpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_data_count_odd_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DATA_COUNT_ODD",
-            0xa7, regvalue, cur_col, wrap));
-}
-
-int
 ahd_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SCBPTR",
             0xa8, regvalue, cur_col, wrap));
 }
 
-int
-ahd_ccscbacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "CCSCBACNT",
-            0xab, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SCBAUTOPTR_parse_table[] = {
+static const ahd_reg_parse_entry_t SCBAUTOPTR_parse_table[] = {
         { "SCBPTR_OFF",         0x07, 0x07 },
         { "SCBPTR_ADDR",        0x38, 0x38 },
         { "AUSCBPTR_EN",        0x80, 0x80 }
@@ -2537,36 +1613,13 @@ ahd_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_ccscbadr_bk_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "CCSCBADR_BK",
-            0xac, regvalue, cur_col, wrap));
-}
-
-int
 ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "CCSCBADDR",
             0xac, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CMC_RAMBIST_parse_table[] = {
-        { "CMC_BUFFER_BIST_EN", 0x01, 0x01 },
-        { "CMC_BUFFER_BIST_FAIL",0x02, 0x02 },
-        { "SG_BIST_EN",         0x10, 0x10 },
-        { "SG_BIST_FAIL",       0x20, 0x20 },
-        { "SCBRAMBIST_FAIL",    0x40, 0x40 },
-        { "SG_ELEMENT_SIZE",    0x80, 0x80 }
-};
-
-int
-ahd_cmc_rambist_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(CMC_RAMBIST_parse_table, 6, "CMC_RAMBIST",
-            0xad, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
         { "CCSCBRESET",         0x01, 0x01 },
         { "CCSCBDIR",           0x04, 0x04 },
         { "CCSCBEN",            0x08, 0x08 },
@@ -2582,7 +1635,7 @@ ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xad, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
         { "CCSGRESET",          0x01, 0x01 },
         { "SG_FETCH_REQ",       0x02, 0x02 },
         { "CCSGENACK",          0x08, 0x08 },
@@ -2606,13 +1659,6 @@ ahd_ccsgram_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_flexadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "FLEXADR",
-            0xb0, regvalue, cur_col, wrap));
-}
-
-int
 ahd_ccscbram_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "CCSCBRAM",
@@ -2620,39 +1666,13 @@ ahd_ccscbram_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_flexcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "FLEXCNT",
-            0xb3, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t FLEXDMASTAT_parse_table[] = {
-        { "FLEXDMADONE",        0x01, 0x01 },
-        { "FLEXDMAERR",         0x02, 0x02 }
-};
-
-int
-ahd_flexdmastat_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(FLEXDMASTAT_parse_table, 2, "FLEXDMASTAT",
-            0xb5, regvalue, cur_col, wrap));
-}
-
-int
-ahd_flexdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "FLEXDATA",
-            0xb6, regvalue, cur_col, wrap));
-}
-
-int
 ahd_brddat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "BRDDAT",
             0xb8, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t BRDCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t BRDCTL_parse_table[] = {
         { "BRDSTB",             0x01, 0x01 },
         { "BRDRW",              0x02, 0x02 },
         { "BRDEN",              0x04, 0x04 },
@@ -2682,7 +1702,7 @@ ahd_seedat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xbc, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEECTL_parse_table[] = {
+static const ahd_reg_parse_entry_t SEECTL_parse_table[] = {
         { "SEEOP_ERAL",         0x40, 0x70 },
         { "SEEOP_WRITE",        0x50, 0x70 },
         { "SEEOP_READ",         0x60, 0x70 },
@@ -2702,7 +1722,7 @@ ahd_seectl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xbe, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEESTAT_parse_table[] = {
+static const ahd_reg_parse_entry_t SEESTAT_parse_table[] = {
         { "SEESTART",           0x01, 0x01 },
         { "SEEBUSY",            0x02, 0x02 },
         { "SEEARBACK",          0x04, 0x04 },
@@ -2718,34 +1738,7 @@ ahd_seestat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xbe, regvalue, cur_col, wrap));
 }
 
-int
-ahd_scbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCBCNT",
-            0xbf, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfwaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFWADDR",
-            0xc0, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DSPFLTRCTL_parse_table[] = {
-        { "DSPFCNTSEL",         0x0f, 0x0f },
-        { "EDGESENSE",          0x10, 0x10 },
-        { "FLTRDISABLE",        0x20, 0x20 }
-};
-
-int
-ahd_dspfltrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DSPFLTRCTL_parse_table, 3, "DSPFLTRCTL",
-            0xc0, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DSPDATACTL_parse_table[] = {
+static const ahd_reg_parse_entry_t DSPDATACTL_parse_table[] = {
         { "XMITOFFSTDIS",       0x02, 0x02 },
         { "RCVROFFSTDIS",       0x04, 0x04 },
         { "DESQDIS",            0x10, 0x10 },
@@ -2760,44 +1753,13 @@ ahd_dspdatactl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_dfraddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFRADDR",
-            0xc2, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DSPREQCTL_parse_table[] = {
-        { "MANREQDLY",          0x3f, 0x3f },
-        { "MANREQCTL",          0xc0, 0xc0 }
-};
-
-int
-ahd_dspreqctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DSPREQCTL_parse_table, 2, "DSPREQCTL",
-            0xc2, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DSPACKCTL_parse_table[] = {
-        { "MANACKDLY",          0x3f, 0x3f },
-        { "MANACKCTL",          0xc0, 0xc0 }
-};
-
-int
-ahd_dspackctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DSPACKCTL_parse_table, 2, "DSPACKCTL",
-            0xc3, regvalue, cur_col, wrap));
-}
-
-int
 ahd_dfdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "DFDAT",
             0xc4, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DSPSELECT_parse_table[] = {
+static const ahd_reg_parse_entry_t DSPSELECT_parse_table[] = {
         { "DSPSEL",             0x1f, 0x1f },
         { "AUTOINCEN",          0x80, 0x80 }
 };
@@ -2809,7 +1771,7 @@ ahd_dspselect_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xc4, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t WRTBIASCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t WRTBIASCTL_parse_table[] = {
         { "XMITMANVAL",         0x3f, 0x3f },
         { "AUTOXBCDIS",         0x80, 0x80 }
 };
@@ -2821,91 +1783,7 @@ ahd_wrtbiasctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xc5, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t RCVRBIOSCTL_parse_table[] = {
-        { "RCVRMANVAL",         0x3f, 0x3f },
-        { "AUTORBCDIS",         0x80, 0x80 }
-};
-
-int
-ahd_rcvrbiosctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(RCVRBIOSCTL_parse_table, 2, "RCVRBIOSCTL",
-            0xc6, regvalue, cur_col, wrap));
-}
-
-int
-ahd_wrtbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "WRTBIASCALC",
-            0xc7, regvalue, cur_col, wrap));
-}
-
-int
-ahd_rcvrbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "RCVRBIASCALC",
-            0xc8, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfptrs_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFPTRS",
-            0xc8, regvalue, cur_col, wrap));
-}
-
-int
-ahd_skewcalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SKEWCALC",
-            0xc9, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfbkptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFBKPTR",
-            0xc9, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t DFDBCTL_parse_table[] = {
-        { "DFF_RAMBIST_EN",     0x01, 0x01 },
-        { "DFF_RAMBIST_DONE",   0x02, 0x02 },
-        { "DFF_RAMBIST_FAIL",   0x04, 0x04 },
-        { "DFF_DIR_ERR",        0x08, 0x08 },
-        { "DFF_CIO_RD_RDY",     0x10, 0x10 },
-        { "DFF_CIO_WR_RDY",     0x20, 0x20 }
-};
-
-int
-ahd_dfdbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(DFDBCTL_parse_table, 6, "DFDBCTL",
-            0xcb, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfscnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFSCNT",
-            0xcc, regvalue, cur_col, wrap));
-}
-
-int
-ahd_dfbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "DFBCNT",
-            0xce, regvalue, cur_col, wrap));
-}
-
-int
-ahd_ovlyaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "OVLYADDR",
-            0xd4, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
         { "LOADRAM",            0x01, 0x01 },
         { "SEQRESET",           0x02, 0x02 },
         { "STEP",               0x04, 0x04 },
@@ -2923,21 +1801,7 @@ ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xd6, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQCTL1_parse_table[] = {
-        { "RAMBIST_EN",         0x01, 0x01 },
-        { "RAMBIST_FAIL",       0x02, 0x02 },
-        { "RAMBIST_DONE",       0x04, 0x04 },
-        { "OVRLAY_DATA_CHK",    0x08, 0x08 }
-};
-
-int
-ahd_seqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(SEQCTL1_parse_table, 4, "SEQCTL1",
-            0xd7, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t FLAGS_parse_table[] = {
+static const ahd_reg_parse_entry_t FLAGS_parse_table[] = {
         { "CARRY",              0x01, 0x01 },
         { "ZERO",               0x02, 0x02 }
 };
@@ -2949,7 +1813,7 @@ ahd_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xd8, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
         { "IRET",               0x01, 0x01 },
         { "INTMASK1",           0x02, 0x02 },
         { "INTMASK2",           0x04, 0x04 },
@@ -3002,24 +1866,6 @@ ahd_dindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_brkaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "BRKADDR0",
-            0xe6, regvalue, cur_col, wrap));
-}
-
-static ahd_reg_parse_entry_t BRKADDR1_parse_table[] = {
-        { "BRKDIS",             0x80, 0x80 }
-};
-
-int
-ahd_brkaddr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(BRKADDR1_parse_table, 1, "BRKADDR1",
-            0xe6, regvalue, cur_col, wrap));
-}
-
-int
 ahd_allones_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "ALLONES",
@@ -3055,13 +1901,6 @@ ahd_dindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_function1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "FUNCTION1",
-            0xf0, regvalue, cur_col, wrap));
-}
-
-int
 ahd_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "STACK",
@@ -3083,13 +1922,6 @@ ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_lastaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "LASTADDR",
-            0xf6, regvalue, cur_col, wrap));
-}
-
-int
 ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
@@ -3111,23 +1943,16 @@ ahd_accum_save_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_waiting_scb_tails_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "WAITING_SCB_TAILS",
-            0x100, regvalue, cur_col, wrap));
-}
-
-int
-ahd_ahd_pci_config_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "AHD_PCI_CONFIG_BASE",
+        return (ahd_print_register(NULL, 0, "SRAM_BASE",
             0x100, regvalue, cur_col, wrap));
 }
 
 int
-ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_waiting_scb_tails_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SRAM_BASE",
+        return (ahd_print_register(NULL, 0, "WAITING_SCB_TAILS",
             0x100, regvalue, cur_col, wrap));
 }
 
@@ -3215,7 +2040,7 @@ ahd_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x137, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
+static const ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
         { "FIFORESET",          0x01, 0x01 },
         { "FIFOFLUSH",          0x02, 0x02 },
         { "DIRECTION",          0x04, 0x04 },
@@ -3235,7 +2060,7 @@ ahd_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x138, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
         { "NO_DISCONNECT",      0x01, 0x01 },
         { "SPHASE_PENDING",     0x02, 0x02 },
         { "DPHASE_PENDING",     0x04, 0x04 },
@@ -3268,7 +2093,7 @@ ahd_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x13b, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
+static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
         { "P_DATAOUT",          0x00, 0xe0 },
         { "P_DATAOUT_DT",       0x20, 0xe0 },
         { "P_DATAIN",           0x40, 0xe0 },
@@ -3326,7 +2151,7 @@ ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x144, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t ARG_1_parse_table[] = {
+static const ahd_reg_parse_entry_t ARG_1_parse_table[] = {
         { "CONT_MSG_LOOP_TARG", 0x02, 0x02 },
         { "CONT_MSG_LOOP_READ", 0x03, 0x03 },
         { "CONT_MSG_LOOP_WRITE",0x04, 0x04 },
@@ -3358,7 +2183,7 @@ ahd_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x14a, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
+static const ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
         { "ALTSTIM",            0x01, 0x01 },
         { "ENAUTOATNP",         0x02, 0x02 },
         { "MANUALP",            0x0c, 0x0c },
@@ -3381,7 +2206,7 @@ ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x14c, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
+static const ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
         { "PENDING_MK_MESSAGE", 0x01, 0x01 },
         { "TARGET_MSG_PENDING", 0x02, 0x02 },
         { "SELECTOUT_QFROZEN",  0x04, 0x04 }
@@ -3465,20 +2290,20 @@ ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_scb_residual_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SCB_BASE",
+        return (ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT",
             0x180, regvalue, cur_col, wrap));
 }
 
 int
-ahd_scb_residual_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
+ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
-        return (ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT",
+        return (ahd_print_register(NULL, 0, "SCB_BASE",
             0x180, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_RESIDUAL_SGPTR_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_RESIDUAL_SGPTR_parse_table[] = {
         { "SG_LIST_NULL",       0x01, 0x01 },
         { "SG_OVERRUN_RESID",   0x02, 0x02 },
         { "SG_ADDR_MASK",       0xf8, 0xf8 }
@@ -3499,27 +2324,6 @@ ahd_scb_scsi_status_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_scb_target_phases_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCB_TARGET_PHASES",
-            0x189, regvalue, cur_col, wrap));
-}
-
-int
-ahd_scb_target_data_dir_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCB_TARGET_DATA_DIR",
-            0x18a, regvalue, cur_col, wrap));
-}
-
-int
-ahd_scb_target_itag_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCB_TARGET_ITAG",
-            0x18b, regvalue, cur_col, wrap));
-}
-
-int
 ahd_scb_sense_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SCB_SENSE_BUSADDR",
@@ -3533,7 +2337,7 @@ ahd_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x190, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
         { "SCB_TAG_TYPE",       0x03, 0x03 },
         { "DISCONNECTED",       0x04, 0x04 },
         { "STATUS_RCVD",        0x08, 0x08 },
@@ -3550,7 +2354,7 @@ ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x192, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
         { "OID",                0x0f, 0x0f },
         { "TID",                0xf0, 0xf0 }
 };
@@ -3562,7 +2366,7 @@ ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x193, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_LUN_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_LUN_parse_table[] = {
         { "LID",                0xff, 0xff }
 };
 
@@ -3573,7 +2377,7 @@ ahd_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x194, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_TASK_ATTRIBUTE_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_TASK_ATTRIBUTE_parse_table[] = {
         { "SCB_XFERLEN_ODD",    0x01, 0x01 }
 };
 
@@ -3584,7 +2388,7 @@ ahd_scb_task_attribute_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x195, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_CDB_LEN_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_CDB_LEN_parse_table[] = {
         { "SCB_CDB_LEN_PTR",    0x80, 0x80 }
 };
 
@@ -3609,7 +2413,7 @@ ahd_scb_dataptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x198, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
         { "SG_HIGH_ADDR_BITS",  0x7f, 0x7f },
         { "SG_LAST_SEG",        0x80, 0x80 }
 };
@@ -3621,7 +2425,7 @@ ahd_scb_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1a0, regvalue, cur_col, wrap));
 }
 
-static ahd_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
+static const ahd_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
         { "SG_LIST_NULL",       0x01, 0x01 },
         { "SG_FULL_RESID",      0x02, 0x02 },
         { "SG_STATUS_VALID",    0x04, 0x04 }
@@ -3656,13 +2460,6 @@ ahd_scb_next2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahd_scb_spare_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahd_print_register(NULL, 0, "SCB_SPARE",
-            0x1b0, regvalue, cur_col, wrap));
-}
-
-int
 ahd_scb_disconnected_lists_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahd_print_register(NULL, 0, "SCB_DISCONNECTED_LISTS",
diff --git a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
index 11bed07e90b7..4b51e232392f 100644
--- a/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
+++ b/drivers/scsi/aic7xxx/aic79xx_seq.h_shipped
@@ -5,7 +5,7 @@
  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
  */
-static uint8_t seqprog[] = {
+static const uint8_t seqprog[] = {
         0xff, 0x02, 0x06, 0x78,
         0x00, 0xea, 0x6e, 0x59,
         0x01, 0xea, 0x04, 0x30,
@@ -1027,7 +1027,7 @@ ahd_patch0_func(struct ahd_softc *ahd)
         return (0);
 }
 
-static struct patch {
+static const struct patch {
         ahd_patch_func_t                *patch_func;
         uint32_t                 begin          :10,
                                  skip_instr     :10,
@@ -1166,7 +1166,7 @@ static struct patch {
         { ahd_patch23_func, 815, 11, 1 }
 };
 
-static struct cs {
+static const struct cs {
         uint16_t        begin;
         uint16_t        end;
 } critical_sections[] = {
diff --git a/drivers/scsi/aic7xxx/aic7xxx.h b/drivers/scsi/aic7xxx/aic7xxx.h
index c0344e617651..e4e651cca3e4 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.h
+++ b/drivers/scsi/aic7xxx/aic7xxx.h
@@ -736,7 +736,7 @@ struct ahc_syncrate {
 #define         ST_SXFR    0x010        /* Rate Single Transition Only */
 #define         DT_SXFR    0x040        /* Rate Double Transition Only */
         uint8_t period; /* Period to send to SCSI target */
-        char *rate;
+        const char *rate;
 };
 
 /* Safe and valid period for async negotiations. */
@@ -1114,7 +1114,7 @@ typedef int (ahc_device_setup_t)(struct ahc_softc *);
 struct ahc_pci_identity {
         uint64_t                 full_id;
         uint64_t                 id_mask;
-        char                    *name;
+        const char              *name;
         ahc_device_setup_t      *setup;
 };
 
@@ -1133,15 +1133,11 @@ extern const int ahc_num_aic7770_devs;
 
 /*************************** Function Declarations ****************************/
 /******************************************************************************/
-u_int                   ahc_index_busy_tcl(struct ahc_softc *ahc, u_int tcl);
-void                    ahc_unbusy_tcl(struct ahc_softc *ahc, u_int tcl);
-void                    ahc_busy_tcl(struct ahc_softc *ahc,
-                                     u_int tcl, u_int busyid);
 
 /***************************** PCI Front End *********************************/
-struct ahc_pci_identity *ahc_find_pci_device(ahc_dev_softc_t);
+const struct ahc_pci_identity   *ahc_find_pci_device(ahc_dev_softc_t);
 int                      ahc_pci_config(struct ahc_softc *,
-                                        struct ahc_pci_identity *);
+                                        const struct ahc_pci_identity *);
 int                      ahc_pci_test_register_access(struct ahc_softc *);
 #ifdef CONFIG_PM
 void                     ahc_pci_resume(struct ahc_softc *ahc);
@@ -1155,9 +1151,6 @@ int			 aic7770_config(struct ahc_softc *ahc,
 
 /************************** SCB and SCB queue management **********************/
 int             ahc_probe_scbs(struct ahc_softc *);
-void            ahc_run_untagged_queues(struct ahc_softc *ahc);
-void            ahc_run_untagged_queue(struct ahc_softc *ahc,
-                                       struct scb_tailq *queue);
 void            ahc_qinfifo_requeue_tail(struct ahc_softc *ahc,
                                          struct scb *scb);
 int             ahc_match_scb(struct ahc_softc *ahc, struct scb *scb,
@@ -1178,22 +1171,8 @@ int			 ahc_resume(struct ahc_softc *ahc);
 #endif
 void                     ahc_set_unit(struct ahc_softc *, int);
 void                     ahc_set_name(struct ahc_softc *, char *);
-void                     ahc_alloc_scbs(struct ahc_softc *ahc);
 void                     ahc_free(struct ahc_softc *ahc);
 int                      ahc_reset(struct ahc_softc *ahc, int reinit);
-void                     ahc_shutdown(void *arg);
-
-/*************************** Interrupt Services *******************************/
-void                    ahc_clear_intstat(struct ahc_softc *ahc);
-void                    ahc_run_qoutfifo(struct ahc_softc *ahc);
-#ifdef AHC_TARGET_MODE
-void                    ahc_run_tqinfifo(struct ahc_softc *ahc, int paused);
-#endif
-void                    ahc_handle_brkadrint(struct ahc_softc *ahc);
-void                    ahc_handle_seqint(struct ahc_softc *ahc, u_int intstat);
-void                    ahc_handle_scsiint(struct ahc_softc *ahc,
-                                           u_int intstat);
-void                    ahc_clear_critical_section(struct ahc_softc *ahc);
 
 /***************************** Error Recovery *********************************/
 typedef enum {
@@ -1214,36 +1193,19 @@ int			ahc_search_disc_list(struct ahc_softc *ahc, int target,
                                              char channel, int lun, u_int tag,
                                              int stop_on_first, int remove,
                                              int save_state);
-void                    ahc_freeze_devq(struct ahc_softc *ahc, struct scb *scb);
 int                     ahc_reset_channel(struct ahc_softc *ahc, char channel,
                                           int initiate_reset);
-int                     ahc_abort_scbs(struct ahc_softc *ahc, int target,
-                                       char channel, int lun, u_int tag,
-                                       role_t role, uint32_t status);
-void                    ahc_restart(struct ahc_softc *ahc);
-void                    ahc_calc_residual(struct ahc_softc *ahc,
-                                          struct scb *scb);
+
 /*************************** Utility Functions ********************************/
-struct ahc_phase_table_entry*
-                        ahc_lookup_phase_entry(int phase);
 void                    ahc_compile_devinfo(struct ahc_devinfo *devinfo,
                                             u_int our_id, u_int target,
                                             u_int lun, char channel,
                                             role_t role);
 /************************** Transfer Negotiation ******************************/
-struct ahc_syncrate*    ahc_find_syncrate(struct ahc_softc *ahc, u_int *period,
+const struct ahc_syncrate*      ahc_find_syncrate(struct ahc_softc *ahc, u_int *period,
                                           u_int *ppr_options, u_int maxsync);
 u_int                   ahc_find_period(struct ahc_softc *ahc,
                                         u_int scsirate, u_int maxsync);
-void                    ahc_validate_offset(struct ahc_softc *ahc,
-                                            struct ahc_initiator_tinfo *tinfo,
-                                            struct ahc_syncrate *syncrate,
-                                            u_int *offset, int wide,
-                                            role_t role);
-void                    ahc_validate_width(struct ahc_softc *ahc,
-                                           struct ahc_initiator_tinfo *tinfo,
-                                           u_int *bus_width,
-                                           role_t role);
 /*
  * Negotiation types.  These are used to qualify if we should renegotiate
  * even if our goal and current transport parameters are identical.
@@ -1263,7 +1225,7 @@ void			ahc_set_width(struct ahc_softc *ahc,
                                       u_int width, u_int type, int paused);
 void                    ahc_set_syncrate(struct ahc_softc *ahc,
                                          struct ahc_devinfo *devinfo,
-                                         struct ahc_syncrate *syncrate,
+                                         const struct ahc_syncrate *syncrate,
                                          u_int period, u_int offset,
                                          u_int ppr_options,
                                          u_int type, int paused);
@@ -1305,11 +1267,10 @@ extern uint32_t ahc_debug;
 #define AHC_SHOW_MASKED_ERRORS  0x1000
 #define AHC_DEBUG_SEQUENCER     0x2000
 #endif
-void                    ahc_print_scb(struct scb *scb);
 void                    ahc_print_devinfo(struct ahc_softc *ahc,
                                           struct ahc_devinfo *dev);
 void                    ahc_dump_card_state(struct ahc_softc *ahc);
-int                     ahc_print_register(ahc_reg_parse_entry_t *table,
+int                     ahc_print_register(const ahc_reg_parse_entry_t *table,
                                            u_int num_entries,
                                            const char *name,
                                            u_int address,
diff --git a/drivers/scsi/aic7xxx/aic7xxx.reg b/drivers/scsi/aic7xxx/aic7xxx.reg
index e196d83b93c7..0d2f763c3427 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.reg
+++ b/drivers/scsi/aic7xxx/aic7xxx.reg
@@ -238,6 +238,7 @@ register SXFRCTL2 {
 register OPTIONMODE {
         address                 0x008
         access_mode RW
+        count           2
         field   AUTORATEEN              0x80
         field   AUTOACKEN               0x40
         field   ATNMGMNTEN              0x20
@@ -254,6 +255,7 @@ register TARGCRCCNT {
         address                 0x00a
         size    2
         access_mode RW
+        count           2
 }
 
 /*
@@ -344,6 +346,7 @@ register SSTAT2 {
 register SSTAT3 {
         address                 0x00e
         access_mode RO
+        count           2
         mask    SCSICNT         0xf0
         mask    OFFCNT          0x0f
         mask    U2OFFCNT        0x7f
@@ -367,6 +370,7 @@ register SCSIID_ULTRA2 {
 register SIMODE0 {
         address                 0x010
         access_mode RW
+        count           2
         field   ENSELDO         0x40
         field   ENSELDI         0x20
         field   ENSELINGO       0x10
@@ -429,6 +433,7 @@ register SHADDR {
 register SELTIMER {
         address                 0x018
         access_mode RW
+        count           1
         field   STAGE6          0x20
         field   STAGE5          0x10
         field   STAGE4          0x08
@@ -467,6 +472,7 @@ register TARGID {
         address                 0x01b
         size                    2
         access_mode RW
+        count           14
 }
 
 /*
@@ -480,6 +486,7 @@ register TARGID {
 register SPIOCAP {
         address                 0x01b
         access_mode RW
+        count           10
         field   SOFT1           0x80
         field   SOFT0           0x40
         field   SOFTCMDEN       0x20    
@@ -492,6 +499,7 @@ register SPIOCAP {
 
 register BRDCTL {
         address                 0x01d
+        count           11
         field   BRDDAT7         0x80
         field   BRDDAT6         0x40
         field   BRDDAT5         0x20
@@ -534,6 +542,7 @@ register BRDCTL	{
  */
 register SEECTL {
         address                 0x01e
+        count           11
         field   EXTARBACK       0x80
         field   EXTARBREQ       0x40
         field   SEEMS           0x20
@@ -570,6 +579,7 @@ register SBLKCTL {
 register SEQCTL {
         address                 0x060
         access_mode RW
+        count           15
         field   PERRORDIS       0x80
         field   PAUSEDIS        0x40
         field   FAILDIS         0x20
@@ -590,6 +600,7 @@ register SEQCTL {
 register SEQRAM {
         address                 0x061
         access_mode RW
+        count           2
 }
 
 /*
@@ -604,6 +615,7 @@ register SEQADDR0 {
 register SEQADDR1 {
         address                 0x063
         access_mode RW
+        count           8
         mask    SEQADDR1_MASK   0x01
 }
 
@@ -649,6 +661,7 @@ register NONE {
 register FLAGS {
         address                 0x06b
         access_mode RO
+        count           18
         field   ZERO            0x02
         field   CARRY           0x01
 }
@@ -671,6 +684,7 @@ register FUNCTION1 {
 register STACK {
         address                 0x06f
         access_mode RO
+        count           5
 }
 
 const   STACK_SIZE      4
@@ -692,6 +706,7 @@ register BCTL {
 register DSCOMMAND0 {
         address                 0x084
         access_mode RW
+        count           7
         field   CACHETHEN       0x80    /* Cache Threshold enable */
         field   DPARCKEN        0x40    /* Data Parity Check Enable */
         field   MPARCKEN        0x20    /* Memory Parity Check Enable */
@@ -717,6 +732,7 @@ register DSCOMMAND1 {
 register BUSTIME {
         address                 0x085
         access_mode RW
+        count           2
         mask    BOFF            0xf0
         mask    BON             0x0f
 }
@@ -727,6 +743,7 @@ register BUSTIME {
 register BUSSPD {
         address                 0x086
         access_mode RW
+        count           2
         mask    DFTHRSH         0xc0
         mask    STBOFF          0x38
         mask    STBON           0x07
@@ -737,6 +754,7 @@ register BUSSPD {
 /* aic7850/55/60/70/80/95 only */
 register DSPCISTATUS {
         address                 0x086
+        count           4
         mask    DFTHRSH_100     0xc0
 }
 
@@ -758,6 +776,7 @@ const	SEQ_MAILBOX_SHIFT	0
 register HCNTRL {
         address                 0x087
         access_mode RW
+        count           14
         field   POWRDN          0x40
         field   SWINT           0x10
         field   IRQMS           0x08
@@ -869,6 +888,7 @@ register INTSTAT {
 register ERROR {
         address                 0x092
         access_mode RO
+        count           26
         field   CIOPARERR       0x80    /* Ultra2 only */
         field   PCIERRSTAT      0x40    /* PCI only */
         field   MPARERR         0x20    /* PCI only */
@@ -885,6 +905,7 @@ register ERROR {
 register CLRINT {
         address                 0x092
         access_mode WO
+        count           24
         field   CLRPARERR       0x10    /* PCI only */
         field   CLRBRKADRINT    0x08
         field   CLRSCSIINT      0x04
@@ -943,6 +964,7 @@ register DFDAT {
 register SCBCNT {
         address                 0x09a
         access_mode RW
+        count           1
         field   SCBAUTO         0x80
         mask    SCBCNT_MASK     0x1f
 }
@@ -954,6 +976,7 @@ register SCBCNT {
 register QINFIFO {
         address                 0x09b
         access_mode RW
+        count           12
 }
 
 /*
@@ -972,11 +995,13 @@ register QINCNT	{
 register QOUTFIFO {
         address                 0x09d
         access_mode WO
+        count           7
 }
 
 register CRCCONTROL1 {
         address                 0x09d
         access_mode RW
+        count           3
         field   CRCONSEEN               0x80
         field   CRCVALCHKEN             0x40
         field   CRCENDCHKEN             0x20
@@ -1013,6 +1038,7 @@ register SCSIPHASE {
 register SFUNCT {
         address                 0x09f
         access_mode RW
+        count       4
         field   ALT_MODE        0x80
 }
 
@@ -1095,6 +1121,7 @@ scb {
         }
         SCB_SCSIOFFSET {
                 size    1
+                count   1
         }
         SCB_NEXT {
                 size    1
@@ -1118,6 +1145,7 @@ const	SG_SIZEOF	0x08		/* sizeof(struct ahc_dma) */
 register SEECTL_2840 {
         address                 0x0c0
         access_mode RW
+        count           2
         field   CS_2840         0x04
         field   CK_2840         0x02
         field   DO_2840         0x01
@@ -1126,6 +1154,7 @@ register SEECTL_2840 {
 register STATUS_2840 {
         address                 0x0c1
         access_mode RW
+        count           4
         field   EEPROM_TF       0x80
         mask    BIOS_SEL        0x60
         mask    ADSEL           0x1e
@@ -1161,6 +1190,7 @@ register CCSGCTL {
 
 register CCSCBCNT {
         address                 0xEF
+        count           1
 }
 
 register CCSCBCTL {
@@ -1187,6 +1217,7 @@ register CCSCBRAM {
 register SCBBADDR {
         address                 0x0F0
         access_mode RW
+        count           3
 }
 
 register CCSCBPTR {
@@ -1195,6 +1226,7 @@ register CCSCBPTR {
 
 register HNSCB_QOFF {
         address                 0x0F4
+        count           4
 }
 
 register SNSCB_QOFF {
@@ -1234,6 +1266,7 @@ register DFF_THRSH {
         mask    WR_DFTHRSH_85   0x50
         mask    WR_DFTHRSH_90   0x60
         mask    WR_DFTHRSH_MAX  0x70
+        count   4
 }
 
 register SG_CACHE_PRE {
@@ -1287,6 +1320,7 @@ scratch_ram {
         ULTRA_ENB {
                 alias           CMDSIZE_TABLE
                 size            2
+                count           2
         }
         /*
          * Bit vector of targets that have disconnection disabled as set by
@@ -1296,6 +1330,7 @@ scratch_ram {
          */
         DISC_DSB {
                 size            2
+                count           6
         }
         CMDSIZE_TABLE_TAIL {
                 size            4
@@ -1323,6 +1358,7 @@ scratch_ram {
         /* Parameters for DMA Logic */
         DMAPARAMS {
                 size            1
+                count           12
                 field   PRELOADEN       0x80
                 field   WIDEODD         0x40
                 field   SCSIEN          0x20
@@ -1436,11 +1472,12 @@ scratch_ram {
         KERNEL_TQINPOS {
                 size            1
         }
-        TQINPOS {                
+        TQINPOS {
                 size            1
         }
         ARG_1 {
                 size            1
+                count           1
                 mask    SEND_MSG                0x80
                 mask    SEND_SENSE              0x40
                 mask    SEND_REJ                0x20
@@ -1495,6 +1532,7 @@ scratch_ram {
                 size    1
                 field   HA_274_EXTENDED_TRANS   0x01
                 alias   INITIATOR_TAG
+                count           1
         }
 
         SEQ_FLAGS2 {
@@ -1518,6 +1556,7 @@ scratch_ram {
          */
         SCSICONF {
                 size            1
+                count           12
                 field   TERM_ENB        0x80
                 field   RESET_SCSI      0x40
                 field   ENSPCHK         0x20
@@ -1527,16 +1566,19 @@ scratch_ram {
         INTDEF {
                 address         0x05c
                 size            1
+                count           1
                 field   EDGE_TRIG       0x80
                 mask    VECTOR          0x0f
         }
         HOSTCONF {
                 address         0x05d
                 size            1
+                count           1
         }
         HA_274_BIOSCTRL {
                 address         0x05f
                 size            1
+                count           1
                 mask    BIOSMODE                0x30
                 mask    BIOSDISABLED            0x30    
                 field   CHANNEL_B_PRIMARY       0x08
@@ -1552,6 +1594,7 @@ scratch_ram {
          */
         TARG_OFFSET {
                 size            16
+                count           1
         }
 }
 
diff --git a/drivers/scsi/aic7xxx/aic7xxx_93cx6.c b/drivers/scsi/aic7xxx/aic7xxx_93cx6.c
index 3cb07e114e89..dd11999b77b6 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_93cx6.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_93cx6.c
@@ -84,16 +84,16 @@ struct seeprom_cmd {
 };
 
 /* Short opcodes for the c46 */
-static struct seeprom_cmd seeprom_ewen = {9, {1, 0, 0, 1, 1, 0, 0, 0, 0}};
-static struct seeprom_cmd seeprom_ewds = {9, {1, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const struct seeprom_cmd seeprom_ewen = {9, {1, 0, 0, 1, 1, 0, 0, 0, 0}};
+static const struct seeprom_cmd seeprom_ewds = {9, {1, 0, 0, 0, 0, 0, 0, 0, 0}};
 
 /* Long opcodes for the C56/C66 */
-static struct seeprom_cmd seeprom_long_ewen = {11, {1, 0, 0, 1, 1, 0, 0, 0, 0}};
-static struct seeprom_cmd seeprom_long_ewds = {11, {1, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const struct seeprom_cmd seeprom_long_ewen = {11, {1, 0, 0, 1, 1, 0, 0, 0, 0}};
+static const struct seeprom_cmd seeprom_long_ewds = {11, {1, 0, 0, 0, 0, 0, 0, 0, 0}};
 
 /* Common opcodes */
-static struct seeprom_cmd seeprom_write = {3, {1, 0, 1}};
-static struct seeprom_cmd seeprom_read  = {3, {1, 1, 0}};
+static const struct seeprom_cmd seeprom_write = {3, {1, 0, 1}};
+static const struct seeprom_cmd seeprom_read  = {3, {1, 1, 0}};
 
 /*
  * Wait for the SEERDY to go high; about 800 ns.
@@ -108,7 +108,7 @@ static struct seeprom_cmd seeprom_read  = {3, {1, 1, 0}};
  * Send a START condition and the given command
  */
 static void
-send_seeprom_cmd(struct seeprom_descriptor *sd, struct seeprom_cmd *cmd)
+send_seeprom_cmd(struct seeprom_descriptor *sd, const struct seeprom_cmd *cmd)
 {
         uint8_t temp;
         int i = 0;
@@ -227,7 +227,7 @@ int
 ahc_write_seeprom(struct seeprom_descriptor *sd, uint16_t *buf,
                   u_int start_addr, u_int count)
 {
-        struct seeprom_cmd *ewen, *ewds;
+        const struct seeprom_cmd *ewen, *ewds;
         uint16_t v;
         uint8_t temp;
         int i, k;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_core.c b/drivers/scsi/aic7xxx/aic7xxx_core.c
index 64e62ce59c15..0ae2b4605d09 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_core.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_core.c
@@ -51,8 +51,7 @@
 #endif
 
 /***************************** Lookup Tables **********************************/
-char *ahc_chip_names[] =
-{
+static const char *const ahc_chip_names[] = {
         "NONE",
         "aic7770",
         "aic7850",
@@ -75,10 +74,10 @@ static const u_int num_chip_names = ARRAY_SIZE(ahc_chip_names);
  */
 struct ahc_hard_error_entry {
         uint8_t errno;
-        char *errmesg;
+        const char *errmesg;
 };
 
-static struct ahc_hard_error_entry ahc_hard_errors[] = {
+static const struct ahc_hard_error_entry ahc_hard_errors[] = {
         { ILLHADDR,     "Illegal Host Access" },
         { ILLSADDR,     "Illegal Sequencer Address referrenced" },
         { ILLOPCODE,    "Illegal Opcode in sequencer program" },
@@ -90,7 +89,7 @@ static struct ahc_hard_error_entry ahc_hard_errors[] = {
 };
 static const u_int num_errors = ARRAY_SIZE(ahc_hard_errors);
 
-static struct ahc_phase_table_entry ahc_phase_table[] =
+static const struct ahc_phase_table_entry ahc_phase_table[] =
 {
         { P_DATAOUT,    MSG_NOOP,               "in Data-out phase"     },
         { P_DATAIN,     MSG_INITIATOR_DET_ERR,  "in Data-in phase"      },
@@ -115,7 +114,7 @@ static const u_int num_phases = ARRAY_SIZE(ahc_phase_table) - 1;
  * Provides a mapping of tranfer periods in ns to the proper value to
  * stick in the scsixfer reg.
  */
-static struct ahc_syncrate ahc_syncrates[] =
+static const struct ahc_syncrate ahc_syncrates[] =
 {
       /* ultra2    fast/ultra  period     rate */
         { 0x42,      0x000,      9,      "80.0" },
@@ -148,7 +147,7 @@ static struct ahc_tmode_tstate*
 static void             ahc_free_tstate(struct ahc_softc *ahc,
                                         u_int scsi_id, char channel, int force);
 #endif
-static struct ahc_syncrate*
+static const struct ahc_syncrate*
                         ahc_devlimited_syncrate(struct ahc_softc *ahc,
                                                 struct ahc_initiator_tinfo *,
                                                 u_int *period,
@@ -204,9 +203,9 @@ static void		ahc_setup_target_msgin(struct ahc_softc *ahc,
 #endif
 
 static bus_dmamap_callback_t    ahc_dmamap_cb; 
-static void                     ahc_build_free_scb_list(struct ahc_softc *ahc);
-static int                      ahc_init_scbdata(struct ahc_softc *ahc);
-static void                     ahc_fini_scbdata(struct ahc_softc *ahc);
+static void             ahc_build_free_scb_list(struct ahc_softc *ahc);
+static int              ahc_init_scbdata(struct ahc_softc *ahc);
+static void             ahc_fini_scbdata(struct ahc_softc *ahc);
 static void             ahc_qinfifo_requeue(struct ahc_softc *ahc,
                                             struct scb *prev_scb,
                                             struct scb *scb);
@@ -222,7 +221,7 @@ static void		ahc_dumpseq(struct ahc_softc *ahc);
 #endif
 static int              ahc_loadseq(struct ahc_softc *ahc);
 static int              ahc_check_patch(struct ahc_softc *ahc,
-                                        struct patch **start_patch,
+                                        const struct patch **start_patch,
                                         u_int start_instr, u_int *skip_addr);
 static void             ahc_download_instr(struct ahc_softc *ahc,
                                            u_int instrptr, uint8_t *dconsts);
@@ -237,11 +236,582 @@ static void		ahc_update_scsiid(struct ahc_softc *ahc,
 static int              ahc_handle_target_cmd(struct ahc_softc *ahc,
                                               struct target_cmd *cmd);
 #endif
+
+static u_int            ahc_index_busy_tcl(struct ahc_softc *ahc, u_int tcl);
+static void             ahc_unbusy_tcl(struct ahc_softc *ahc, u_int tcl);
+static void             ahc_busy_tcl(struct ahc_softc *ahc,
+                                     u_int tcl, u_int busyid);
+
+/************************** SCB and SCB queue management **********************/
+static void             ahc_run_untagged_queues(struct ahc_softc *ahc);
+static void             ahc_run_untagged_queue(struct ahc_softc *ahc,
+                                               struct scb_tailq *queue);
+
+/****************************** Initialization ********************************/
+static void              ahc_alloc_scbs(struct ahc_softc *ahc);
+static void              ahc_shutdown(void *arg);
+
+/*************************** Interrupt Services *******************************/
+static void             ahc_clear_intstat(struct ahc_softc *ahc);
+static void             ahc_run_qoutfifo(struct ahc_softc *ahc);
+#ifdef AHC_TARGET_MODE
+static void             ahc_run_tqinfifo(struct ahc_softc *ahc, int paused);
+#endif
+static void             ahc_handle_brkadrint(struct ahc_softc *ahc);
+static void             ahc_handle_seqint(struct ahc_softc *ahc, u_int intstat);
+static void             ahc_handle_scsiint(struct ahc_softc *ahc,
+                                           u_int intstat);
+static void             ahc_clear_critical_section(struct ahc_softc *ahc);
+
+/***************************** Error Recovery *********************************/
+static void             ahc_freeze_devq(struct ahc_softc *ahc, struct scb *scb);
+static int              ahc_abort_scbs(struct ahc_softc *ahc, int target,
+                                       char channel, int lun, u_int tag,
+                                       role_t role, uint32_t status);
+static void             ahc_calc_residual(struct ahc_softc *ahc,
+                                          struct scb *scb);
+
+/*********************** Untagged Transaction Routines ************************/
+static inline void      ahc_freeze_untagged_queues(struct ahc_softc *ahc);
+static inline void      ahc_release_untagged_queues(struct ahc_softc *ahc);
+
+/*
+ * Block our completion routine from starting the next untagged
+ * transaction for this target or target lun.
+ */
+static inline void
+ahc_freeze_untagged_queues(struct ahc_softc *ahc)
+{
+        if ((ahc->flags & AHC_SCB_BTT) == 0)
+                ahc->untagged_queue_lock++;
+}
+
+/*
+ * Allow the next untagged transaction for this target or target lun
+ * to be executed.  We use a counting semaphore to allow the lock
+ * to be acquired recursively.  Once the count drops to zero, the
+ * transaction queues will be run.
+ */
+static inline void
+ahc_release_untagged_queues(struct ahc_softc *ahc)
+{
+        if ((ahc->flags & AHC_SCB_BTT) == 0) {
+                ahc->untagged_queue_lock--;
+                if (ahc->untagged_queue_lock == 0)
+                        ahc_run_untagged_queues(ahc);
+        }
+}
+
 /************************* Sequencer Execution Control ************************/
 /*
- * Restart the sequencer program from address zero
+ * Work around any chip bugs related to halting sequencer execution.
+ * On Ultra2 controllers, we must clear the CIOBUS stretch signal by
+ * reading a register that will set this signal and deassert it.
+ * Without this workaround, if the chip is paused, by an interrupt or
+ * manual pause while accessing scb ram, accesses to certain registers
+ * will hang the system (infinite pci retries).
+ */
+static void
+ahc_pause_bug_fix(struct ahc_softc *ahc)
+{
+        if ((ahc->features & AHC_ULTRA2) != 0)
+                (void)ahc_inb(ahc, CCSCBCTL);
+}
+
+/*
+ * Determine whether the sequencer has halted code execution.
+ * Returns non-zero status if the sequencer is stopped.
+ */
+int
+ahc_is_paused(struct ahc_softc *ahc)
+{
+        return ((ahc_inb(ahc, HCNTRL) & PAUSE) != 0);
+}
+
+/*
+ * Request that the sequencer stop and wait, indefinitely, for it
+ * to stop.  The sequencer will only acknowledge that it is paused
+ * once it has reached an instruction boundary and PAUSEDIS is
+ * cleared in the SEQCTL register.  The sequencer may use PAUSEDIS
+ * for critical sections.
+ */
+void
+ahc_pause(struct ahc_softc *ahc)
+{
+        ahc_outb(ahc, HCNTRL, ahc->pause);
+
+        /*
+         * Since the sequencer can disable pausing in a critical section, we
+         * must loop until it actually stops.
+         */
+        while (ahc_is_paused(ahc) == 0)
+                ;
+
+        ahc_pause_bug_fix(ahc);
+}
+
+/*
+ * Allow the sequencer to continue program execution.
+ * We check here to ensure that no additional interrupt
+ * sources that would cause the sequencer to halt have been
+ * asserted.  If, for example, a SCSI bus reset is detected
+ * while we are fielding a different, pausing, interrupt type,
+ * we don't want to release the sequencer before going back
+ * into our interrupt handler and dealing with this new
+ * condition.
+ */
+void
+ahc_unpause(struct ahc_softc *ahc)
+{
+        if ((ahc_inb(ahc, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) == 0)
+                ahc_outb(ahc, HCNTRL, ahc->unpause);
+}
+
+/************************** Memory mapping routines ***************************/
+static struct ahc_dma_seg *
+ahc_sg_bus_to_virt(struct scb *scb, uint32_t sg_busaddr)
+{
+        int sg_index;
+
+        sg_index = (sg_busaddr - scb->sg_list_phys)/sizeof(struct ahc_dma_seg);
+        /* sg_list_phys points to entry 1, not 0 */
+        sg_index++;
+
+        return (&scb->sg_list[sg_index]);
+}
+
+static uint32_t
+ahc_sg_virt_to_bus(struct scb *scb, struct ahc_dma_seg *sg)
+{
+        int sg_index;
+
+        /* sg_list_phys points to entry 1, not 0 */
+        sg_index = sg - &scb->sg_list[1];
+
+        return (scb->sg_list_phys + (sg_index * sizeof(*scb->sg_list)));
+}
+
+static uint32_t
+ahc_hscb_busaddr(struct ahc_softc *ahc, u_int index)
+{
+        return (ahc->scb_data->hscb_busaddr
+                + (sizeof(struct hardware_scb) * index));
+}
+
+static void
+ahc_sync_scb(struct ahc_softc *ahc, struct scb *scb, int op)
+{
+        ahc_dmamap_sync(ahc, ahc->scb_data->hscb_dmat,
+                        ahc->scb_data->hscb_dmamap,
+                        /*offset*/(scb->hscb - ahc->hscbs) * sizeof(*scb->hscb),
+                        /*len*/sizeof(*scb->hscb), op);
+}
+
+void
+ahc_sync_sglist(struct ahc_softc *ahc, struct scb *scb, int op)
+{
+        if (scb->sg_count == 0)
+                return;
+
+        ahc_dmamap_sync(ahc, ahc->scb_data->sg_dmat, scb->sg_map->sg_dmamap,
+                        /*offset*/(scb->sg_list - scb->sg_map->sg_vaddr)
+                                * sizeof(struct ahc_dma_seg),
+                        /*len*/sizeof(struct ahc_dma_seg) * scb->sg_count, op);
+}
+
+#ifdef AHC_TARGET_MODE
+static uint32_t
+ahc_targetcmd_offset(struct ahc_softc *ahc, u_int index)
+{
+        return (((uint8_t *)&ahc->targetcmds[index]) - ahc->qoutfifo);
+}
+#endif
+
+/*********************** Miscelaneous Support Functions ***********************/
+/*
+ * Determine whether the sequencer reported a residual
+ * for this SCB/transaction.
+ */
+static void
+ahc_update_residual(struct ahc_softc *ahc, struct scb *scb)
+{
+        uint32_t sgptr;
+
+        sgptr = ahc_le32toh(scb->hscb->sgptr);
+        if ((sgptr & SG_RESID_VALID) != 0)
+                ahc_calc_residual(ahc, scb);
+}
+
+/*
+ * Return pointers to the transfer negotiation information
+ * for the specified our_id/remote_id pair.
+ */
+struct ahc_initiator_tinfo *
+ahc_fetch_transinfo(struct ahc_softc *ahc, char channel, u_int our_id,
+                    u_int remote_id, struct ahc_tmode_tstate **tstate)
+{
+        /*
+         * Transfer data structures are stored from the perspective
+         * of the target role.  Since the parameters for a connection
+         * in the initiator role to a given target are the same as
+         * when the roles are reversed, we pretend we are the target.
+         */
+        if (channel == 'B')
+                our_id += 8;
+        *tstate = ahc->enabled_targets[our_id];
+        return (&(*tstate)->transinfo[remote_id]);
+}
+
+uint16_t
+ahc_inw(struct ahc_softc *ahc, u_int port)
+{
+        uint16_t r = ahc_inb(ahc, port+1) << 8;
+        return r | ahc_inb(ahc, port);
+}
+
+void
+ahc_outw(struct ahc_softc *ahc, u_int port, u_int value)
+{
+        ahc_outb(ahc, port, value & 0xFF);
+        ahc_outb(ahc, port+1, (value >> 8) & 0xFF);
+}
+
+uint32_t
+ahc_inl(struct ahc_softc *ahc, u_int port)
+{
+        return ((ahc_inb(ahc, port))
+              | (ahc_inb(ahc, port+1) << 8)
+              | (ahc_inb(ahc, port+2) << 16)
+              | (ahc_inb(ahc, port+3) << 24));
+}
+
+void
+ahc_outl(struct ahc_softc *ahc, u_int port, uint32_t value)
+{
+        ahc_outb(ahc, port, (value) & 0xFF);
+        ahc_outb(ahc, port+1, ((value) >> 8) & 0xFF);
+        ahc_outb(ahc, port+2, ((value) >> 16) & 0xFF);
+        ahc_outb(ahc, port+3, ((value) >> 24) & 0xFF);
+}
+
+uint64_t
+ahc_inq(struct ahc_softc *ahc, u_int port)
+{
+        return ((ahc_inb(ahc, port))
+              | (ahc_inb(ahc, port+1) << 8)
+              | (ahc_inb(ahc, port+2) << 16)
+              | (ahc_inb(ahc, port+3) << 24)
+              | (((uint64_t)ahc_inb(ahc, port+4)) << 32)
+              | (((uint64_t)ahc_inb(ahc, port+5)) << 40)
+              | (((uint64_t)ahc_inb(ahc, port+6)) << 48)
+              | (((uint64_t)ahc_inb(ahc, port+7)) << 56));
+}
+
+void
+ahc_outq(struct ahc_softc *ahc, u_int port, uint64_t value)
+{
+        ahc_outb(ahc, port, value & 0xFF);
+        ahc_outb(ahc, port+1, (value >> 8) & 0xFF);
+        ahc_outb(ahc, port+2, (value >> 16) & 0xFF);
+        ahc_outb(ahc, port+3, (value >> 24) & 0xFF);
+        ahc_outb(ahc, port+4, (value >> 32) & 0xFF);
+        ahc_outb(ahc, port+5, (value >> 40) & 0xFF);
+        ahc_outb(ahc, port+6, (value >> 48) & 0xFF);
+        ahc_outb(ahc, port+7, (value >> 56) & 0xFF);
+}
+
+/*
+ * Get a free scb. If there are none, see if we can allocate a new SCB.
+ */
+struct scb *
+ahc_get_scb(struct ahc_softc *ahc)
+{
+        struct scb *scb;
+
+        if ((scb = SLIST_FIRST(&ahc->scb_data->free_scbs)) == NULL) {
+                ahc_alloc_scbs(ahc);
+                scb = SLIST_FIRST(&ahc->scb_data->free_scbs);
+                if (scb == NULL)
+                        return (NULL);
+        }
+        SLIST_REMOVE_HEAD(&ahc->scb_data->free_scbs, links.sle);
+        return (scb);
+}
+
+/*
+ * Return an SCB resource to the free list.
+ */
+void
+ahc_free_scb(struct ahc_softc *ahc, struct scb *scb)
+{
+        struct hardware_scb *hscb;
+
+        hscb = scb->hscb;
+        /* Clean up for the next user */
+        ahc->scb_data->scbindex[hscb->tag] = NULL;
+        scb->flags = SCB_FREE;
+        hscb->control = 0;
+
+        SLIST_INSERT_HEAD(&ahc->scb_data->free_scbs, scb, links.sle);
+
+        /* Notify the OSM that a resource is now available. */
+        ahc_platform_scb_free(ahc, scb);
+}
+
+struct scb *
+ahc_lookup_scb(struct ahc_softc *ahc, u_int tag)
+{
+        struct scb* scb;
+
+        scb = ahc->scb_data->scbindex[tag];
+        if (scb != NULL)
+                ahc_sync_scb(ahc, scb,
+                             BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+        return (scb);
+}
+
+static void
+ahc_swap_with_next_hscb(struct ahc_softc *ahc, struct scb *scb)
+{
+        struct hardware_scb *q_hscb;
+        u_int  saved_tag;
+
+        /*
+         * Our queuing method is a bit tricky.  The card
+         * knows in advance which HSCB to download, and we
+         * can't disappoint it.  To achieve this, the next
+         * SCB to download is saved off in ahc->next_queued_scb.
+         * When we are called to queue "an arbitrary scb",
+         * we copy the contents of the incoming HSCB to the one
+         * the sequencer knows about, swap HSCB pointers and
+         * finally assign the SCB to the tag indexed location
+         * in the scb_array.  This makes sure that we can still
+         * locate the correct SCB by SCB_TAG.
+         */
+        q_hscb = ahc->next_queued_scb->hscb;
+        saved_tag = q_hscb->tag;
+        memcpy(q_hscb, scb->hscb, sizeof(*scb->hscb));
+        if ((scb->flags & SCB_CDB32_PTR) != 0) {
+                q_hscb->shared_data.cdb_ptr =
+                    ahc_htole32(ahc_hscb_busaddr(ahc, q_hscb->tag)
+                              + offsetof(struct hardware_scb, cdb32));
+        }
+        q_hscb->tag = saved_tag;
+        q_hscb->next = scb->hscb->tag;
+
+        /* Now swap HSCB pointers. */
+        ahc->next_queued_scb->hscb = scb->hscb;
+        scb->hscb = q_hscb;
+
+        /* Now define the mapping from tag to SCB in the scbindex */
+        ahc->scb_data->scbindex[scb->hscb->tag] = scb;
+}
+
+/*
+ * Tell the sequencer about a new transaction to execute.
  */
 void
+ahc_queue_scb(struct ahc_softc *ahc, struct scb *scb)
+{
+        ahc_swap_with_next_hscb(ahc, scb);
+
+        if (scb->hscb->tag == SCB_LIST_NULL
+         || scb->hscb->next == SCB_LIST_NULL)
+                panic("Attempt to queue invalid SCB tag %x:%x\n",
+                      scb->hscb->tag, scb->hscb->next);
+
+        /*
+         * Setup data "oddness".
+         */
+        scb->hscb->lun &= LID;
+        if (ahc_get_transfer_length(scb) & 0x1)
+                scb->hscb->lun |= SCB_XFERLEN_ODD;
+
+        /*
+         * Keep a history of SCBs we've downloaded in the qinfifo.
+         */
+        ahc->qinfifo[ahc->qinfifonext++] = scb->hscb->tag;
+
+        /*
+         * Make sure our data is consistent from the
+         * perspective of the adapter.
+         */
+        ahc_sync_scb(ahc, scb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+
+        /* Tell the adapter about the newly queued SCB */
+        if ((ahc->features & AHC_QUEUE_REGS) != 0) {
+                ahc_outb(ahc, HNSCB_QOFF, ahc->qinfifonext);
+        } else {
+                if ((ahc->features & AHC_AUTOPAUSE) == 0)
+                        ahc_pause(ahc);
+                ahc_outb(ahc, KERNEL_QINPOS, ahc->qinfifonext);
+                if ((ahc->features & AHC_AUTOPAUSE) == 0)
+                        ahc_unpause(ahc);
+        }
+}
+
+struct scsi_sense_data *
+ahc_get_sense_buf(struct ahc_softc *ahc, struct scb *scb)
+{
+        int offset;
+
+        offset = scb - ahc->scb_data->scbarray;
+        return (&ahc->scb_data->sense[offset]);
+}
+
+static uint32_t
+ahc_get_sense_bufaddr(struct ahc_softc *ahc, struct scb *scb)
+{
+        int offset;
+
+        offset = scb - ahc->scb_data->scbarray;
+        return (ahc->scb_data->sense_busaddr
+              + (offset * sizeof(struct scsi_sense_data)));
+}
+
+/************************** Interrupt Processing ******************************/
+static void
+ahc_sync_qoutfifo(struct ahc_softc *ahc, int op)
+{
+        ahc_dmamap_sync(ahc, ahc->shared_data_dmat, ahc->shared_data_dmamap,
+                        /*offset*/0, /*len*/256, op);
+}
+
+static void
+ahc_sync_tqinfifo(struct ahc_softc *ahc, int op)
+{
+#ifdef AHC_TARGET_MODE
+        if ((ahc->flags & AHC_TARGETROLE) != 0) {
+                ahc_dmamap_sync(ahc, ahc->shared_data_dmat,
+                                ahc->shared_data_dmamap,
+                                ahc_targetcmd_offset(ahc, 0),
+                                sizeof(struct target_cmd) * AHC_TMODE_CMDS,
+                                op);
+        }
+#endif
+}
+
+/*
+ * See if the firmware has posted any completed commands
+ * into our in-core command complete fifos.
+ */
+#define AHC_RUN_QOUTFIFO 0x1
+#define AHC_RUN_TQINFIFO 0x2
+static u_int
+ahc_check_cmdcmpltqueues(struct ahc_softc *ahc)
+{
+        u_int retval;
+
+        retval = 0;
+        ahc_dmamap_sync(ahc, ahc->shared_data_dmat, ahc->shared_data_dmamap,
+                        /*offset*/ahc->qoutfifonext, /*len*/1,
+                        BUS_DMASYNC_POSTREAD);
+        if (ahc->qoutfifo[ahc->qoutfifonext] != SCB_LIST_NULL)
+                retval |= AHC_RUN_QOUTFIFO;
+#ifdef AHC_TARGET_MODE
+        if ((ahc->flags & AHC_TARGETROLE) != 0
+         && (ahc->flags & AHC_TQINFIFO_BLOCKED) == 0) {
+                ahc_dmamap_sync(ahc, ahc->shared_data_dmat,
+                                ahc->shared_data_dmamap,
+                                ahc_targetcmd_offset(ahc, ahc->tqinfifofnext),
+                                /*len*/sizeof(struct target_cmd),
+                                BUS_DMASYNC_POSTREAD);
+                if (ahc->targetcmds[ahc->tqinfifonext].cmd_valid != 0)
+                        retval |= AHC_RUN_TQINFIFO;
+        }
+#endif
+        return (retval);
+}
+
+/*
+ * Catch an interrupt from the adapter
+ */
+int
+ahc_intr(struct ahc_softc *ahc)
+{
+        u_int   intstat;
+
+        if ((ahc->pause & INTEN) == 0) {
+                /*
+                 * Our interrupt is not enabled on the chip
+                 * and may be disabled for re-entrancy reasons,
+                 * so just return.  This is likely just a shared
+                 * interrupt.
+                 */
+                return (0);
+        }
+        /*
+         * Instead of directly reading the interrupt status register,
+         * infer the cause of the interrupt by checking our in-core
+         * completion queues.  This avoids a costly PCI bus read in
+         * most cases.
+         */
+        if ((ahc->flags & (AHC_ALL_INTERRUPTS|AHC_EDGE_INTERRUPT)) == 0
+         && (ahc_check_cmdcmpltqueues(ahc) != 0))
+                intstat = CMDCMPLT;
+        else {
+                intstat = ahc_inb(ahc, INTSTAT);
+        }
+
+        if ((intstat & INT_PEND) == 0) {
+#if AHC_PCI_CONFIG > 0
+                if (ahc->unsolicited_ints > 500) {
+                        ahc->unsolicited_ints = 0;
+                        if ((ahc->chip & AHC_PCI) != 0
+                         && (ahc_inb(ahc, ERROR) & PCIERRSTAT) != 0)
+                                ahc->bus_intr(ahc);
+                }
+#endif
+                ahc->unsolicited_ints++;
+                return (0);
+        }
+        ahc->unsolicited_ints = 0;
+
+        if (intstat & CMDCMPLT) {
+                ahc_outb(ahc, CLRINT, CLRCMDINT);
+
+                /*
+                 * Ensure that the chip sees that we've cleared
+                 * this interrupt before we walk the output fifo.
+                 * Otherwise, we may, due to posted bus writes,
+                 * clear the interrupt after we finish the scan,
+                 * and after the sequencer has added new entries
+                 * and asserted the interrupt again.
+                 */
+                ahc_flush_device_writes(ahc);
+                ahc_run_qoutfifo(ahc);
+#ifdef AHC_TARGET_MODE
+                if ((ahc->flags & AHC_TARGETROLE) != 0)
+                        ahc_run_tqinfifo(ahc, /*paused*/FALSE);
+#endif
+        }
+
+        /*
+         * Handle statuses that may invalidate our cached
+         * copy of INTSTAT separately.
+         */
+        if (intstat == 0xFF && (ahc->features & AHC_REMOVABLE) != 0) {
+                /* Hot eject.  Do nothing */
+        } else if (intstat & BRKADRINT) {
+                ahc_handle_brkadrint(ahc);
+        } else if ((intstat & (SEQINT|SCSIINT)) != 0) {
+
+                ahc_pause_bug_fix(ahc);
+
+                if ((intstat & SEQINT) != 0)
+                        ahc_handle_seqint(ahc, intstat);
+
+                if ((intstat & SCSIINT) != 0)
+                        ahc_handle_scsiint(ahc, intstat);
+        }
+        return (1);
+}
+
+/************************* Sequencer Execution Control ************************/
+/*
+ * Restart the sequencer program from address zero
+ */
+static void
 ahc_restart(struct ahc_softc *ahc)
 {
 
@@ -302,7 +872,7 @@ ahc_restart(struct ahc_softc *ahc)
 }
 
 /************************* Input/Output Queues ********************************/
-void
+static void
 ahc_run_qoutfifo(struct ahc_softc *ahc)
 {
         struct scb *scb;
@@ -349,7 +919,7 @@ ahc_run_qoutfifo(struct ahc_softc *ahc)
         }
 }
 
-void
+static void
 ahc_run_untagged_queues(struct ahc_softc *ahc)
 {
         int i;
@@ -358,7 +928,7 @@ ahc_run_untagged_queues(struct ahc_softc *ahc)
                 ahc_run_untagged_queue(ahc, &ahc->untagged_queues[i]);
 }
 
-void
+static void
 ahc_run_untagged_queue(struct ahc_softc *ahc, struct scb_tailq *queue)
 {
         struct scb *scb;
@@ -374,7 +944,7 @@ ahc_run_untagged_queue(struct ahc_softc *ahc, struct scb_tailq *queue)
 }
 
 /************************* Interrupt Handling *********************************/
-void
+static void
 ahc_handle_brkadrint(struct ahc_softc *ahc)
 {
         /*
@@ -403,7 +973,7 @@ ahc_handle_brkadrint(struct ahc_softc *ahc)
         ahc_shutdown(ahc);
 }
 
-void
+static void
 ahc_handle_seqint(struct ahc_softc *ahc, u_int intstat)
 {
         struct scb *scb;
@@ -954,7 +1524,7 @@ unpause:
         ahc_unpause(ahc);
 }
 
-void
+static void
 ahc_handle_scsiint(struct ahc_softc *ahc, u_int intstat)
 {
         u_int   scb_index;
@@ -1407,7 +1977,7 @@ ahc_force_renegotiation(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
 }
 
 #define AHC_MAX_STEPS 2000
-void
+static void
 ahc_clear_critical_section(struct ahc_softc *ahc)
 {
         int     stepping;
@@ -1500,7 +2070,7 @@ ahc_clear_critical_section(struct ahc_softc *ahc)
 /*
  * Clear any pending interrupt status.
  */
-void
+static void
 ahc_clear_intstat(struct ahc_softc *ahc)
 {
         /* Clear any interrupt conditions this may have caused */
@@ -1519,7 +2089,8 @@ ahc_clear_intstat(struct ahc_softc *ahc)
 uint32_t ahc_debug = AHC_DEBUG_OPTS;
 #endif
 
-void
+#if 0 /* unused */
+static void
 ahc_print_scb(struct scb *scb)
 {
         int i;
@@ -1551,6 +2122,7 @@ ahc_print_scb(struct scb *scb)
                 }
         }
 }
+#endif
 
 /************************* Transfer Negotiation *******************************/
 /*
@@ -1634,7 +2206,7 @@ ahc_free_tstate(struct ahc_softc *ahc, u_int scsi_id, char channel, int force)
  * by the capabilities of the bus connectivity of and sync settings for
  * the target.
  */
-struct ahc_syncrate *
+const struct ahc_syncrate *
 ahc_devlimited_syncrate(struct ahc_softc *ahc,
                         struct ahc_initiator_tinfo *tinfo,
                         u_int *period, u_int *ppr_options, role_t role)
@@ -1689,11 +2261,11 @@ ahc_devlimited_syncrate(struct ahc_softc *ahc,
  * Return the period and offset that should be sent to the target
  * if this was the beginning of an SDTR.
  */
-struct ahc_syncrate *
+const struct ahc_syncrate *
 ahc_find_syncrate(struct ahc_softc *ahc, u_int *period,
                   u_int *ppr_options, u_int maxsync)
 {
-        struct ahc_syncrate *syncrate;
+        const struct ahc_syncrate *syncrate;
 
         if ((ahc->features & AHC_DT) == 0)
                 *ppr_options &= ~MSG_EXT_PPR_DT_REQ;
@@ -1768,7 +2340,7 @@ ahc_find_syncrate(struct ahc_softc *ahc, u_int *period,
 u_int
 ahc_find_period(struct ahc_softc *ahc, u_int scsirate, u_int maxsync)
 {
-        struct ahc_syncrate *syncrate;
+        const struct ahc_syncrate *syncrate;
 
         if ((ahc->features & AHC_ULTRA2) != 0)
                 scsirate &= SXFR_ULTRA2;
@@ -1806,10 +2378,10 @@ ahc_find_period(struct ahc_softc *ahc, u_int scsirate, u_int maxsync)
  * Truncate the given synchronous offset to a value the
  * current adapter type and syncrate are capable of.
  */
-void
+static void
 ahc_validate_offset(struct ahc_softc *ahc,
                     struct ahc_initiator_tinfo *tinfo,
-                    struct ahc_syncrate *syncrate,
+                    const struct ahc_syncrate *syncrate,
                     u_int *offset, int wide, role_t role)
 {
         u_int maxoffset;
@@ -1838,7 +2410,7 @@ ahc_validate_offset(struct ahc_softc *ahc,
  * Truncate the given transfer width parameter to a value the
  * current adapter type is capable of.
  */
-void
+static void
 ahc_validate_width(struct ahc_softc *ahc, struct ahc_initiator_tinfo *tinfo,
                    u_int *bus_width, role_t role)
 {
@@ -1913,7 +2485,7 @@ ahc_update_neg_request(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
  */
 void
 ahc_set_syncrate(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
-                 struct ahc_syncrate *syncrate, u_int period,
+                 const struct ahc_syncrate *syncrate, u_int period,
                  u_int offset, u_int ppr_options, u_int type, int paused)
 {
         struct  ahc_initiator_tinfo *tinfo;
@@ -2220,11 +2792,11 @@ ahc_fetch_devinfo(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
                             role);
 }
 
-struct ahc_phase_table_entry*
+static const struct ahc_phase_table_entry*
 ahc_lookup_phase_entry(int phase)
 {
-        struct ahc_phase_table_entry *entry;
-        struct ahc_phase_table_entry *last_entry;
+        const struct ahc_phase_table_entry *entry;
+        const struct ahc_phase_table_entry *last_entry;
 
         /*
          * num_phases doesn't include the default entry which
@@ -2390,7 +2962,7 @@ ahc_build_transfer_msg(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
          */
         struct  ahc_initiator_tinfo *tinfo;
         struct  ahc_tmode_tstate *tstate;
-        struct  ahc_syncrate *rate;
+        const struct ahc_syncrate *rate;
         int     dowide;
         int     dosync;
         int     doppr;
@@ -2655,7 +3227,7 @@ proto_violation_reset:
  */
 static void
 ahc_handle_message_phase(struct ahc_softc *ahc)
-{ 
+{
         struct  ahc_devinfo devinfo;
         u_int   bus_phase;
         int     end_session;
@@ -3056,7 +3628,7 @@ ahc_parse_msg(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
                 switch (ahc->msgin_buf[2]) {
                 case MSG_EXT_SDTR:
                 {
-                        struct   ahc_syncrate *syncrate;
+                        const struct ahc_syncrate *syncrate;
                         u_int    period;
                         u_int    ppr_options;
                         u_int    offset;
@@ -3231,7 +3803,7 @@ ahc_parse_msg(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
                 }
                 case MSG_EXT_PPR:
                 {
-                        struct  ahc_syncrate *syncrate;
+                        const struct ahc_syncrate *syncrate;
                         u_int   period;
                         u_int   offset;
                         u_int   bus_width;
@@ -3984,7 +4556,7 @@ ahc_free(struct ahc_softc *ahc)
         return;
 }
 
-void
+static void
 ahc_shutdown(void *arg)
 {
         struct  ahc_softc *ahc;
@@ -4388,7 +4960,7 @@ ahc_fini_scbdata(struct ahc_softc *ahc)
                 free(scb_data->scbarray, M_DEVBUF);
 }
 
-void
+static void
 ahc_alloc_scbs(struct ahc_softc *ahc)
 {
         struct scb_data *scb_data;
@@ -5121,7 +5693,7 @@ ahc_resume(struct ahc_softc *ahc)
  * Return the untagged transaction id for a given target/channel lun.
  * Optionally, clear the entry.
  */
-u_int
+static u_int
 ahc_index_busy_tcl(struct ahc_softc *ahc, u_int tcl)
 {
         u_int scbid;
@@ -5142,7 +5714,7 @@ ahc_index_busy_tcl(struct ahc_softc *ahc, u_int tcl)
         return (scbid);
 }
 
-void
+static void
 ahc_unbusy_tcl(struct ahc_softc *ahc, u_int tcl)
 {
         u_int target_offset;
@@ -5160,7 +5732,7 @@ ahc_unbusy_tcl(struct ahc_softc *ahc, u_int tcl)
         }
 }
 
-void
+static void
 ahc_busy_tcl(struct ahc_softc *ahc, u_int tcl, u_int scbid)
 {
         u_int target_offset;
@@ -5215,7 +5787,7 @@ ahc_match_scb(struct ahc_softc *ahc, struct scb *scb, int target,
         return match;
 }
 
-void
+static void
 ahc_freeze_devq(struct ahc_softc *ahc, struct scb *scb)
 {
         int     target;
@@ -5707,7 +6279,7 @@ ahc_add_curscb_to_free_list(struct ahc_softc *ahc)
  */
 static u_int
 ahc_rem_wscb(struct ahc_softc *ahc, u_int scbpos, u_int prev)
-{       
+{
         u_int curscb, next;
 
         /*
@@ -5756,7 +6328,7 @@ ahc_rem_wscb(struct ahc_softc *ahc, u_int scbpos, u_int prev)
  * been modified from CAM_REQ_INPROG.  This routine assumes that the sequencer
  * is paused before it is called.
  */
-int
+static int
 ahc_abort_scbs(struct ahc_softc *ahc, int target, char channel,
                int lun, u_int tag, role_t role, uint32_t status)
 {
@@ -6078,7 +6650,7 @@ ahc_reset_channel(struct ahc_softc *ahc, char channel, int initiate_reset)
 /*
  * Calculate the residual for a just completed SCB.
  */
-void
+static void
 ahc_calc_residual(struct ahc_softc *ahc, struct scb *scb)
 {
         struct hardware_scb *hscb;
@@ -6279,7 +6851,7 @@ ahc_loadseq(struct ahc_softc *ahc)
         struct  cs cs_table[num_critical_sections];
         u_int   begin_set[num_critical_sections];
         u_int   end_set[num_critical_sections];
-        struct  patch *cur_patch;
+        const struct patch *cur_patch;
         u_int   cs_count;
         u_int   cur_cs;
         u_int   i;
@@ -6384,11 +6956,11 @@ ahc_loadseq(struct ahc_softc *ahc)
 }
 
 static int
-ahc_check_patch(struct ahc_softc *ahc, struct patch **start_patch,
+ahc_check_patch(struct ahc_softc *ahc, const struct patch **start_patch,
                 u_int start_instr, u_int *skip_addr)
 {
-        struct  patch *cur_patch;
-        struct  patch *last_patch;
+        const struct patch *cur_patch;
+        const struct patch *last_patch;
         u_int   num_patches;
 
         num_patches = ARRAY_SIZE(patches);
@@ -6447,7 +7019,7 @@ ahc_download_instr(struct ahc_softc *ahc, u_int instrptr, uint8_t *dconsts)
         case AIC_OP_JE:
         case AIC_OP_JZ:
         {
-                struct patch *cur_patch;
+                const struct patch *cur_patch;
                 int address_offset;
                 u_int address;
                 u_int skip_addr;
@@ -6545,7 +7117,7 @@ ahc_download_instr(struct ahc_softc *ahc, u_int instrptr, uint8_t *dconsts)
 }
 
 int
-ahc_print_register(ahc_reg_parse_entry_t *table, u_int num_entries,
+ahc_print_register(const ahc_reg_parse_entry_t *table, u_int num_entries,
                    const char *name, u_int address, u_int value,
                    u_int *cur_column, u_int wrap_point)
 {
@@ -7229,7 +7801,7 @@ ahc_update_scsiid(struct ahc_softc *ahc, u_int targid_mask)
                 ahc_outb(ahc, SCSIID, scsiid);
 }
 
-void
+static void
 ahc_run_tqinfifo(struct ahc_softc *ahc, int paused)
 {
         struct target_cmd *cmd;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_inline.h b/drivers/scsi/aic7xxx/aic7xxx_inline.h
index cba2f23bbe79..09bf2f4d78d5 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_inline.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_inline.h
@@ -46,179 +46,13 @@
 #define _AIC7XXX_INLINE_H_
 
 /************************* Sequencer Execution Control ************************/
-static __inline void ahc_pause_bug_fix(struct ahc_softc *ahc);
-static __inline int  ahc_is_paused(struct ahc_softc *ahc);
-static __inline void ahc_pause(struct ahc_softc *ahc);
-static __inline void ahc_unpause(struct ahc_softc *ahc);
-
-/*
- * Work around any chip bugs related to halting sequencer execution.
- * On Ultra2 controllers, we must clear the CIOBUS stretch signal by
- * reading a register that will set this signal and deassert it.
- * Without this workaround, if the chip is paused, by an interrupt or
- * manual pause while accessing scb ram, accesses to certain registers
- * will hang the system (infinite pci retries).
- */
-static __inline void
-ahc_pause_bug_fix(struct ahc_softc *ahc)
-{
-        if ((ahc->features & AHC_ULTRA2) != 0)
-                (void)ahc_inb(ahc, CCSCBCTL);
-}
-
-/*
- * Determine whether the sequencer has halted code execution.
- * Returns non-zero status if the sequencer is stopped.
- */
-static __inline int
-ahc_is_paused(struct ahc_softc *ahc)
-{
-        return ((ahc_inb(ahc, HCNTRL) & PAUSE) != 0);
-}
-
-/*
- * Request that the sequencer stop and wait, indefinitely, for it
- * to stop.  The sequencer will only acknowledge that it is paused
- * once it has reached an instruction boundary and PAUSEDIS is
- * cleared in the SEQCTL register.  The sequencer may use PAUSEDIS
- * for critical sections.
- */
-static __inline void
-ahc_pause(struct ahc_softc *ahc)
-{
-        ahc_outb(ahc, HCNTRL, ahc->pause);
-
-        /*
-         * Since the sequencer can disable pausing in a critical section, we
-         * must loop until it actually stops.
-         */
-        while (ahc_is_paused(ahc) == 0)
-                ;
-
-        ahc_pause_bug_fix(ahc);
-}
-
-/*
- * Allow the sequencer to continue program execution.
- * We check here to ensure that no additional interrupt
- * sources that would cause the sequencer to halt have been
- * asserted.  If, for example, a SCSI bus reset is detected
- * while we are fielding a different, pausing, interrupt type,
- * we don't want to release the sequencer before going back
- * into our interrupt handler and dealing with this new
- * condition.
- */
-static __inline void
-ahc_unpause(struct ahc_softc *ahc)
-{
-        if ((ahc_inb(ahc, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) == 0)
-                ahc_outb(ahc, HCNTRL, ahc->unpause);
-}
-
-/*********************** Untagged Transaction Routines ************************/
-static __inline void    ahc_freeze_untagged_queues(struct ahc_softc *ahc);
-static __inline void    ahc_release_untagged_queues(struct ahc_softc *ahc);
-
-/*
- * Block our completion routine from starting the next untagged
- * transaction for this target or target lun.
- */
-static __inline void
-ahc_freeze_untagged_queues(struct ahc_softc *ahc)
-{
-        if ((ahc->flags & AHC_SCB_BTT) == 0)
-                ahc->untagged_queue_lock++;
-}
-
-/*
- * Allow the next untagged transaction for this target or target lun
- * to be executed.  We use a counting semaphore to allow the lock
- * to be acquired recursively.  Once the count drops to zero, the
- * transaction queues will be run.
- */
-static __inline void
-ahc_release_untagged_queues(struct ahc_softc *ahc)
-{
-        if ((ahc->flags & AHC_SCB_BTT) == 0) {
-                ahc->untagged_queue_lock--;
-                if (ahc->untagged_queue_lock == 0)
-                        ahc_run_untagged_queues(ahc);
-        }
-}
+int  ahc_is_paused(struct ahc_softc *ahc);
+void ahc_pause(struct ahc_softc *ahc);
+void ahc_unpause(struct ahc_softc *ahc);
 
 /************************** Memory mapping routines ***************************/
-static __inline struct ahc_dma_seg *
-                        ahc_sg_bus_to_virt(struct scb *scb,
-                                           uint32_t sg_busaddr);
-static __inline uint32_t
-                        ahc_sg_virt_to_bus(struct scb *scb,
-                                           struct ahc_dma_seg *sg);
-static __inline uint32_t
-                        ahc_hscb_busaddr(struct ahc_softc *ahc, u_int index);
-static __inline void    ahc_sync_scb(struct ahc_softc *ahc,
-                                     struct scb *scb, int op);
-static __inline void    ahc_sync_sglist(struct ahc_softc *ahc,
-                                        struct scb *scb, int op);
-static __inline uint32_t
-                        ahc_targetcmd_offset(struct ahc_softc *ahc,
-                                             u_int index);
-
-static __inline struct ahc_dma_seg *
-ahc_sg_bus_to_virt(struct scb *scb, uint32_t sg_busaddr)
-{
-        int sg_index;
-
-        sg_index = (sg_busaddr - scb->sg_list_phys)/sizeof(struct ahc_dma_seg);
-        /* sg_list_phys points to entry 1, not 0 */
-        sg_index++;
-
-        return (&scb->sg_list[sg_index]);
-}
-
-static __inline uint32_t
-ahc_sg_virt_to_bus(struct scb *scb, struct ahc_dma_seg *sg)
-{
-        int sg_index;
-
-        /* sg_list_phys points to entry 1, not 0 */
-        sg_index = sg - &scb->sg_list[1];
-
-        return (scb->sg_list_phys + (sg_index * sizeof(*scb->sg_list)));
-}
-
-static __inline uint32_t
-ahc_hscb_busaddr(struct ahc_softc *ahc, u_int index)
-{
-        return (ahc->scb_data->hscb_busaddr
-                + (sizeof(struct hardware_scb) * index));
-}
-
-static __inline void
-ahc_sync_scb(struct ahc_softc *ahc, struct scb *scb, int op)
-{
-        ahc_dmamap_sync(ahc, ahc->scb_data->hscb_dmat,
-                        ahc->scb_data->hscb_dmamap,
-                        /*offset*/(scb->hscb - ahc->hscbs) * sizeof(*scb->hscb),
-                        /*len*/sizeof(*scb->hscb), op);
-}
-
-static __inline void
-ahc_sync_sglist(struct ahc_softc *ahc, struct scb *scb, int op)
-{
-        if (scb->sg_count == 0)
-                return;
-
-        ahc_dmamap_sync(ahc, ahc->scb_data->sg_dmat, scb->sg_map->sg_dmamap,
-                        /*offset*/(scb->sg_list - scb->sg_map->sg_vaddr)
-                                * sizeof(struct ahc_dma_seg),
-                        /*len*/sizeof(struct ahc_dma_seg) * scb->sg_count, op);
-}
-
-static __inline uint32_t
-ahc_targetcmd_offset(struct ahc_softc *ahc, u_int index)
-{
-        return (((uint8_t *)&ahc->targetcmds[index]) - ahc->qoutfifo);
-}
+void    ahc_sync_sglist(struct ahc_softc *ahc,
+                        struct scb *scb, int op);
 
 /******************************** Debugging ***********************************/
 static __inline char *ahc_name(struct ahc_softc *ahc);
@@ -231,420 +65,34 @@ ahc_name(struct ahc_softc *ahc)
 
 /*********************** Miscellaneous Support Functions ***********************/
 
-static __inline void    ahc_update_residual(struct ahc_softc *ahc,
-                                            struct scb *scb);
-static __inline struct ahc_initiator_tinfo *
-                        ahc_fetch_transinfo(struct ahc_softc *ahc,
-                                            char channel, u_int our_id,
-                                            u_int remote_id,
-                                            struct ahc_tmode_tstate **tstate);
-static __inline uint16_t
-                        ahc_inw(struct ahc_softc *ahc, u_int port);
-static __inline void    ahc_outw(struct ahc_softc *ahc, u_int port,
-                                 u_int value);
-static __inline uint32_t
-                        ahc_inl(struct ahc_softc *ahc, u_int port);
-static __inline void    ahc_outl(struct ahc_softc *ahc, u_int port,
-                                 uint32_t value);
-static __inline uint64_t
-                        ahc_inq(struct ahc_softc *ahc, u_int port);
-static __inline void    ahc_outq(struct ahc_softc *ahc, u_int port,
-                                 uint64_t value);
-static __inline struct scb*
-                        ahc_get_scb(struct ahc_softc *ahc);
-static __inline void    ahc_free_scb(struct ahc_softc *ahc, struct scb *scb);
-static __inline void    ahc_swap_with_next_hscb(struct ahc_softc *ahc,
-                                                struct scb *scb);
-static __inline void    ahc_queue_scb(struct ahc_softc *ahc, struct scb *scb);
-static __inline struct scsi_sense_data *
-                        ahc_get_sense_buf(struct ahc_softc *ahc,
-                                          struct scb *scb);
-static __inline uint32_t
-                        ahc_get_sense_bufaddr(struct ahc_softc *ahc,
-                                              struct scb *scb);
-
-/*
- * Determine whether the sequencer reported a residual
- * for this SCB/transaction.
- */
-static __inline void
-ahc_update_residual(struct ahc_softc *ahc, struct scb *scb)
-{
-        uint32_t sgptr;
-
-        sgptr = ahc_le32toh(scb->hscb->sgptr);
-        if ((sgptr & SG_RESID_VALID) != 0)
-                ahc_calc_residual(ahc, scb);
-}
-
-/*
- * Return pointers to the transfer negotiation information
- * for the specified our_id/remote_id pair.
- */
-static __inline struct ahc_initiator_tinfo *
-ahc_fetch_transinfo(struct ahc_softc *ahc, char channel, u_int our_id,
-                    u_int remote_id, struct ahc_tmode_tstate **tstate)
-{
-        /*
-         * Transfer data structures are stored from the perspective
-         * of the target role.  Since the parameters for a connection
-         * in the initiator role to a given target are the same as
-         * when the roles are reversed, we pretend we are the target.
-         */
-        if (channel == 'B')
-                our_id += 8;
-        *tstate = ahc->enabled_targets[our_id];
-        return (&(*tstate)->transinfo[remote_id]);
-}
-
-static __inline uint16_t
-ahc_inw(struct ahc_softc *ahc, u_int port)
-{
-        uint16_t r = ahc_inb(ahc, port+1) << 8;
-        return r | ahc_inb(ahc, port);
-}
-
-static __inline void
-ahc_outw(struct ahc_softc *ahc, u_int port, u_int value)
-{
-        ahc_outb(ahc, port, value & 0xFF);
-        ahc_outb(ahc, port+1, (value >> 8) & 0xFF);
-}
-
-static __inline uint32_t
-ahc_inl(struct ahc_softc *ahc, u_int port)
-{
-        return ((ahc_inb(ahc, port))
-              | (ahc_inb(ahc, port+1) << 8)
-              | (ahc_inb(ahc, port+2) << 16)
-              | (ahc_inb(ahc, port+3) << 24));
-}
-
-static __inline void
-ahc_outl(struct ahc_softc *ahc, u_int port, uint32_t value)
-{
-        ahc_outb(ahc, port, (value) & 0xFF);
-        ahc_outb(ahc, port+1, ((value) >> 8) & 0xFF);
-        ahc_outb(ahc, port+2, ((value) >> 16) & 0xFF);
-        ahc_outb(ahc, port+3, ((value) >> 24) & 0xFF);
-}
-
-static __inline uint64_t
-ahc_inq(struct ahc_softc *ahc, u_int port)
-{
-        return ((ahc_inb(ahc, port))
-              | (ahc_inb(ahc, port+1) << 8)
-              | (ahc_inb(ahc, port+2) << 16)
-              | (ahc_inb(ahc, port+3) << 24)
-              | (((uint64_t)ahc_inb(ahc, port+4)) << 32)
-              | (((uint64_t)ahc_inb(ahc, port+5)) << 40)
-              | (((uint64_t)ahc_inb(ahc, port+6)) << 48)
-              | (((uint64_t)ahc_inb(ahc, port+7)) << 56));
-}
-
-static __inline void
-ahc_outq(struct ahc_softc *ahc, u_int port, uint64_t value)
-{
-        ahc_outb(ahc, port, value & 0xFF);
-        ahc_outb(ahc, port+1, (value >> 8) & 0xFF);
-        ahc_outb(ahc, port+2, (value >> 16) & 0xFF);
-        ahc_outb(ahc, port+3, (value >> 24) & 0xFF);
-        ahc_outb(ahc, port+4, (value >> 32) & 0xFF);
-        ahc_outb(ahc, port+5, (value >> 40) & 0xFF);
-        ahc_outb(ahc, port+6, (value >> 48) & 0xFF);
-        ahc_outb(ahc, port+7, (value >> 56) & 0xFF);
-}
-
-/*
- * Get a free scb. If there are none, see if we can allocate a new SCB.
- */
-static __inline struct scb *
-ahc_get_scb(struct ahc_softc *ahc)
-{
-        struct scb *scb;
-
-        if ((scb = SLIST_FIRST(&ahc->scb_data->free_scbs)) == NULL) {
-                ahc_alloc_scbs(ahc);
-                scb = SLIST_FIRST(&ahc->scb_data->free_scbs);
-                if (scb == NULL)
-                        return (NULL);
-        }
-        SLIST_REMOVE_HEAD(&ahc->scb_data->free_scbs, links.sle);
-        return (scb);
-}
-
-/*
- * Return an SCB resource to the free list.
- */
-static __inline void
-ahc_free_scb(struct ahc_softc *ahc, struct scb *scb)
-{       
-        struct hardware_scb *hscb;
-
-        hscb = scb->hscb;
-        /* Clean up for the next user */
-        ahc->scb_data->scbindex[hscb->tag] = NULL;
-        scb->flags = SCB_FREE;
-        hscb->control = 0;
-
-        SLIST_INSERT_HEAD(&ahc->scb_data->free_scbs, scb, links.sle);
-
-        /* Notify the OSM that a resource is now available. */
-        ahc_platform_scb_free(ahc, scb);
-}
-
-static __inline struct scb *
-ahc_lookup_scb(struct ahc_softc *ahc, u_int tag)
-{
-        struct scb* scb;
-
-        scb = ahc->scb_data->scbindex[tag];
-        if (scb != NULL)
-                ahc_sync_scb(ahc, scb,
-                             BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
-        return (scb);
-}
-
-static __inline void
-ahc_swap_with_next_hscb(struct ahc_softc *ahc, struct scb *scb)
-{
-        struct hardware_scb *q_hscb;
-        u_int  saved_tag;
-
-        /*
-         * Our queuing method is a bit tricky.  The card
-         * knows in advance which HSCB to download, and we
-         * can't disappoint it.  To achieve this, the next
-         * SCB to download is saved off in ahc->next_queued_scb.
-         * When we are called to queue "an arbitrary scb",
-         * we copy the contents of the incoming HSCB to the one
-         * the sequencer knows about, swap HSCB pointers and
-         * finally assign the SCB to the tag indexed location
-         * in the scb_array.  This makes sure that we can still
-         * locate the correct SCB by SCB_TAG.
-         */
-        q_hscb = ahc->next_queued_scb->hscb;
-        saved_tag = q_hscb->tag;
-        memcpy(q_hscb, scb->hscb, sizeof(*scb->hscb));
-        if ((scb->flags & SCB_CDB32_PTR) != 0) {
-                q_hscb->shared_data.cdb_ptr =
-                    ahc_htole32(ahc_hscb_busaddr(ahc, q_hscb->tag)
-                              + offsetof(struct hardware_scb, cdb32));
-        }
-        q_hscb->tag = saved_tag;
-        q_hscb->next = scb->hscb->tag;
-
-        /* Now swap HSCB pointers. */
-        ahc->next_queued_scb->hscb = scb->hscb;
-        scb->hscb = q_hscb;
-
-        /* Now define the mapping from tag to SCB in the scbindex */
-        ahc->scb_data->scbindex[scb->hscb->tag] = scb;
-}
-
-/*
- * Tell the sequencer about a new transaction to execute.
- */
-static __inline void
-ahc_queue_scb(struct ahc_softc *ahc, struct scb *scb)
-{
-        ahc_swap_with_next_hscb(ahc, scb);
-
-        if (scb->hscb->tag == SCB_LIST_NULL
-         || scb->hscb->next == SCB_LIST_NULL)
-                panic("Attempt to queue invalid SCB tag %x:%x\n",
-                      scb->hscb->tag, scb->hscb->next);
-
-        /*
-         * Setup data "oddness".
-         */
-        scb->hscb->lun &= LID;
-        if (ahc_get_transfer_length(scb) & 0x1)
-                scb->hscb->lun |= SCB_XFERLEN_ODD;
-
-        /*
-         * Keep a history of SCBs we've downloaded in the qinfifo.
-         */
-        ahc->qinfifo[ahc->qinfifonext++] = scb->hscb->tag;
-
-        /*
-         * Make sure our data is consistent from the
-         * perspective of the adapter.
-         */
-        ahc_sync_scb(ahc, scb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
-
-        /* Tell the adapter about the newly queued SCB */
-        if ((ahc->features & AHC_QUEUE_REGS) != 0) {
-                ahc_outb(ahc, HNSCB_QOFF, ahc->qinfifonext);
-        } else {
-                if ((ahc->features & AHC_AUTOPAUSE) == 0)
-                        ahc_pause(ahc);
-                ahc_outb(ahc, KERNEL_QINPOS, ahc->qinfifonext);
-                if ((ahc->features & AHC_AUTOPAUSE) == 0)
-                        ahc_unpause(ahc);
-        }
-}
-
-static __inline struct scsi_sense_data *
-ahc_get_sense_buf(struct ahc_softc *ahc, struct scb *scb)
-{
-        int offset;
-
-        offset = scb - ahc->scb_data->scbarray;
-        return (&ahc->scb_data->sense[offset]);
-}
-
-static __inline uint32_t
-ahc_get_sense_bufaddr(struct ahc_softc *ahc, struct scb *scb)
-{
-        int offset;
-
-        offset = scb - ahc->scb_data->scbarray;
-        return (ahc->scb_data->sense_busaddr
-              + (offset * sizeof(struct scsi_sense_data)));
-}
+struct ahc_initiator_tinfo *
+        ahc_fetch_transinfo(struct ahc_softc *ahc,
+                            char channel, u_int our_id,
+                            u_int remote_id,
+                            struct ahc_tmode_tstate **tstate);
+uint16_t
+        ahc_inw(struct ahc_softc *ahc, u_int port);
+void    ahc_outw(struct ahc_softc *ahc, u_int port,
+                 u_int value);
+uint32_t
+        ahc_inl(struct ahc_softc *ahc, u_int port);
+void    ahc_outl(struct ahc_softc *ahc, u_int port,
+                 uint32_t value);
+uint64_t
+        ahc_inq(struct ahc_softc *ahc, u_int port);
+void    ahc_outq(struct ahc_softc *ahc, u_int port,
+                 uint64_t value);
+struct scb*
+        ahc_get_scb(struct ahc_softc *ahc);
+void    ahc_free_scb(struct ahc_softc *ahc, struct scb *scb);
+struct scb *
+        ahc_lookup_scb(struct ahc_softc *ahc, u_int tag);
+void    ahc_queue_scb(struct ahc_softc *ahc, struct scb *scb);
+struct scsi_sense_data *
+        ahc_get_sense_buf(struct ahc_softc *ahc,
+                          struct scb *scb);
 
 /************************** Interrupt Processing ******************************/
-static __inline void    ahc_sync_qoutfifo(struct ahc_softc *ahc, int op);
-static __inline void    ahc_sync_tqinfifo(struct ahc_softc *ahc, int op);
-static __inline u_int   ahc_check_cmdcmpltqueues(struct ahc_softc *ahc);
-static __inline int     ahc_intr(struct ahc_softc *ahc);
-
-static __inline void
-ahc_sync_qoutfifo(struct ahc_softc *ahc, int op)
-{
-        ahc_dmamap_sync(ahc, ahc->shared_data_dmat, ahc->shared_data_dmamap,
-                        /*offset*/0, /*len*/256, op);
-}
-
-static __inline void
-ahc_sync_tqinfifo(struct ahc_softc *ahc, int op)
-{
-#ifdef AHC_TARGET_MODE
-        if ((ahc->flags & AHC_TARGETROLE) != 0) {
-                ahc_dmamap_sync(ahc, ahc->shared_data_dmat,
-                                ahc->shared_data_dmamap,
-                                ahc_targetcmd_offset(ahc, 0),
-                                sizeof(struct target_cmd) * AHC_TMODE_CMDS,
-                                op);
-        }
-#endif
-}
-
-/*
- * See if the firmware has posted any completed commands
- * into our in-core command complete fifos.
- */
-#define AHC_RUN_QOUTFIFO 0x1
-#define AHC_RUN_TQINFIFO 0x2
-static __inline u_int
-ahc_check_cmdcmpltqueues(struct ahc_softc *ahc)
-{
-        u_int retval;
-
-        retval = 0;
-        ahc_dmamap_sync(ahc, ahc->shared_data_dmat, ahc->shared_data_dmamap,
-                        /*offset*/ahc->qoutfifonext, /*len*/1,
-                        BUS_DMASYNC_POSTREAD);
-        if (ahc->qoutfifo[ahc->qoutfifonext] != SCB_LIST_NULL)
-                retval |= AHC_RUN_QOUTFIFO;
-#ifdef AHC_TARGET_MODE
-        if ((ahc->flags & AHC_TARGETROLE) != 0
-         && (ahc->flags & AHC_TQINFIFO_BLOCKED) == 0) {
-                ahc_dmamap_sync(ahc, ahc->shared_data_dmat,
-                                ahc->shared_data_dmamap,
-                                ahc_targetcmd_offset(ahc, ahc->tqinfifofnext),
-                                /*len*/sizeof(struct target_cmd),
-                                BUS_DMASYNC_POSTREAD);
-                if (ahc->targetcmds[ahc->tqinfifonext].cmd_valid != 0)
-                        retval |= AHC_RUN_TQINFIFO;
-        }
-#endif
-        return (retval);
-}
-
-/*
- * Catch an interrupt from the adapter
- */
-static __inline int
-ahc_intr(struct ahc_softc *ahc)
-{
-        u_int   intstat;
-
-        if ((ahc->pause & INTEN) == 0) {
-                /*
-                 * Our interrupt is not enabled on the chip
-                 * and may be disabled for re-entrancy reasons,
-                 * so just return.  This is likely just a shared
-                 * interrupt.
-                 */
-                return (0);
-        }
-        /*
-         * Instead of directly reading the interrupt status register,
-         * infer the cause of the interrupt by checking our in-core
-         * completion queues.  This avoids a costly PCI bus read in
-         * most cases.
-         */
-        if ((ahc->flags & (AHC_ALL_INTERRUPTS|AHC_EDGE_INTERRUPT)) == 0
-         && (ahc_check_cmdcmpltqueues(ahc) != 0))
-                intstat = CMDCMPLT;
-        else {
-                intstat = ahc_inb(ahc, INTSTAT);
-        }
-
-        if ((intstat & INT_PEND) == 0) {
-#if AHC_PCI_CONFIG > 0
-                if (ahc->unsolicited_ints > 500) {
-                        ahc->unsolicited_ints = 0;
-                        if ((ahc->chip & AHC_PCI) != 0
-                         && (ahc_inb(ahc, ERROR) & PCIERRSTAT) != 0)
-                                ahc->bus_intr(ahc);
-                }
-#endif
-                ahc->unsolicited_ints++;
-                return (0);
-        }
-        ahc->unsolicited_ints = 0;
-
-        if (intstat & CMDCMPLT) {
-                ahc_outb(ahc, CLRINT, CLRCMDINT);
-
-                /*
-                 * Ensure that the chip sees that we've cleared
-                 * this interrupt before we walk the output fifo.
-                 * Otherwise, we may, due to posted bus writes,
-                 * clear the interrupt after we finish the scan,
-                 * and after the sequencer has added new entries
-                 * and asserted the interrupt again.
-                 */
-                ahc_flush_device_writes(ahc);
-                ahc_run_qoutfifo(ahc);
-#ifdef AHC_TARGET_MODE
-                if ((ahc->flags & AHC_TARGETROLE) != 0)
-                        ahc_run_tqinfifo(ahc, /*paused*/FALSE);
-#endif
-        }
-
-        /*
-         * Handle statuses that may invalidate our cached
-         * copy of INTSTAT separately.
-         */
-        if (intstat == 0xFF && (ahc->features & AHC_REMOVABLE) != 0) {
-                /* Hot eject.  Do nothing */
-        } else if (intstat & BRKADRINT) {
-                ahc_handle_brkadrint(ahc);
-        } else if ((intstat & (SEQINT|SCSIINT)) != 0) {
-
-                ahc_pause_bug_fix(ahc);
-
-                if ((intstat & SEQINT) != 0)
-                        ahc_handle_seqint(ahc, intstat);
-
-                if ((intstat & SCSIINT) != 0)
-                        ahc_handle_scsiint(ahc, intstat);
-        }
-        return (1);
-}
+int     ahc_intr(struct ahc_softc *ahc);
 
 #endif  /* _AIC7XXX_INLINE_H_ */
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index 42ad48e09f02..fd2b9785ff4f 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -388,14 +388,83 @@ static int  aic7xxx_setup(char *s);
 static int ahc_linux_unit;
 
 
+/************************** OS Utility Wrappers *******************************/
+void
+ahc_delay(long usec)
+{
+        /*
+         * udelay on Linux can have problems for
+         * multi-millisecond waits.  Wait at most
+         * 1024us per call.
+         */
+        while (usec > 0) {
+                udelay(usec % 1024);
+                usec -= 1024;
+        }
+}
+
+/***************************** Low Level I/O **********************************/
+uint8_t
+ahc_inb(struct ahc_softc * ahc, long port)
+{
+        uint8_t x;
+
+        if (ahc->tag == BUS_SPACE_MEMIO) {
+                x = readb(ahc->bsh.maddr + port);
+        } else {
+                x = inb(ahc->bsh.ioport + port);
+        }
+        mb();
+        return (x);
+}
+
+void
+ahc_outb(struct ahc_softc * ahc, long port, uint8_t val)
+{
+        if (ahc->tag == BUS_SPACE_MEMIO) {
+                writeb(val, ahc->bsh.maddr + port);
+        } else {
+                outb(val, ahc->bsh.ioport + port);
+        }
+        mb();
+}
+
+void
+ahc_outsb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
+{
+        int i;
+
+        /*
+         * There is probably a more efficient way to do this on Linux
+         * but we don't use this for anything speed critical and this
+         * should work.
+         */
+        for (i = 0; i < count; i++)
+                ahc_outb(ahc, port, *array++);
+}
+
+void
+ahc_insb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
+{
+        int i;
+
+        /*
+         * There is probably a more efficient way to do this on Linux
+         * but we don't use this for anything speed critical and this
+         * should work.
+         */
+        for (i = 0; i < count; i++)
+                *array++ = ahc_inb(ahc, port);
+}
+
 /********************************* Inlines ************************************/
-static __inline void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);
+static void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);
 
-static __inline int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
+static int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
                                       struct ahc_dma_seg *sg,
                                       dma_addr_t addr, bus_size_t len);
 
-static __inline void
+static void
 ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)
 {
         struct scsi_cmnd *cmd;
@@ -406,7 +475,7 @@ ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)
         scsi_dma_unmap(cmd);
 }
 
-static __inline int
+static int
 ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
                   struct ahc_dma_seg *sg, dma_addr_t addr, bus_size_t len)
 {
@@ -442,13 +511,11 @@ ahc_linux_info(struct Scsi_Host *host)
         bp = &buffer[0];
         ahc = *(struct ahc_softc **)host->hostdata;
         memset(bp, 0, sizeof(buffer));
-        strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev ");
-        strcat(bp, AIC7XXX_DRIVER_VERSION);
-        strcat(bp, "\n");
-        strcat(bp, "        <");
+        strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev " AIC7XXX_DRIVER_VERSION "\n"
+                        "        <");
         strcat(bp, ahc->description);
-        strcat(bp, ">\n");
-        strcat(bp, "        ");
+        strcat(bp, ">\n"
+                        "        ");
         ahc_controller_info(ahc, ahc_info);
         strcat(bp, ahc_info);
         strcat(bp, "\n");
@@ -964,7 +1031,7 @@ aic7xxx_setup(char *s)
         char   *p;
         char   *end;
 
-        static struct {
+        static const struct {
                 const char *name;
                 uint32_t *flag;
         } options[] = {
@@ -2317,7 +2384,7 @@ static void ahc_linux_set_period(struct scsi_target *starget, int period)
         unsigned int ppr_options = tinfo->goal.ppr_options;
         unsigned long flags;
         unsigned long offset = tinfo->goal.offset;
-        struct ahc_syncrate *syncrate;
+        const struct ahc_syncrate *syncrate;
 
         if (offset == 0)
                 offset = MAX_OFFSET;
@@ -2361,7 +2428,7 @@ static void ahc_linux_set_offset(struct scsi_target *starget, int offset)
         unsigned int ppr_options = 0;
         unsigned int period = 0;
         unsigned long flags;
-        struct ahc_syncrate *syncrate = NULL;
+        const struct ahc_syncrate *syncrate = NULL;
 
         ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
                             starget->channel + 'A', ROLE_INITIATOR);
@@ -2391,7 +2458,7 @@ static void ahc_linux_set_dt(struct scsi_target *starget, int dt)
         unsigned int period = tinfo->goal.period;
         unsigned int width = tinfo->goal.width;
         unsigned long flags;
-        struct ahc_syncrate *syncrate;
+        const struct ahc_syncrate *syncrate;
 
         if (dt && spi_max_width(starget)) {
                 ppr_options |= MSG_EXT_PPR_DT_REQ;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.h b/drivers/scsi/aic7xxx/aic7xxx_osm.h
index b48dab447bde..3f7238db35e5 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.h
@@ -365,7 +365,7 @@ struct ahc_platform_data {
 #define AHC_LINUX_NOIRQ ((uint32_t)~0)
         uint32_t                 irq;           /* IRQ for this adapter */
         uint32_t                 bios_address;
-        uint32_t                 mem_busaddr;   /* Mem Base Addr */
+        resource_size_t          mem_busaddr;   /* Mem Base Addr */
 };
 
 /************************** OS Utility Wrappers *******************************/
@@ -375,82 +375,16 @@ struct ahc_platform_data {
 #define malloc(size, type, flags) kmalloc(size, flags)
 #define free(ptr, type) kfree(ptr)
 
-static __inline void ahc_delay(long);
-static __inline void
-ahc_delay(long usec)
-{
-        /*
-         * udelay on Linux can have problems for
-         * multi-millisecond waits.  Wait at most
-         * 1024us per call.
-         */
-        while (usec > 0) {
-                udelay(usec % 1024);
-                usec -= 1024;
-        }
-}
+void ahc_delay(long);
 
 
 /***************************** Low Level I/O **********************************/
-static __inline uint8_t ahc_inb(struct ahc_softc * ahc, long port);
-static __inline void ahc_outb(struct ahc_softc * ahc, long port, uint8_t val);
-static __inline void ahc_outsb(struct ahc_softc * ahc, long port,
-                               uint8_t *, int count);
-static __inline void ahc_insb(struct ahc_softc * ahc, long port,
-                               uint8_t *, int count);
-
-static __inline uint8_t
-ahc_inb(struct ahc_softc * ahc, long port)
-{
-        uint8_t x;
-
-        if (ahc->tag == BUS_SPACE_MEMIO) {
-                x = readb(ahc->bsh.maddr + port);
-        } else {
-                x = inb(ahc->bsh.ioport + port);
-        }
-        mb();
-        return (x);
-}
-
-static __inline void
-ahc_outb(struct ahc_softc * ahc, long port, uint8_t val)
-{
-        if (ahc->tag == BUS_SPACE_MEMIO) {
-                writeb(val, ahc->bsh.maddr + port);
-        } else {
-                outb(val, ahc->bsh.ioport + port);
-        }
-        mb();
-}
-
-static __inline void
-ahc_outsb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
-{
-        int i;
-
-        /*
-         * There is probably a more efficient way to do this on Linux
-         * but we don't use this for anything speed critical and this
-         * should work.
-         */
-        for (i = 0; i < count; i++)
-                ahc_outb(ahc, port, *array++);
-}
-
-static __inline void
-ahc_insb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
-{
-        int i;
-
-        /*
-         * There is probably a more efficient way to do this on Linux
-         * but we don't use this for anything speed critical and this
-         * should work.
-         */
-        for (i = 0; i < count; i++)
-                *array++ = ahc_inb(ahc, port);
-}
+uint8_t ahc_inb(struct ahc_softc * ahc, long port);
+void ahc_outb(struct ahc_softc * ahc, long port, uint8_t val);
+void ahc_outsb(struct ahc_softc * ahc, long port,
+               uint8_t *, int count);
+void ahc_insb(struct ahc_softc * ahc, long port,
+               uint8_t *, int count);
 
 /**************************** Initialization **********************************/
 int             ahc_linux_register_host(struct ahc_softc *,
@@ -464,9 +398,6 @@ struct info_str {
         int pos;
 };
 
-void    ahc_format_transinfo(struct info_str *info,
-                             struct ahc_transinfo *tinfo);
-
 /******************************** Locking *************************************/
 /* Lock protecting internal data structures */
 
@@ -555,61 +486,12 @@ void			 ahc_linux_pci_exit(void);
 int                      ahc_pci_map_registers(struct ahc_softc *ahc);
 int                      ahc_pci_map_int(struct ahc_softc *ahc);
 
-static __inline uint32_t ahc_pci_read_config(ahc_dev_softc_t pci,
+uint32_t                 ahc_pci_read_config(ahc_dev_softc_t pci,
                                              int reg, int width);
 
-static __inline uint32_t
-ahc_pci_read_config(ahc_dev_softc_t pci, int reg, int width)
-{
-        switch (width) {
-        case 1:
-        {
-                uint8_t retval;
-
-                pci_read_config_byte(pci, reg, &retval);
-                return (retval);
-        }
-        case 2:
-        {
-                uint16_t retval;
-                pci_read_config_word(pci, reg, &retval);
-                return (retval);
-        }
-        case 4:
-        {
-                uint32_t retval;
-                pci_read_config_dword(pci, reg, &retval);
-                return (retval);
-        }
-        default:
-                panic("ahc_pci_read_config: Read size too big");
-                /* NOTREACHED */
-                return (0);
-        }
-}
-
-static __inline void ahc_pci_write_config(ahc_dev_softc_t pci,
-                                          int reg, uint32_t value,
-                                          int width);
-
-static __inline void
-ahc_pci_write_config(ahc_dev_softc_t pci, int reg, uint32_t value, int width)
-{
-        switch (width) {
-        case 1:
-                pci_write_config_byte(pci, reg, value);
-                break;
-        case 2:
-                pci_write_config_word(pci, reg, value);
-                break;
-        case 4:
-                pci_write_config_dword(pci, reg, value);
-                break;
-        default:
-                panic("ahc_pci_write_config: Write size too big");
-                /* NOTREACHED */
-        }
-}
+void                     ahc_pci_write_config(ahc_dev_softc_t pci,
+                                              int reg, uint32_t value,
+                                              int width);
 
 static __inline int ahc_get_pci_function(ahc_dev_softc_t);
 static __inline int
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
index 3d3eaef65fb3..0d7628f1f1ef 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
@@ -46,7 +46,7 @@
 */
 #define ID(x)   ID_C(x, PCI_CLASS_STORAGE_SCSI)
 
-static struct pci_device_id ahc_linux_pci_id_table[] = {
+static const struct pci_device_id ahc_linux_pci_id_table[] = {
         /* aic7850 based controllers */
         ID(ID_AHA_2902_04_10_15_20C_30C),
         /* aic7860 based controllers */
@@ -206,7 +206,7 @@ ahc_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         const uint64_t   mask_39bit = 0x7FFFFFFFFFULL;
         struct           ahc_softc *ahc;
         ahc_dev_softc_t  pci;
-        struct           ahc_pci_identity *entry;
+        const struct ahc_pci_identity *entry;
         char            *name;
         int              error;
         struct device   *dev = &pdev->dev;
@@ -269,6 +269,57 @@ ahc_linux_pci_dev_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         return (0);
 }
 
+/******************************* PCI Routines *********************************/
+uint32_t
+ahc_pci_read_config(ahc_dev_softc_t pci, int reg, int width)
+{
+        switch (width) {
+        case 1:
+        {
+                uint8_t retval;
+
+                pci_read_config_byte(pci, reg, &retval);
+                return (retval);
+        }
+        case 2:
+        {
+                uint16_t retval;
+                pci_read_config_word(pci, reg, &retval);
+                return (retval);
+        }
+        case 4:
+        {
+                uint32_t retval;
+                pci_read_config_dword(pci, reg, &retval);
+                return (retval);
+        }
+        default:
+                panic("ahc_pci_read_config: Read size too big");
+                /* NOTREACHED */
+                return (0);
+        }
+}
+
+void
+ahc_pci_write_config(ahc_dev_softc_t pci, int reg, uint32_t value, int width)
+{
+        switch (width) {
+        case 1:
+                pci_write_config_byte(pci, reg, value);
+                break;
+        case 2:
+                pci_write_config_word(pci, reg, value);
+                break;
+        case 4:
+                pci_write_config_dword(pci, reg, value);
+                break;
+        default:
+                panic("ahc_pci_write_config: Write size too big");
+                /* NOTREACHED */
+        }
+}
+
+
 static struct pci_driver aic7xxx_pci_driver = {
         .name           = "aic7xxx",
         .probe          = ahc_linux_pci_dev_probe,
@@ -293,7 +344,7 @@ ahc_linux_pci_exit(void)
 }
 
 static int
-ahc_linux_pci_reserve_io_region(struct ahc_softc *ahc, u_long *base)
+ahc_linux_pci_reserve_io_region(struct ahc_softc *ahc, resource_size_t *base)
 {
         if (aic7xxx_allow_memio == 0)
                 return (ENOMEM);
@@ -308,10 +359,10 @@ ahc_linux_pci_reserve_io_region(struct ahc_softc *ahc, u_long *base)
 
 static int
 ahc_linux_pci_reserve_mem_region(struct ahc_softc *ahc,
-                                 u_long *bus_addr,
+                                 resource_size_t *bus_addr,
                                  uint8_t __iomem **maddr)
 {
-        u_long  start;
+        resource_size_t start;
         int     error;
 
         error = 0;
@@ -336,7 +387,7 @@ int
 ahc_pci_map_registers(struct ahc_softc *ahc)
 {
         uint32_t command;
-        u_long   base;
+        resource_size_t base;
         uint8_t __iomem *maddr;
         int      error;
 
@@ -374,12 +425,12 @@ ahc_pci_map_registers(struct ahc_softc *ahc)
                 } else
                         command |= PCIM_CMD_MEMEN;
         } else {
-                printf("aic7xxx: PCI%d:%d:%d MEM region 0x%lx "
+                printf("aic7xxx: PCI%d:%d:%d MEM region 0x%llx "
                        "unavailable. Cannot memory map device.\n",
                        ahc_get_pci_bus(ahc->dev_softc),
                        ahc_get_pci_slot(ahc->dev_softc),
                        ahc_get_pci_function(ahc->dev_softc),
-                       base);
+                       (unsigned long long)base);
         }
 
         /*
@@ -390,15 +441,15 @@ ahc_pci_map_registers(struct ahc_softc *ahc)
                 error = ahc_linux_pci_reserve_io_region(ahc, &base);
                 if (error == 0) {
                         ahc->tag = BUS_SPACE_PIO;
-                        ahc->bsh.ioport = base;
+                        ahc->bsh.ioport = (u_long)base;
                         command |= PCIM_CMD_PORTEN;
                 } else {
-                        printf("aic7xxx: PCI%d:%d:%d IO region 0x%lx[0..255] "
+                        printf("aic7xxx: PCI%d:%d:%d IO region 0x%llx[0..255] "
                                "unavailable. Cannot map device.\n",
                                ahc_get_pci_bus(ahc->dev_softc),
                                ahc_get_pci_slot(ahc->dev_softc),
                                ahc_get_pci_function(ahc->dev_softc),
-                               base);
+                               (unsigned long long)base);
                 }
         }
         ahc_pci_write_config(ahc->dev_softc, PCIR_COMMAND, command, 4);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_pci.c b/drivers/scsi/aic7xxx/aic7xxx_pci.c
index 56848f41e4f9..c07cb6eebb02 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_pci.c
@@ -168,8 +168,7 @@ static ahc_device_setup_t ahc_aha394XX_setup;
 static ahc_device_setup_t ahc_aha494XX_setup;
 static ahc_device_setup_t ahc_aha398XX_setup;
 
-static struct ahc_pci_identity ahc_pci_ident_table [] =
-{
+static const struct ahc_pci_identity ahc_pci_ident_table[] = {
         /* aic7850 based controllers */
         {
                 ID_AHA_2902_04_10_15_20C_30C,
@@ -668,7 +667,7 @@ ahc_9005_subdevinfo_valid(uint16_t device, uint16_t vendor,
         return (result);
 }
 
-struct ahc_pci_identity *
+const struct ahc_pci_identity *
 ahc_find_pci_device(ahc_dev_softc_t pci)
 {
         uint64_t  full_id;
@@ -676,7 +675,7 @@ ahc_find_pci_device(ahc_dev_softc_t pci)
         uint16_t  vendor;
         uint16_t  subdevice;
         uint16_t  subvendor;
-        struct    ahc_pci_identity *entry;
+        const struct ahc_pci_identity *entry;
         u_int     i;
 
         vendor = ahc_pci_read_config(pci, PCIR_DEVVENDOR, /*bytes*/2);
@@ -710,7 +709,7 @@ ahc_find_pci_device(ahc_dev_softc_t pci)
 }
 
 int
-ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
+ahc_pci_config(struct ahc_softc *ahc, const struct ahc_pci_identity *entry)
 {
         u_int    command;
         u_int    our_id;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_proc.c b/drivers/scsi/aic7xxx/aic7xxx_proc.c
index 99e5443e7535..e92991a7c485 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_proc.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_proc.c
@@ -58,7 +58,7 @@ static int	ahc_proc_write_seeprom(struct ahc_softc *ahc,
  * Table of syncrates that don't follow the "divisible by 4"
  * rule. This table will be expanded in future SCSI specs.
  */
-static struct {
+static const struct {
         u_int period_factor;
         u_int period;   /* in 100ths of ns */
 } scsi_syncrates[] = {
@@ -137,7 +137,7 @@ copy_info(struct info_str *info, char *fmt, ...)
         return (len);
 }
 
-void
+static void
 ahc_format_transinfo(struct info_str *info, struct ahc_transinfo *tinfo)
 {
         u_int speed;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped b/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
index 88bfd767c51c..309a562b009e 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
+++ b/drivers/scsi/aic7xxx/aic7xxx_reg_print.c_shipped
@@ -8,7 +8,7 @@
 
 #include "aic7xxx_osm.h"
 
-static ahc_reg_parse_entry_t SCSISEQ_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSISEQ_parse_table[] = {
         { "SCSIRSTO",           0x01, 0x01 },
         { "ENAUTOATNP",         0x02, 0x02 },
         { "ENAUTOATNI",         0x04, 0x04 },
@@ -26,7 +26,7 @@ ahc_scsiseq_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x00, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SXFRCTL0_parse_table[] = {
+static const ahc_reg_parse_entry_t SXFRCTL0_parse_table[] = {
         { "CLRCHN",             0x02, 0x02 },
         { "SCAMEN",             0x04, 0x04 },
         { "SPIOEN",             0x08, 0x08 },
@@ -43,7 +43,7 @@ ahc_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x01, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SXFRCTL1_parse_table[] = {
+static const ahc_reg_parse_entry_t SXFRCTL1_parse_table[] = {
         { "STPWEN",             0x01, 0x01 },
         { "ACTNEGEN",           0x02, 0x02 },
         { "ENSTIMER",           0x04, 0x04 },
@@ -60,7 +60,7 @@ ahc_sxfrctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x02, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSISIGO_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSISIGO_parse_table[] = {
         { "ACKO",               0x01, 0x01 },
         { "REQO",               0x02, 0x02 },
         { "BSYO",               0x04, 0x04 },
@@ -85,7 +85,7 @@ ahc_scsisigo_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x03, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSISIGI_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSISIGI_parse_table[] = {
         { "ACKI",               0x01, 0x01 },
         { "REQI",               0x02, 0x02 },
         { "BSYI",               0x04, 0x04 },
@@ -112,7 +112,7 @@ ahc_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x03, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSIRATE_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSIRATE_parse_table[] = {
         { "SINGLE_EDGE",        0x10, 0x10 },
         { "ENABLE_CRC",         0x40, 0x40 },
         { "WIDEXFER",           0x80, 0x80 },
@@ -128,7 +128,7 @@ ahc_scsirate_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x04, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSIID_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSIID_parse_table[] = {
         { "TWIN_CHNLB",         0x80, 0x80 },
         { "OID",                0x0f, 0x0f },
         { "TWIN_TID",           0x70, 0x70 },
@@ -151,20 +151,13 @@ ahc_scsidatl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_scsidath_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "SCSIDATH",
-            0x07, regvalue, cur_col, wrap));
-}
-
-int
 ahc_stcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "STCNT",
             0x08, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t OPTIONMODE_parse_table[] = {
+static const ahc_reg_parse_entry_t OPTIONMODE_parse_table[] = {
         { "DIS_MSGIN_DUALEDGE", 0x01, 0x01 },
         { "AUTO_MSGOUT_DE",     0x02, 0x02 },
         { "SCSIDATL_IMGEN",     0x04, 0x04 },
@@ -190,7 +183,7 @@ ahc_targcrccnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0a, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CLRSINT0_parse_table[] = {
+static const ahc_reg_parse_entry_t CLRSINT0_parse_table[] = {
         { "CLRSPIORDY",         0x02, 0x02 },
         { "CLRSWRAP",           0x08, 0x08 },
         { "CLRIOERR",           0x08, 0x08 },
@@ -206,7 +199,7 @@ ahc_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0b, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SSTAT0_parse_table[] = {
+static const ahc_reg_parse_entry_t SSTAT0_parse_table[] = {
         { "DMADONE",            0x01, 0x01 },
         { "SPIORDY",            0x02, 0x02 },
         { "SDONE",              0x04, 0x04 },
@@ -225,7 +218,7 @@ ahc_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0b, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CLRSINT1_parse_table[] = {
+static const ahc_reg_parse_entry_t CLRSINT1_parse_table[] = {
         { "CLRREQINIT",         0x01, 0x01 },
         { "CLRPHASECHG",        0x02, 0x02 },
         { "CLRSCSIPERR",        0x04, 0x04 },
@@ -242,7 +235,7 @@ ahc_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0c, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SSTAT1_parse_table[] = {
+static const ahc_reg_parse_entry_t SSTAT1_parse_table[] = {
         { "REQINIT",            0x01, 0x01 },
         { "PHASECHG",           0x02, 0x02 },
         { "SCSIPERR",           0x04, 0x04 },
@@ -260,7 +253,7 @@ ahc_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0c, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SSTAT2_parse_table[] = {
+static const ahc_reg_parse_entry_t SSTAT2_parse_table[] = {
         { "DUAL_EDGE_ERR",      0x01, 0x01 },
         { "CRCREQERR",          0x02, 0x02 },
         { "CRCENDERR",          0x04, 0x04 },
@@ -278,7 +271,7 @@ ahc_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0d, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SSTAT3_parse_table[] = {
+static const ahc_reg_parse_entry_t SSTAT3_parse_table[] = {
         { "OFFCNT",             0x0f, 0x0f },
         { "U2OFFCNT",           0x7f, 0x7f },
         { "SCSICNT",            0xf0, 0xf0 }
@@ -291,7 +284,7 @@ ahc_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0e, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSIID_ULTRA2_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSIID_ULTRA2_parse_table[] = {
         { "OID",                0x0f, 0x0f },
         { "TID",                0xf0, 0xf0 }
 };
@@ -303,7 +296,7 @@ ahc_scsiid_ultra2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x0f, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SIMODE0_parse_table[] = {
+static const ahc_reg_parse_entry_t SIMODE0_parse_table[] = {
         { "ENDMADONE",          0x01, 0x01 },
         { "ENSPIORDY",          0x02, 0x02 },
         { "ENSDONE",            0x04, 0x04 },
@@ -321,7 +314,7 @@ ahc_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x10, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SIMODE1_parse_table[] = {
+static const ahc_reg_parse_entry_t SIMODE1_parse_table[] = {
         { "ENREQINIT",          0x01, 0x01 },
         { "ENPHASECHG",         0x02, 0x02 },
         { "ENSCSIPERR",         0x04, 0x04 },
@@ -347,33 +340,13 @@ ahc_scsibusl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_scsibush_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "SCSIBUSH",
-            0x13, regvalue, cur_col, wrap));
-}
-
-static ahc_reg_parse_entry_t SXFRCTL2_parse_table[] = {
-        { "CMDDMAEN",           0x08, 0x08 },
-        { "AUTORSTDIS",         0x10, 0x10 },
-        { "ASYNC_SETUP",        0x07, 0x07 }
-};
-
-int
-ahc_sxfrctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(SXFRCTL2_parse_table, 3, "SXFRCTL2",
-            0x13, regvalue, cur_col, wrap));
-}
-
-int
 ahc_shaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "SHADDR",
             0x14, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SELTIMER_parse_table[] = {
+static const ahc_reg_parse_entry_t SELTIMER_parse_table[] = {
         { "STAGE1",             0x01, 0x01 },
         { "STAGE2",             0x02, 0x02 },
         { "STAGE3",             0x04, 0x04 },
@@ -389,7 +362,7 @@ ahc_seltimer_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x18, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SELID_parse_table[] = {
+static const ahc_reg_parse_entry_t SELID_parse_table[] = {
         { "ONEBIT",             0x08, 0x08 },
         { "SELID_MASK",         0xf0, 0xf0 }
 };
@@ -401,21 +374,6 @@ ahc_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x19, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCAMCTL_parse_table[] = {
-        { "DFLTTID",            0x10, 0x10 },
-        { "ALTSTIM",            0x20, 0x20 },
-        { "CLRSCAMSELID",       0x40, 0x40 },
-        { "ENSCAMSELO",         0x80, 0x80 },
-        { "SCAMLVL",            0x03, 0x03 }
-};
-
-int
-ahc_scamctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(SCAMCTL_parse_table, 5, "SCAMCTL",
-            0x1a, regvalue, cur_col, wrap));
-}
-
 int
 ahc_targid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
@@ -423,7 +381,7 @@ ahc_targid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1b, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SPIOCAP_parse_table[] = {
+static const ahc_reg_parse_entry_t SPIOCAP_parse_table[] = {
         { "SSPIOCPS",           0x01, 0x01 },
         { "ROM",                0x02, 0x02 },
         { "EEPROM",             0x04, 0x04 },
@@ -441,7 +399,7 @@ ahc_spiocap_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1b, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t BRDCTL_parse_table[] = {
+static const ahc_reg_parse_entry_t BRDCTL_parse_table[] = {
         { "BRDCTL0",            0x01, 0x01 },
         { "BRDSTB_ULTRA2",      0x01, 0x01 },
         { "BRDCTL1",            0x02, 0x02 },
@@ -464,7 +422,7 @@ ahc_brdctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1d, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SEECTL_parse_table[] = {
+static const ahc_reg_parse_entry_t SEECTL_parse_table[] = {
         { "SEEDI",              0x01, 0x01 },
         { "SEEDO",              0x02, 0x02 },
         { "SEECK",              0x04, 0x04 },
@@ -482,7 +440,7 @@ ahc_seectl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x1e, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SBLKCTL_parse_table[] = {
+static const ahc_reg_parse_entry_t SBLKCTL_parse_table[] = {
         { "XCVR",               0x01, 0x01 },
         { "SELWIDE",            0x02, 0x02 },
         { "ENAB20",             0x04, 0x04 },
@@ -522,13 +480,6 @@ ahc_disc_dsb_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_cmdsize_table_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "CMDSIZE_TABLE_TAIL",
-            0x34, regvalue, cur_col, wrap));
-}
-
-int
 ahc_mwi_residual_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "MWI_RESIDUAL",
@@ -549,7 +500,7 @@ ahc_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3a, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DMAPARAMS_parse_table[] = {
+static const ahc_reg_parse_entry_t DMAPARAMS_parse_table[] = {
         { "FIFORESET",          0x01, 0x01 },
         { "FIFOFLUSH",          0x02, 0x02 },
         { "DIRECTION",          0x04, 0x04 },
@@ -569,7 +520,7 @@ ahc_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3b, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
+static const ahc_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
         { "NO_DISCONNECT",      0x01, 0x01 },
         { "SPHASE_PENDING",     0x02, 0x02 },
         { "DPHASE_PENDING",     0x04, 0x04 },
@@ -602,7 +553,7 @@ ahc_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x3e, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t LASTPHASE_parse_table[] = {
+static const ahc_reg_parse_entry_t LASTPHASE_parse_table[] = {
         { "MSGI",               0x20, 0x20 },
         { "IOI",                0x40, 0x40 },
         { "CDI",                0x80, 0x80 },
@@ -645,13 +596,6 @@ ahc_free_scbh_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_complete_scbh_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "COMPLETE_SCBH",
-            0x43, regvalue, cur_col, wrap));
-}
-
-int
 ahc_hscb_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "HSCB_ADDR",
@@ -700,7 +644,7 @@ ahc_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x50, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t ARG_1_parse_table[] = {
+static const ahc_reg_parse_entry_t ARG_1_parse_table[] = {
         { "CONT_TARG_SESSION",  0x02, 0x02 },
         { "CONT_MSG_LOOP",      0x04, 0x04 },
         { "EXIT_MSG_LOOP",      0x08, 0x08 },
@@ -731,7 +675,7 @@ ahc_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x53, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
         { "ENAUTOATNP",         0x02, 0x02 },
         { "ENAUTOATNI",         0x04, 0x04 },
         { "ENAUTOATNO",         0x08, 0x08 },
@@ -747,7 +691,7 @@ ahc_scsiseq_template_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x54, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t HA_274_BIOSGLOBAL_parse_table[] = {
+static const ahc_reg_parse_entry_t HA_274_BIOSGLOBAL_parse_table[] = {
         { "HA_274_EXTENDED_TRANS",0x01, 0x01 }
 };
 
@@ -758,7 +702,7 @@ ahc_ha_274_biosglobal_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x56, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
+static const ahc_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
         { "SCB_DMA",            0x01, 0x01 },
         { "TARGET_MSG_PENDING", 0x02, 0x02 }
 };
@@ -770,7 +714,7 @@ ahc_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x57, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCSICONF_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSICONF_parse_table[] = {
         { "ENSPCHK",            0x20, 0x20 },
         { "RESET_SCSI",         0x40, 0x40 },
         { "TERM_ENB",           0x80, 0x80 },
@@ -785,7 +729,7 @@ ahc_scsiconf_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5a, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t INTDEF_parse_table[] = {
+static const ahc_reg_parse_entry_t INTDEF_parse_table[] = {
         { "EDGE_TRIG",          0x80, 0x80 },
         { "VECTOR",             0x0f, 0x0f }
 };
@@ -804,7 +748,7 @@ ahc_hostconf_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5d, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t HA_274_BIOSCTRL_parse_table[] = {
+static const ahc_reg_parse_entry_t HA_274_BIOSCTRL_parse_table[] = {
         { "CHANNEL_B_PRIMARY",  0x08, 0x08 },
         { "BIOSMODE",           0x30, 0x30 },
         { "BIOSDISABLED",       0x30, 0x30 }
@@ -817,7 +761,7 @@ ahc_ha_274_biosctrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x5f, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SEQCTL_parse_table[] = {
+static const ahc_reg_parse_entry_t SEQCTL_parse_table[] = {
         { "LOADRAM",            0x01, 0x01 },
         { "SEQRESET",           0x02, 0x02 },
         { "STEP",               0x04, 0x04 },
@@ -849,7 +793,7 @@ ahc_seqaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x62, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SEQADDR1_parse_table[] = {
+static const ahc_reg_parse_entry_t SEQADDR1_parse_table[] = {
         { "SEQADDR1_MASK",      0x01, 0x01 }
 };
 
@@ -902,7 +846,7 @@ ahc_none_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x6a, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t FLAGS_parse_table[] = {
+static const ahc_reg_parse_entry_t FLAGS_parse_table[] = {
         { "CARRY",              0x01, 0x01 },
         { "ZERO",               0x02, 0x02 }
 };
@@ -929,13 +873,6 @@ ahc_dindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_function1_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "FUNCTION1",
-            0x6e, regvalue, cur_col, wrap));
-}
-
-int
 ahc_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "STACK",
@@ -956,19 +893,7 @@ ahc_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x70, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t BCTL_parse_table[] = {
-        { "ENABLE",             0x01, 0x01 },
-        { "ACE",                0x08, 0x08 }
-};
-
-int
-ahc_bctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(BCTL_parse_table, 2, "BCTL",
-            0x84, regvalue, cur_col, wrap));
-}
-
-static ahc_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
+static const ahc_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
         { "CIOPARCKEN",         0x01, 0x01 },
         { "USCBSIZE32",         0x02, 0x02 },
         { "RAMPS",              0x04, 0x04 },
@@ -986,7 +911,7 @@ ahc_dscommand0_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x84, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t BUSTIME_parse_table[] = {
+static const ahc_reg_parse_entry_t BUSTIME_parse_table[] = {
         { "BON",                0x0f, 0x0f },
         { "BOFF",               0xf0, 0xf0 }
 };
@@ -998,7 +923,7 @@ ahc_bustime_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x85, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DSCOMMAND1_parse_table[] = {
+static const ahc_reg_parse_entry_t DSCOMMAND1_parse_table[] = {
         { "HADDLDSEL0",         0x01, 0x01 },
         { "HADDLDSEL1",         0x02, 0x02 },
         { "DSLATT",             0xfc, 0xfc }
@@ -1011,7 +936,7 @@ ahc_dscommand1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x85, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t BUSSPD_parse_table[] = {
+static const ahc_reg_parse_entry_t BUSSPD_parse_table[] = {
         { "STBON",              0x07, 0x07 },
         { "STBOFF",             0x38, 0x38 },
         { "DFTHRSH_75",         0x80, 0x80 },
@@ -1026,7 +951,7 @@ ahc_busspd_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x86, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
+static const ahc_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
         { "SEQ_MAILBOX",        0x0f, 0x0f },
         { "HOST_TQINPOS",       0x80, 0x80 },
         { "HOST_MAILBOX",       0xf0, 0xf0 }
@@ -1039,7 +964,7 @@ ahc_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x86, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DSPCISTATUS_parse_table[] = {
+static const ahc_reg_parse_entry_t DSPCISTATUS_parse_table[] = {
         { "DFTHRSH_100",        0xc0, 0xc0 }
 };
 
@@ -1050,7 +975,7 @@ ahc_dspcistatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x86, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t HCNTRL_parse_table[] = {
+static const ahc_reg_parse_entry_t HCNTRL_parse_table[] = {
         { "CHIPRST",            0x01, 0x01 },
         { "CHIPRSTACK",         0x01, 0x01 },
         { "INTEN",              0x02, 0x02 },
@@ -1088,7 +1013,7 @@ ahc_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x90, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t INTSTAT_parse_table[] = {
+static const ahc_reg_parse_entry_t INTSTAT_parse_table[] = {
         { "SEQINT",             0x01, 0x01 },
         { "CMDCMPLT",           0x02, 0x02 },
         { "SCSIINT",            0x04, 0x04 },
@@ -1119,7 +1044,7 @@ ahc_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x91, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CLRINT_parse_table[] = {
+static const ahc_reg_parse_entry_t CLRINT_parse_table[] = {
         { "CLRSEQINT",          0x01, 0x01 },
         { "CLRCMDINT",          0x02, 0x02 },
         { "CLRSCSIINT",         0x04, 0x04 },
@@ -1134,7 +1059,7 @@ ahc_clrint_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x92, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t ERROR_parse_table[] = {
+static const ahc_reg_parse_entry_t ERROR_parse_table[] = {
         { "ILLHADDR",           0x01, 0x01 },
         { "ILLSADDR",           0x02, 0x02 },
         { "ILLOPCODE",          0x04, 0x04 },
@@ -1152,7 +1077,7 @@ ahc_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x92, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DFCNTRL_parse_table[] = {
+static const ahc_reg_parse_entry_t DFCNTRL_parse_table[] = {
         { "FIFORESET",          0x01, 0x01 },
         { "FIFOFLUSH",          0x02, 0x02 },
         { "DIRECTION",          0x04, 0x04 },
@@ -1172,7 +1097,7 @@ ahc_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x93, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DFSTATUS_parse_table[] = {
+static const ahc_reg_parse_entry_t DFSTATUS_parse_table[] = {
         { "FIFOEMP",            0x01, 0x01 },
         { "FIFOFULL",           0x02, 0x02 },
         { "DFTHRESH",           0x04, 0x04 },
@@ -1198,20 +1123,13 @@ ahc_dfwaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_dfraddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "DFRADDR",
-            0x97, regvalue, cur_col, wrap));
-}
-
-int
 ahc_dfdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "DFDAT",
             0x99, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCBCNT_parse_table[] = {
+static const ahc_reg_parse_entry_t SCBCNT_parse_table[] = {
         { "SCBAUTO",            0x80, 0x80 },
         { "SCBCNT_MASK",        0x1f, 0x1f }
 };
@@ -1231,20 +1149,13 @@ ahc_qinfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
 }
 
 int
-ahc_qincnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "QINCNT",
-            0x9c, regvalue, cur_col, wrap));
-}
-
-int
 ahc_qoutfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
 {
         return (ahc_print_register(NULL, 0, "QOUTFIFO",
             0x9d, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CRCCONTROL1_parse_table[] = {
+static const ahc_reg_parse_entry_t CRCCONTROL1_parse_table[] = {
         { "TARGCRCCNTEN",       0x04, 0x04 },
         { "TARGCRCENDEN",       0x08, 0x08 },
         { "CRCREQCHKEN",        0x10, 0x10 },
@@ -1260,14 +1171,7 @@ ahc_crccontrol1_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x9d, regvalue, cur_col, wrap));
 }
 
-int
-ahc_qoutcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "QOUTCNT",
-            0x9e, regvalue, cur_col, wrap));
-}
-
-static ahc_reg_parse_entry_t SCSIPHASE_parse_table[] = {
+static const ahc_reg_parse_entry_t SCSIPHASE_parse_table[] = {
         { "DATA_OUT_PHASE",     0x01, 0x01 },
         { "DATA_IN_PHASE",      0x02, 0x02 },
         { "MSG_OUT_PHASE",      0x04, 0x04 },
@@ -1284,7 +1188,7 @@ ahc_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0x9e, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SFUNCT_parse_table[] = {
+static const ahc_reg_parse_entry_t SFUNCT_parse_table[] = {
         { "ALT_MODE",           0x80, 0x80 }
 };
 
@@ -1351,7 +1255,7 @@ ahc_scb_dataptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xac, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
+static const ahc_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
         { "SG_LAST_SEG",        0x80, 0x80 },
         { "SG_HIGH_ADDR_BITS",  0x7f, 0x7f }
 };
@@ -1363,7 +1267,7 @@ ahc_scb_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xb0, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
+static const ahc_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
         { "SG_LIST_NULL",       0x01, 0x01 },
         { "SG_FULL_RESID",      0x02, 0x02 },
         { "SG_RESID_VALID",     0x04, 0x04 }
@@ -1376,7 +1280,7 @@ ahc_scb_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xb4, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
+static const ahc_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
         { "DISCONNECTED",       0x04, 0x04 },
         { "ULTRAENB",           0x08, 0x08 },
         { "MK_MESSAGE",         0x10, 0x10 },
@@ -1394,7 +1298,7 @@ ahc_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xb8, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
+static const ahc_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
         { "TWIN_CHNLB",         0x80, 0x80 },
         { "OID",                0x0f, 0x0f },
         { "TWIN_TID",           0x70, 0x70 },
@@ -1408,7 +1312,7 @@ ahc_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xb9, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SCB_LUN_parse_table[] = {
+static const ahc_reg_parse_entry_t SCB_LUN_parse_table[] = {
         { "SCB_XFERLEN_ODD",    0x80, 0x80 },
         { "LID",                0x3f, 0x3f }
 };
@@ -1455,14 +1359,7 @@ ahc_scb_next_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xbf, regvalue, cur_col, wrap));
 }
 
-int
-ahc_scb_64_spare_print(u_int regvalue, u_int *cur_col, u_int wrap)
-{
-        return (ahc_print_register(NULL, 0, "SCB_64_SPARE",
-            0xc0, regvalue, cur_col, wrap));
-}
-
-static ahc_reg_parse_entry_t SEECTL_2840_parse_table[] = {
+static const ahc_reg_parse_entry_t SEECTL_2840_parse_table[] = {
         { "DO_2840",            0x01, 0x01 },
         { "CK_2840",            0x02, 0x02 },
         { "CS_2840",            0x04, 0x04 }
@@ -1475,7 +1372,7 @@ ahc_seectl_2840_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xc0, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t STATUS_2840_parse_table[] = {
+static const ahc_reg_parse_entry_t STATUS_2840_parse_table[] = {
         { "DI_2840",            0x01, 0x01 },
         { "EEPROM_TF",          0x80, 0x80 },
         { "ADSEL",              0x1e, 0x1e },
@@ -1524,7 +1421,7 @@ ahc_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xea, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CCSGCTL_parse_table[] = {
+static const ahc_reg_parse_entry_t CCSGCTL_parse_table[] = {
         { "CCSGRESET",          0x01, 0x01 },
         { "SG_FETCH_NEEDED",    0x02, 0x02 },
         { "CCSGEN",             0x08, 0x08 },
@@ -1552,7 +1449,7 @@ ahc_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xed, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t CCSCBCTL_parse_table[] = {
+static const ahc_reg_parse_entry_t CCSCBCTL_parse_table[] = {
         { "CCSCBRESET",         0x01, 0x01 },
         { "CCSCBDIR",           0x04, 0x04 },
         { "CCSCBEN",            0x08, 0x08 },
@@ -1610,7 +1507,7 @@ ahc_sdscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xf8, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
+static const ahc_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
         { "SDSCB_ROLLOVER",     0x10, 0x10 },
         { "SNSCB_ROLLOVER",     0x20, 0x20 },
         { "SCB_AVAIL",          0x40, 0x40 },
@@ -1625,7 +1522,7 @@ ahc_qoff_ctlsta_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xfa, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t DFF_THRSH_parse_table[] = {
+static const ahc_reg_parse_entry_t DFF_THRSH_parse_table[] = {
         { "RD_DFTHRSH_MIN",     0x00, 0x00 },
         { "WR_DFTHRSH_MIN",     0x00, 0x00 },
         { "RD_DFTHRSH_25",      0x01, 0x01 },
@@ -1653,7 +1550,7 @@ ahc_dff_thrsh_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xfb, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
+static const ahc_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
         { "LAST_SEG_DONE",      0x01, 0x01 },
         { "LAST_SEG",           0x02, 0x02 },
         { "SG_ADDR_MASK",       0xf8, 0xf8 }
@@ -1666,7 +1563,7 @@ ahc_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
             0xfc, regvalue, cur_col, wrap));
 }
 
-static ahc_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
+static const ahc_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
         { "LAST_SEG_DONE",      0x01, 0x01 },
         { "LAST_SEG",           0x02, 0x02 },
         { "SG_ADDR_MASK",       0xf8, 0xf8 }
diff --git a/drivers/scsi/aic7xxx/aic7xxx_seq.h_shipped b/drivers/scsi/aic7xxx/aic7xxx_seq.h_shipped
index 4cee08521e75..07e93fbae706 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_seq.h_shipped
+++ b/drivers/scsi/aic7xxx/aic7xxx_seq.h_shipped
@@ -5,7 +5,7 @@
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.seq#58 $
  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#40 $
  */
-static uint8_t seqprog[] = {
+static const uint8_t seqprog[] = {
         0xb2, 0x00, 0x00, 0x08,
         0xf7, 0x11, 0x22, 0x08,
         0x00, 0x65, 0xee, 0x59,
@@ -1081,7 +1081,7 @@ ahc_patch0_func(struct ahc_softc *ahc)
         return (0);
 }
 
-static struct patch {
+static const struct patch {
         ahc_patch_func_t                *patch_func;
         uint32_t                 begin          :10,
                                  skip_instr     :10,
@@ -1291,7 +1291,7 @@ static struct patch {
         { ahc_patch4_func, 865, 12, 1 }
 };
 
-static struct cs {
+static const struct cs {
         uint16_t        begin;
         uint16_t        end;
 } critical_sections[] = {
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm.c b/drivers/scsi/aic7xxx/aicasm/aicasm.c
index 924102720b14..e4a778720301 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm.c
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm.c
@@ -362,7 +362,7 @@ output_code()
 " *\n"
 "%s */\n", versions);
 
-        fprintf(ofile, "static uint8_t seqprog[] = {\n");
+        fprintf(ofile, "static const uint8_t seqprog[] = {\n");
         for (cur_instr = STAILQ_FIRST(&seq_program);
              cur_instr != NULL;
              cur_instr = STAILQ_NEXT(cur_instr, links)) {
@@ -415,7 +415,7 @@ output_code()
         }
 
         fprintf(ofile,
-"static struct patch {\n"
+"static const struct patch {\n"
 "       %spatch_func_t          *patch_func;\n"
 "       uint32_t                 begin          :10,\n"
 "                                skip_instr     :10,\n"
@@ -435,7 +435,7 @@ output_code()
         fprintf(ofile, "\n};\n\n");
 
         fprintf(ofile,
-"static struct cs {\n"
+"static const struct cs {\n"
 "       uint16_t        begin;\n"
 "       uint16_t        end;\n"
 "} critical_sections[] = {\n");
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y b/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
index 702e2dbd11fb..81be6a261cc8 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y
@@ -101,11 +101,12 @@ static void format_3_instr(int opcode, symbol_ref_t *src,
                            expression_t *immed, symbol_ref_t *address);
 static void test_readable_symbol(symbol_t *symbol);
 static void test_writable_symbol(symbol_t *symbol);
-static void type_check(symbol_t *symbol, expression_t *expression, int and_op);
+static void type_check(symbol_ref_t *sym, expression_t *expression, int and_op);
 static void make_expression(expression_t *immed, int value);
 static void add_conditional(symbol_t *symbol);
 static void add_version(const char *verstring);
 static int  is_download_const(expression_t *immed);
+static int  is_location_address(symbol_t *symbol);
 void yyerror(const char *string);
 
 #define SRAM_SYMNAME "SRAM_BASE"
@@ -142,6 +143,8 @@ void yyerror(const char *string);
 
 %token <value> T_ADDRESS
 
+%token T_COUNT
+
 %token T_ACCESS_MODE
 
 %token T_MODES
@@ -192,10 +195,10 @@ void yyerror(const char *string);
 
 %token <value> T_OR
 
-/* 16 bit extensions */
-%token <value> T_OR16 T_AND16 T_XOR16 T_ADD16
-%token <value> T_ADC16 T_MVI16 T_TEST16 T_CMP16 T_CMPXCHG
-
+/* 16 bit extensions, not implemented
+ * %token <value> T_OR16 T_AND16 T_XOR16 T_ADD16
+ * %token <value> T_ADC16 T_MVI16 T_TEST16 T_CMP16 T_CMPXCHG
+ */
 %token T_RET
 
 %token T_NOP
@@ -214,7 +217,7 @@ void yyerror(const char *string);
 
 %type <expression> expression immediate immediate_or_a
 
-%type <value> export ret f1_opcode f2_opcode f4_opcode jmp_jc_jnc_call jz_jnz je_jne
+%type <value> export ret f1_opcode f2_opcode jmp_jc_jnc_call jz_jnz je_jne
 
 %type <value> mode_value mode_list macro_arglist
 
@@ -313,13 +316,13 @@ reg_definition:
                                 stop("Register multiply defined", EX_DATAERR);
                                 /* NOTREACHED */
                         }
-                        cur_symbol = $1; 
+                        cur_symbol = $1;
                         cur_symbol->type = cur_symtype;
                         initialize_symbol(cur_symbol);
                 }
                 reg_attribute_list
         '}'
-                {                    
+                {
                         /*
                          * Default to allowing everything in for registers
                          * with no bit or mask definitions.
@@ -349,9 +352,10 @@ reg_attribute_list:
 |       reg_attribute_list reg_attribute
 ;
 
-reg_attribute:          
+reg_attribute:
         reg_address
 |       size
+|       count
 |       access_mode
 |       modes
 |       field_defn
@@ -392,6 +396,13 @@ size:
         }
 ;
 
+count:
+        T_COUNT T_NUMBER
+        {
+                cur_symbol->count += $2;
+        }
+;
+
 access_mode:
         T_ACCESS_MODE T_MODE
         {
@@ -641,14 +652,14 @@ expression:
                                &($1.referenced_syms),
                                &($3.referenced_syms));
         }
-|       expression T_EXPR_LSHIFT expression
+|       expression T_EXPR_LSHIFT expression
         {
                 $$.value = $1.value << $3.value;
                 symlist_merge(&$$.referenced_syms,
                                &$1.referenced_syms,
                                &$3.referenced_syms);
         }
-|       expression T_EXPR_RSHIFT expression
+|       expression T_EXPR_RSHIFT expression
         {
                 $$.value = $1.value >> $3.value;
                 symlist_merge(&$$.referenced_syms,
@@ -714,7 +725,7 @@ expression:
 ;
 
 constant:
-        T_CONST T_SYMBOL expression 
+        T_CONST T_SYMBOL expression
         {
                 if ($2->type != UNINITIALIZED) {
                         stop("Re-definition of symbol as a constant",
@@ -800,6 +811,7 @@ scratch_ram:
                         cur_symtype = SRAMLOC;
                         cur_symbol->type = SRAMLOC;
                         initialize_symbol(cur_symbol);
+                        cur_symbol->count += 1;
                 }
                 reg_address
                 {
@@ -831,6 +843,7 @@ scb:
                         initialize_symbol(cur_symbol);
                         /* 64 bytes of SCB space */
                         cur_symbol->info.rinfo->size = 64;
+                        cur_symbol->count += 1;
                 }
                 reg_address
                 {
@@ -1311,14 +1324,18 @@ f2_opcode:
 |       T_ROR { $$ = AIC_OP_ROR; }
 ;
 
-f4_opcode:
-        T_OR16  { $$ = AIC_OP_OR16; }
-|       T_AND16 { $$ = AIC_OP_AND16; }
-|       T_XOR16 { $$ = AIC_OP_XOR16; }
-|       T_ADD16 { $$ = AIC_OP_ADD16; }
-|       T_ADC16 { $$ = AIC_OP_ADC16; }
-|       T_MVI16 { $$ = AIC_OP_MVI16; }
-;
+/*
+ * 16bit opcodes, not used
+ *
+ *f4_opcode:
+ *      T_OR16  { $$ = AIC_OP_OR16; }
+ *|     T_AND16 { $$ = AIC_OP_AND16; }
+ *|     T_XOR16 { $$ = AIC_OP_XOR16; }
+ *|     T_ADD16 { $$ = AIC_OP_ADD16; }
+ *|     T_ADC16 { $$ = AIC_OP_ADC16; }
+ *|     T_MVI16 { $$ = AIC_OP_MVI16; }
+ *;
+ */
 
 code:
         f2_opcode destination ',' expression opt_source ret ';'
@@ -1357,6 +1374,7 @@ code:
 code:
         T_OR reg_symbol ',' immediate jmp_jc_jnc_call address ';'
         {
+                type_check(&$2, &$4, AIC_OP_OR);
                 format_3_instr($5, &$2, &$4, &$6);
         }
 ;
@@ -1528,7 +1546,7 @@ initialize_symbol(symbol_t *symbol)
                        sizeof(struct cond_info));
                 break;
         case MACRO:
-                symbol->info.macroinfo = 
+                symbol->info.macroinfo =
                     (struct macro_info *)malloc(sizeof(struct macro_info));
                 if (symbol->info.macroinfo == NULL) {
                         stop("Can't create macro info", EX_SOFTWARE);
@@ -1552,7 +1570,6 @@ add_macro_arg(const char *argtext, int argnum)
         struct macro_arg *marg;
         int i;
         int retval;
-                
 
         if (cur_symbol == NULL || cur_symbol->type != MACRO) {
                 stop("Invalid current symbol for adding macro arg",
@@ -1633,8 +1650,10 @@ format_1_instr(int opcode, symbol_ref_t *dest, expression_t *immed,
         test_writable_symbol(dest->symbol);
         test_readable_symbol(src->symbol);
 
-        /* Ensure that immediate makes sense for this destination */
-        type_check(dest->symbol, immed, opcode);
+        if (!is_location_address(dest->symbol)) {
+                /* Ensure that immediate makes sense for this destination */
+                type_check(dest, immed, opcode);
+        }
 
         /* Allocate sequencer space for the instruction and fill it out */
         instr = seq_alloc();
@@ -1766,9 +1785,6 @@ format_3_instr(int opcode, symbol_ref_t *src,
         /* Test register permissions */
         test_readable_symbol(src->symbol);
 
-        /* Ensure that immediate makes sense for this source */
-        type_check(src->symbol, immed, opcode);
-
         /* Allocate sequencer space for the instruction and fill it out */
         instr = seq_alloc();
         f3_instr = &instr->format.format3;
@@ -1797,7 +1813,6 @@ format_3_instr(int opcode, symbol_ref_t *src,
 static void
 test_readable_symbol(symbol_t *symbol)
 {
-        
         if ((symbol->info.rinfo->modes & (0x1 << src_mode)) == 0) {
                 snprintf(errbuf, sizeof(errbuf),
                         "Register %s unavailable in source reg mode %d",
@@ -1815,7 +1830,6 @@ test_readable_symbol(symbol_t *symbol)
 static void
 test_writable_symbol(symbol_t *symbol)
 {
-        
         if ((symbol->info.rinfo->modes & (0x1 << dst_mode)) == 0) {
                 snprintf(errbuf, sizeof(errbuf),
                         "Register %s unavailable in destination reg mode %d",
@@ -1831,25 +1845,34 @@ test_writable_symbol(symbol_t *symbol)
 }
 
 static void
-type_check(symbol_t *symbol, expression_t *expression, int opcode)
+type_check(symbol_ref_t *sym, expression_t *expression, int opcode)
 {
+        symbol_t *symbol = sym->symbol;
         symbol_node_t *node;
         int and_op;
+        int8_t value, mask;
 
         and_op = FALSE;
-        if (opcode == AIC_OP_AND || opcode == AIC_OP_JNZ || opcode == AIC_OP_JZ)
-                and_op = TRUE;
-
         /*
          * Make sure that we aren't attempting to write something
          * that hasn't been defined.  If this is an and operation,
          * this is a mask, so "undefined" bits are okay.
          */
-        if (and_op == FALSE
-         && (expression->value & ~symbol->info.rinfo->valid_bitmask) != 0) {
+        if (opcode == AIC_OP_AND || opcode == AIC_OP_JNZ ||
+            opcode == AIC_OP_JZ  || opcode == AIC_OP_JNE ||
+            opcode == AIC_OP_BMOV)
+                and_op = TRUE;
+
+        /*
+         * Defaulting to 8 bit logic
+         */
+        mask = (int8_t)~symbol->info.rinfo->valid_bitmask;
+        value = (int8_t)expression->value;
+
+        if (and_op == FALSE && (mask & value) != 0 ) {
                 snprintf(errbuf, sizeof(errbuf),
                          "Invalid bit(s) 0x%x in immediate written to %s",
-                         expression->value & ~symbol->info.rinfo->valid_bitmask,
+                         (mask & value),
                          symbol->name);
                 stop(errbuf, EX_DATAERR);
                 /* NOTREACHED */
@@ -1959,3 +1982,13 @@ is_download_const(expression_t *immed)
 
         return (FALSE);
 }
+
+static int
+is_location_address(symbol_t *sym)
+{
+        if (sym->type == SCBLOC ||
+            sym->type == SRAMLOC)
+                return (TRUE);
+        return (FALSE);
+}
+
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l b/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
index 7c3983f868a9..2c7f02daf88d 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_scan.l
@@ -162,6 +162,7 @@ register		{ return T_REGISTER; }
 const                   { yylval.value = FALSE; return T_CONST; }
 download                { return T_DOWNLOAD; }
 address                 { return T_ADDRESS; }
+count                   { return T_COUNT; }
 access_mode             { return T_ACCESS_MODE; }
 modes                   { return T_MODES; }
 RW|RO|WO                {
@@ -228,15 +229,15 @@ ret			{ return T_RET; }
 nop                     { return T_NOP; }
 
         /* ARP2 16bit extensions */
-or16                    { return T_OR16; }
-and16                   { return T_AND16; }
-xor16                   { return T_XOR16; }
-add16                   { return T_ADD16; }
-adc16                   { return T_ADC16; }
-mvi16                   { return T_MVI16; }
-test16                  { return T_TEST16; }
-cmp16                   { return T_CMP16; }
-cmpxchg                 { return T_CMPXCHG; }
+        /* or16                 { return T_OR16; } */
+        /* and16                        { return T_AND16; }*/
+        /* xor16                        { return T_XOR16; }*/
+        /* add16                        { return T_ADD16; }*/
+        /* adc16                        { return T_ADC16; }*/
+        /* mvi16                        { return T_MVI16; }*/
+        /* test16                       { return T_TEST16; }*/
+        /* cmp16                        { return T_CMP16; }*/
+        /* cmpxchg                      { return T_CMPXCHG; }*/
 
         /* Allowed Symbols */
 \<\<                    { return T_EXPR_LSHIFT; }
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
index f1f448dff569..fcd357872b43 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c
@@ -77,6 +77,7 @@ symbol_create(char *name)
         if (new_symbol->name == NULL)
                  stop("Unable to strdup symbol name", EX_SOFTWARE);
         new_symbol->type = UNINITIALIZED;
+        new_symbol->count = 1;
         return (new_symbol);
 }
 
@@ -198,6 +199,12 @@ symtable_get(char *name)
                 }
         }
         memcpy(&stored_ptr, data.data, sizeof(stored_ptr));
+        stored_ptr->count++;
+        data.data = &stored_ptr;
+        if (symtable->put(symtable, &key, &data, /*flags*/0) !=0) {
+                perror("Symtable put failed");
+                exit(EX_SOFTWARE);
+        }
         return (stored_ptr);
 }
 
@@ -256,7 +263,7 @@ symlist_add(symlist_t *symlist, symbol_t *symbol, int how)
                     && (curnode->symbol->info.finfo->value >
                         newnode->symbol->info.finfo->value))))
                  || (!field && (curnode->symbol->info.rinfo->address >
-                               newnode->symbol->info.rinfo->address))) {
+                                newnode->symbol->info.rinfo->address))) {
                         SLIST_INSERT_HEAD(symlist, newnode, links);
                         return;
                 }
@@ -271,7 +278,7 @@ symlist_add(symlist_t *symlist, symbol_t *symbol, int how)
 
                                 cursymbol = SLIST_NEXT(curnode, links)->symbol;
                                 if ((field
-                                  && (cursymbol->type > symbol->type
+                                  && (cursymbol->type > symbol->type
                                    || (cursymbol->type == symbol->type
                                     && (cursymbol->info.finfo->value >
                                         symbol->info.finfo->value))))
@@ -351,7 +358,7 @@ aic_print_reg_dump_types(FILE *ofile)
 {
         if (ofile == NULL)
                 return;
-                
+
         fprintf(ofile,
 "typedef int (%sreg_print_t)(u_int, u_int *, u_int);\n"
 "typedef struct %sreg_parse_entry {\n"
@@ -370,7 +377,7 @@ aic_print_reg_dump_start(FILE *dfile, symbol_node_t *regnode)
                 return;
 
         fprintf(dfile,
-"static %sreg_parse_entry_t %s_parse_table[] = {\n",
+"static const %sreg_parse_entry_t %s_parse_table[] = {\n",
                 prefix,
                 regnode->symbol->name);
 }
@@ -385,7 +392,7 @@ aic_print_reg_dump_end(FILE *ofile, FILE *dfile,
         lower_name = strdup(regnode->symbol->name);
         if (lower_name == NULL)
                  stop("Unable to strdup symbol name", EX_SOFTWARE);
-        
+
         for (letter = lower_name; *letter != '\0'; letter++)
                 *letter = tolower(*letter);
 
@@ -472,6 +479,7 @@ symtable_dump(FILE *ofile, FILE *dfile)
         DBT              key;
         DBT              data;
         int              flag;
+        int              reg_count = 0, reg_used = 0;
         u_int            i;
 
         if (symtable == NULL)
@@ -541,6 +549,9 @@ symtable_dump(FILE *ofile, FILE *dfile)
                         int              num_entries;
 
                         num_entries = 0;
+                        reg_count++;
+                        if (curnode->symbol->count == 1)
+                                break;
                         fields = &curnode->symbol->info.rinfo->fields;
                         SLIST_FOREACH(fieldnode, fields, links) {
                                 if (num_entries == 0)
@@ -553,11 +564,14 @@ symtable_dump(FILE *ofile, FILE *dfile)
                         }
                         aic_print_reg_dump_end(ofile, dfile,
                                                curnode, num_entries);
+                        reg_used++;
                 }
                 default:
                         break;
                 }
         }
+        fprintf(stderr, "%s: %d of %d register definitions used\n", appname,
+                reg_used, reg_count);
 
         /* Fold in the masks and bits */
         while (SLIST_FIRST(&masks) != NULL) {
@@ -646,7 +660,6 @@ symtable_dump(FILE *ofile, FILE *dfile)
                 free(curnode);
         }
 
-        
         fprintf(ofile, "\n\n/* Downloaded Constant Definitions */\n");
 
         for (i = 0; SLIST_FIRST(&download_constants) != NULL; i++) {
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.h b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.h
index afc22e8b4903..05190c1a2fb7 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.h
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_symbol.h
@@ -128,6 +128,7 @@ typedef struct expression_info {
 typedef struct symbol {
         char    *name;
         symtype type;
+        int     count;
         union   {
                 struct reg_info   *rinfo;
                 struct field_info *finfo;
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 8be3d76656fa..a73a6bbb1b2b 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -2286,17 +2286,14 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec,
         }
 }
 
-static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
+static irqreturn_t ihdlr(struct Scsi_Host *shost)
 {
         struct scsi_cmnd *SCpnt;
         unsigned int i, k, c, status, tstatus, reg;
         struct mssp *spp;
         struct mscp *cpp;
         struct hostdata *ha = (struct hostdata *)shost->hostdata;
-
-        if (shost->irq != irq)
-                panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
-                      shost->irq);
+        int irq = shost->irq;
 
         /* Check if this board need to be serviced */
         if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
@@ -2535,7 +2532,7 @@ static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
         return IRQ_NONE;
 }
 
-static irqreturn_t do_interrupt_handler(int irq, void *shap)
+static irqreturn_t do_interrupt_handler(int dummy, void *shap)
 {
         struct Scsi_Host *shost;
         unsigned int j;
@@ -2548,7 +2545,7 @@ static irqreturn_t do_interrupt_handler(int irq, void *shap)
         shost = sh[j];
 
         spin_lock_irqsave(shost->host_lock, spin_flags);
-        ret = ihdlr(irq, shost);
+        ret = ihdlr(shost);
         spin_unlock_irqrestore(shost->host_lock, spin_flags);
         return ret;
 }
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index bfdee5968892..a0b6d414953d 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -978,7 +978,7 @@ static int esp_check_spur_intr(struct esp *esp)
                          */
                         if (!esp->ops->dma_error(esp)) {
                                 printk(KERN_ERR PFX "esp%d: Spurious irq, "
-                                       "sreg=%x.\n",
+                                       "sreg=%02x.\n",
                                        esp->host->unique_id, esp->sreg);
                                 return -1;
                         }
@@ -1447,6 +1447,9 @@ static void esp_msgin_sdtr(struct esp *esp, struct esp_target_data *tp)
         if (offset > 15)
                 goto do_reject;
 
+        if (esp->flags & ESP_FLAG_DISABLE_SYNC)
+                offset = 0;
+
         if (offset) {
                 int rounded_up, one_clock;
 
@@ -1697,7 +1700,12 @@ again:
                 else
                         ent->flags &= ~ESP_CMD_FLAG_WRITE;
 
-                dma_len = esp_dma_length_limit(esp, dma_addr, dma_len);
+                if (esp->ops->dma_length_limit)
+                        dma_len = esp->ops->dma_length_limit(esp, dma_addr,
+                                                             dma_len);
+                else
+                        dma_len = esp_dma_length_limit(esp, dma_addr, dma_len);
+
                 esp->data_dma_len = dma_len;
 
                 if (!dma_len) {
@@ -1761,7 +1769,6 @@ again:
                 esp_advance_dma(esp, ent, cmd, bytes_sent);
                 esp_event(esp, ESP_EVENT_CHECK_PHASE);
                 goto again;
-                break;
         }
 
         case ESP_EVENT_STATUS: {
@@ -2235,7 +2242,7 @@ static void esp_bootup_reset(struct esp *esp)
 
 static void esp_set_clock_params(struct esp *esp)
 {
-        int fmhz;
+        int fhz;
         u8 ccf;
 
         /* This is getting messy but it has to be done correctly or else
@@ -2270,9 +2277,9 @@ static void esp_set_clock_params(struct esp *esp)
          *    This entails the smallest and largest sync period we could ever
          *    handle on this ESP.
          */
-        fmhz = esp->cfreq;
+        fhz = esp->cfreq;
 
-        ccf = ((fmhz / 1000000) + 4) / 5;
+        ccf = ((fhz / 1000000) + 4) / 5;
         if (ccf == 1)
                 ccf = 2;
 
@@ -2281,16 +2288,16 @@ static void esp_set_clock_params(struct esp *esp)
          * been unable to find the clock-frequency PROM property.  All
          * other machines provide useful values it seems.
          */
-        if (fmhz <= 5000000 || ccf < 1 || ccf > 8) {
-                fmhz = 20000000;
+        if (fhz <= 5000000 || ccf < 1 || ccf > 8) {
+                fhz = 20000000;
                 ccf = 4;
         }
 
         esp->cfact = (ccf == 8 ? 0 : ccf);
-        esp->cfreq = fmhz;
-        esp->ccycle = ESP_MHZ_TO_CYCLE(fmhz);
+        esp->cfreq = fhz;
+        esp->ccycle = ESP_HZ_TO_CYCLE(fhz);
         esp->ctick = ESP_TICK(ccf, esp->ccycle);
-        esp->neg_defp = ESP_NEG_DEFP(fmhz, ccf);
+        esp->neg_defp = ESP_NEG_DEFP(fhz, ccf);
         esp->sync_defp = SYNC_DEFP_SLOW;
 }
 
@@ -2382,6 +2389,12 @@ static int esp_slave_configure(struct scsi_device *dev)
         struct esp_target_data *tp = &esp->target[dev->id];
         int goal_tags, queue_depth;
 
+        if (esp->flags & ESP_FLAG_DISABLE_SYNC) {
+                /* Bypass async domain validation */
+                dev->ppr  = 0;
+                dev->sdtr = 0;
+        }
+
         goal_tags = 0;
 
         if (dev->tagged_supported) {
diff --git a/drivers/scsi/esp_scsi.h b/drivers/scsi/esp_scsi.h
index d5576d54ce76..bb43a1388188 100644
--- a/drivers/scsi/esp_scsi.h
+++ b/drivers/scsi/esp_scsi.h
@@ -224,7 +224,7 @@
 #define ESP_TIMEO_CONST       8192
 #define ESP_NEG_DEFP(mhz, cfact) \
         ((ESP_BUS_TIMEOUT * ((mhz) / 1000)) / (8192 * (cfact)))
-#define ESP_MHZ_TO_CYCLE(mhertz)  ((1000000000) / ((mhertz) / 1000))
+#define ESP_HZ_TO_CYCLE(hertz)  ((1000000000) / ((hertz) / 1000))
 #define ESP_TICK(ccf, cycle)  ((7682 * (ccf) * (cycle) / 1000))
 
 /* For slow to medium speed input clock rates we shoot for 5mb/s, but for high
@@ -240,9 +240,9 @@ struct esp_cmd_priv {
                 int             num_sg;
         } u;
 
-        unsigned int            cur_residue;
+        int                     cur_residue;
         struct scatterlist      *cur_sg;
-        unsigned int            tot_residue;
+        int                     tot_residue;
 };
 #define ESP_CMD_PRIV(CMD)       ((struct esp_cmd_priv *)(&(CMD)->SCp))
 
@@ -368,6 +368,12 @@ struct esp_driver_ops {
          */
         int (*irq_pending)(struct esp *esp);
 
+        /* Return the maximum allowable size of a DMA transfer for a
+         * given buffer.
+         */
+        u32 (*dma_length_limit)(struct esp *esp, u32 dma_addr,
+                                u32 dma_len);
+
         /* Reset the DMA engine entirely.  On return, ESP interrupts
          * should be enabled.  Often the interrupt enabling is
          * controlled in the DMA engine.
@@ -471,6 +477,7 @@ struct esp {
 #define ESP_FLAG_DOING_SLOWCMD  0x00000004
 #define ESP_FLAG_WIDE_CAPABLE   0x00000008
 #define ESP_FLAG_QUICKIRQ_CHECK 0x00000010
+#define ESP_FLAG_DISABLE_SYNC   0x00000020
 
         u8                      select_state;
 #define ESP_SELECT_NONE         0x00 /* Not selecting */
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index c264a8c5f01e..3690360d7a79 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -199,9 +199,13 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
         if (!shost->can_queue) {
                 printk(KERN_ERR "%s: can_queue = 0 no longer supported\n",
                                 sht->name);
-                goto out;
+                goto fail;
         }
 
+        error = scsi_setup_command_freelist(shost);
+        if (error)
+                goto fail;
+
         if (!shost->shost_gendev.parent)
                 shost->shost_gendev.parent = dev ? dev : &platform_bus;
 
@@ -255,6 +259,8 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
  out_del_gendev:
         device_del(&shost->shost_gendev);
  out:
+        scsi_destroy_command_freelist(shost);
+ fail:
         return error;
 }
 EXPORT_SYMBOL(scsi_add_host);
@@ -284,6 +290,11 @@ static void scsi_host_dev_release(struct device *dev)
         kfree(shost);
 }
 
+struct device_type scsi_host_type = {
+        .name =         "scsi_host",
+        .release =      scsi_host_dev_release,
+};
+
 /**
  * scsi_host_alloc - register a scsi host adapter instance.
  * @sht:        pointer to scsi host template
@@ -376,33 +387,31 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
         else
                 shost->dma_boundary = 0xffffffff;
 
-        rval = scsi_setup_command_freelist(shost);
-        if (rval)
-                goto fail_kfree;
-
         device_initialize(&shost->shost_gendev);
         snprintf(shost->shost_gendev.bus_id, BUS_ID_SIZE, "host%d",
                 shost->host_no);
-        shost->shost_gendev.release = scsi_host_dev_release;
+#ifndef CONFIG_SYSFS_DEPRECATED
+        shost->shost_gendev.bus = &scsi_bus_type;
+#endif
+        shost->shost_gendev.type = &scsi_host_type;
 
         device_initialize(&shost->shost_dev);
         shost->shost_dev.parent = &shost->shost_gendev;
         shost->shost_dev.class = &shost_class;
         snprintf(shost->shost_dev.bus_id, BUS_ID_SIZE, "host%d",
                  shost->host_no);
+        shost->shost_dev.groups = scsi_sysfs_shost_attr_groups;
 
         shost->ehandler = kthread_run(scsi_error_handler, shost,
                         "scsi_eh_%d", shost->host_no);
         if (IS_ERR(shost->ehandler)) {
                 rval = PTR_ERR(shost->ehandler);
-                goto fail_destroy_freelist;
+                goto fail_kfree;
         }
 
         scsi_proc_hostdir_add(shost->hostt);
         return shost;
 
- fail_destroy_freelist:
-        scsi_destroy_command_freelist(shost);
  fail_kfree:
         kfree(shost);
         return NULL;
@@ -496,7 +505,7 @@ void scsi_exit_hosts(void)
 
 int scsi_is_host_device(const struct device *dev)
 {
-        return dev->release == scsi_host_dev_release;
+        return dev->type == &scsi_host_type;
 }
 EXPORT_SYMBOL(scsi_is_host_device);
 
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 93c3fc20aa59..32553639aded 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -258,8 +258,7 @@ idescsi_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
 
         if (ide_read_status(drive) & (BUSY_STAT | DRQ_STAT))
                 /* force an abort */
-                hwif->OUTB(WIN_IDLEIMMEDIATE,
-                           hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTB(WIN_IDLEIMMEDIATE, hwif->io_ports.command_addr);
 
         rq->errors++;
 
@@ -393,7 +392,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
                 printk ("ide-scsi: %s: DMA complete\n", drive->name);
 #endif /* IDESCSI_DEBUG_LOG */
                 pc->xferred = pc->req_xfer;
-                (void) HWIF(drive)->ide_dma_end(drive);
+                (void)hwif->dma_ops->dma_end(drive);
         }
 
         /* Clear the interrupt */
@@ -410,9 +409,9 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
                 idescsi_end_request (drive, 1, 0);
                 return ide_stopped;
         }
-        bcount = (hwif->INB(hwif->io_ports[IDE_BCOUNTH_OFFSET]) << 8) |
-                  hwif->INB(hwif->io_ports[IDE_BCOUNTL_OFFSET]);
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) |
+                  hwif->INB(hwif->io_ports.lbam_addr);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
 
         if (ireason & CD) {
                 printk(KERN_ERR "ide-scsi: CoD != 0 in idescsi_pc_intr\n");
@@ -485,7 +484,7 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)
                         "initiated yet DRQ isn't asserted\n");
                 return startstop;
         }
-        ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]);
+        ireason = hwif->INB(hwif->io_ports.nsect_addr);
         if ((ireason & CD) == 0 || (ireason & IO)) {
                 printk(KERN_ERR "ide-scsi: (IO,CoD) != (0,1) while "
                                 "issuing a packet command\n");
@@ -498,7 +497,7 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)
         drive->hwif->atapi_output_bytes(drive, scsi->pc->c, 12);
         if (pc->flags & PC_FLAG_DMA_OK) {
                 pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
-                hwif->dma_start(drive);
+                hwif->dma_ops->dma_start(drive);
         }
         return ide_started;
 }
@@ -560,7 +559,7 @@ static ide_startstop_t idescsi_issue_pc(ide_drive_t *drive,
 
         if (drive->using_dma && !idescsi_map_sg(drive, pc)) {
                 hwif->sg_mapped = 1;
-                dma = !hwif->dma_setup(drive);
+                dma = !hwif->dma_ops->dma_setup(drive);
                 hwif->sg_mapped = 0;
         }
 
@@ -575,7 +574,7 @@ static ide_startstop_t idescsi_issue_pc(ide_drive_t *drive,
                 return ide_started;
         } else {
                 /* Issue the packet command */
-                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports[IDE_COMMAND_OFFSET]);
+                hwif->OUTB(WIN_PACKETCMD, hwif->io_ports.command_addr);
                 return idescsi_transfer_pc(drive);
         }
 }
diff --git a/drivers/scsi/jazz_esp.c b/drivers/scsi/jazz_esp.c
index 5d231015bb20..b2d481dd3750 100644
--- a/drivers/scsi/jazz_esp.c
+++ b/drivers/scsi/jazz_esp.c
@@ -217,11 +217,15 @@ static int __devexit esp_jazz_remove(struct platform_device *dev)
         return 0;
 }
 
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:jazz_esp");
+
 static struct platform_driver esp_jazz_driver = {
         .probe          = esp_jazz_probe,
         .remove         = __devexit_p(esp_jazz_remove),
         .driver = {
                 .name   = "jazz_esp",
+                .owner  = THIS_MODULE,
         },
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index a9fbb3f88659..960baaf11fb1 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -182,8 +182,8 @@ lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
 }
 static ssize_t
-lpfc_state_show(struct device *dev, struct device_attribute *attr,
-                char *buf)
+lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
+                     char *buf)
 {
         struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
@@ -936,7 +936,7 @@ static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
-static DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
+static DEVICE_ATTR(link_state, S_IRUGO, lpfc_link_state_show, NULL);
 static DEVICE_ATTR(option_rom_version, S_IRUGO,
                    lpfc_option_rom_version_show, NULL);
 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
@@ -1666,7 +1666,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_fwrev,
         &dev_attr_hdw,
         &dev_attr_option_rom_version,
-        &dev_attr_state,
+        &dev_attr_link_state,
         &dev_attr_num_discovered_ports,
         &dev_attr_lpfc_drvr_version,
         &dev_attr_lpfc_temp_sensor,
@@ -1714,7 +1714,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
 
 struct device_attribute *lpfc_vport_attrs[] = {
         &dev_attr_info,
-        &dev_attr_state,
+        &dev_attr_link_state,
         &dev_attr_num_discovered_ports,
         &dev_attr_lpfc_drvr_version,
         &dev_attr_lpfc_log_verbose,
diff --git a/drivers/scsi/mac_esp.c b/drivers/scsi/mac_esp.c
new file mode 100644
index 000000000000..cd37bd69a115
--- /dev/null
+++ b/drivers/scsi/mac_esp.c
@@ -0,0 +1,657 @@
+/* mac_esp.c: ESP front-end for Macintosh Quadra systems.
+ *
+ * Adapted from jazz_esp.c and the old mac_esp.c.
+ *
+ * The pseudo DMA algorithm is based on the one used in NetBSD.
+ * See sys/arch/mac68k/obio/esp.c for some background information.
+ *
+ * Copyright (C) 2007-2008 Finn Thain
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/scatterlist.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/nubus.h>
+
+#include <asm/irq.h>
+#include <asm/dma.h>
+
+#include <asm/macints.h>
+#include <asm/macintosh.h>
+
+#include <scsi/scsi_host.h>
+
+#include "esp_scsi.h"
+
+#define DRV_MODULE_NAME     "mac_esp"
+#define PFX                 DRV_MODULE_NAME ": "
+#define DRV_VERSION         "1.000"
+#define DRV_MODULE_RELDATE  "Sept 15, 2007"
+
+#define MAC_ESP_IO_BASE          0x50F00000
+#define MAC_ESP_REGS_QUADRA      (MAC_ESP_IO_BASE + 0x10000)
+#define MAC_ESP_REGS_QUADRA2     (MAC_ESP_IO_BASE + 0xF000)
+#define MAC_ESP_REGS_QUADRA3     (MAC_ESP_IO_BASE + 0x18000)
+#define MAC_ESP_REGS_SPACING     0x402
+#define MAC_ESP_PDMA_REG         0xF9800024
+#define MAC_ESP_PDMA_REG_SPACING 0x4
+#define MAC_ESP_PDMA_IO_OFFSET   0x100
+
+#define esp_read8(REG)          mac_esp_read8(esp, REG)
+#define esp_write8(VAL, REG)    mac_esp_write8(esp, VAL, REG)
+
+struct mac_esp_priv {
+        struct esp *esp;
+        void __iomem *pdma_regs;
+        void __iomem *pdma_io;
+        int error;
+};
+static struct platform_device *internal_esp, *external_esp;
+
+#define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
+                               platform_get_drvdata((struct platform_device *) \
+                                                    (esp->dev)))
+
+static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)
+{
+        nubus_writeb(val, esp->regs + reg * 16);
+}
+
+static inline u8 mac_esp_read8(struct esp *esp, unsigned long reg)
+{
+        return nubus_readb(esp->regs + reg * 16);
+}
+
+/* For pseudo DMA and PIO we need the virtual address
+ * so this address mapping is the identity mapping.
+ */
+
+static dma_addr_t mac_esp_map_single(struct esp *esp, void *buf,
+                                     size_t sz, int dir)
+{
+        return (dma_addr_t)buf;
+}
+
+static int mac_esp_map_sg(struct esp *esp, struct scatterlist *sg,
+                          int num_sg, int dir)
+{
+        int i;
+
+        for (i = 0; i < num_sg; i++)
+                sg[i].dma_address = (u32)sg_virt(&sg[i]);
+        return num_sg;
+}
+
+static void mac_esp_unmap_single(struct esp *esp, dma_addr_t addr,
+                                 size_t sz, int dir)
+{
+        /* Nothing to do. */
+}
+
+static void mac_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
+                             int num_sg, int dir)
+{
+        /* Nothing to do. */
+}
+
+static void mac_esp_reset_dma(struct esp *esp)
+{
+        /* Nothing to do. */
+}
+
+static void mac_esp_dma_drain(struct esp *esp)
+{
+        /* Nothing to do. */
+}
+
+static void mac_esp_dma_invalidate(struct esp *esp)
+{
+        /* Nothing to do. */
+}
+
+static int mac_esp_dma_error(struct esp *esp)
+{
+        return MAC_ESP_GET_PRIV(esp)->error;
+}
+
+static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)
+{
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
+        int i = 500000;
+
+        do {
+                if (!(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES))
+                        return 0;
+
+                if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
+                        return 1;
+
+                udelay(2);
+        } while (--i);
+
+        printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",
+               esp_read8(ESP_STATUS));
+        mep->error = 1;
+        return 1;
+}
+
+static inline int mac_esp_wait_for_dreq(struct esp *esp)
+{
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
+        int i = 500000;
+
+        do {
+                if (mep->pdma_regs == NULL) {
+                        if (mac_irq_pending(IRQ_MAC_SCSIDRQ))
+                                return 0;
+                } else {
+                        if (nubus_readl(mep->pdma_regs) & 0x200)
+                                return 0;
+                }
+
+                if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
+                        return 1;
+
+                udelay(2);
+        } while (--i);
+
+        printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",
+               esp_read8(ESP_STATUS));
+        mep->error = 1;
+        return 1;
+}
+
+#define MAC_ESP_PDMA_LOOP(operands) \
+        asm volatile ( \
+             "       tstw %2                   \n" \
+             "       jbeq 20f                  \n" \
+             "1:     movew " operands "        \n" \
+             "2:     movew " operands "        \n" \
+             "3:     movew " operands "        \n" \
+             "4:     movew " operands "        \n" \
+             "5:     movew " operands "        \n" \
+             "6:     movew " operands "        \n" \
+             "7:     movew " operands "        \n" \
+             "8:     movew " operands "        \n" \
+             "9:     movew " operands "        \n" \
+             "10:    movew " operands "        \n" \
+             "11:    movew " operands "        \n" \
+             "12:    movew " operands "        \n" \
+             "13:    movew " operands "        \n" \
+             "14:    movew " operands "        \n" \
+             "15:    movew " operands "        \n" \
+             "16:    movew " operands "        \n" \
+             "       subqw #1,%2               \n" \
+             "       jbne 1b                   \n" \
+             "20:    tstw %3                   \n" \
+             "       jbeq 30f                  \n" \
+             "21:    movew " operands "        \n" \
+             "       subqw #1,%3               \n" \
+             "       jbne 21b                  \n" \
+             "30:    tstw %4                   \n" \
+             "       jbeq 40f                  \n" \
+             "31:    moveb " operands "        \n" \
+             "32:    nop                       \n" \
+             "40:                              \n" \
+             "                                 \n" \
+             "       .section __ex_table,\"a\" \n" \
+             "       .align  4                 \n" \
+             "       .long   1b,40b            \n" \
+             "       .long   2b,40b            \n" \
+             "       .long   3b,40b            \n" \
+             "       .long   4b,40b            \n" \
+             "       .long   5b,40b            \n" \
+             "       .long   6b,40b            \n" \
+             "       .long   7b,40b            \n" \
+             "       .long   8b,40b            \n" \
+             "       .long   9b,40b            \n" \
+             "       .long  10b,40b            \n" \
+             "       .long  11b,40b            \n" \
+             "       .long  12b,40b            \n" \
+             "       .long  13b,40b            \n" \
+             "       .long  14b,40b            \n" \
+             "       .long  15b,40b            \n" \
+             "       .long  16b,40b            \n" \
+             "       .long  21b,40b            \n" \
+             "       .long  31b,40b            \n" \
+             "       .long  32b,40b            \n" \
+             "       .previous                 \n" \
+             : "+a" (addr) \
+             : "a" (mep->pdma_io), "r" (count32), "r" (count2), "g" (esp_count))
+
+static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
+                                  u32 dma_count, int write, u8 cmd)
+{
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        mep->error = 0;
+
+        if (!write)
+                scsi_esp_cmd(esp, ESP_CMD_FLUSH);
+
+        esp_write8((esp_count >> 0) & 0xFF, ESP_TCLOW);
+        esp_write8((esp_count >> 8) & 0xFF, ESP_TCMED);
+
+        scsi_esp_cmd(esp, cmd);
+
+        do {
+                unsigned int count32 = esp_count >> 5;
+                unsigned int count2 = (esp_count & 0x1F) >> 1;
+                unsigned int start_addr = addr;
+
+                if (mac_esp_wait_for_dreq(esp))
+                        break;
+
+                if (write) {
+                        MAC_ESP_PDMA_LOOP("%1@,%0@+");
+
+                        esp_count -= addr - start_addr;
+                } else {
+                        unsigned int n;
+
+                        MAC_ESP_PDMA_LOOP("%0@+,%1@");
+
+                        if (mac_esp_wait_for_empty_fifo(esp))
+                                break;
+
+                        n = (esp_read8(ESP_TCMED) << 8) + esp_read8(ESP_TCLOW);
+                        addr = start_addr + esp_count - n;
+                        esp_count = n;
+                }
+        } while (esp_count);
+
+        local_irq_restore(flags);
+}
+
+/*
+ * Programmed IO routines follow.
+ */
+
+static inline int mac_esp_wait_for_fifo(struct esp *esp)
+{
+        int i = 500000;
+
+        do {
+                if (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES)
+                        return 0;
+
+                udelay(2);
+        } while (--i);
+
+        printk(KERN_ERR PFX "FIFO is empty (sreg %02x)\n",
+               esp_read8(ESP_STATUS));
+        return 1;
+}
+
+static inline int mac_esp_wait_for_intr(struct esp *esp)
+{
+        int i = 500000;
+
+        do {
+                esp->sreg = esp_read8(ESP_STATUS);
+                if (esp->sreg & ESP_STAT_INTR)
+                        return 0;
+
+                udelay(2);
+        } while (--i);
+
+        printk(KERN_ERR PFX "IRQ timeout (sreg %02x)\n", esp->sreg);
+        return 1;
+}
+
+#define MAC_ESP_PIO_LOOP(operands, reg1) \
+        asm volatile ( \
+             "1:     moveb " operands " \n" \
+             "       subqw #1,%1        \n" \
+             "       jbne 1b            \n" \
+             : "+a" (addr), "+r" (reg1) \
+             : "a" (fifo))
+
+#define MAC_ESP_PIO_FILL(operands, reg1) \
+        asm volatile ( \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       moveb " operands " \n" \
+             "       subqw #8,%1        \n" \
+             "       subqw #8,%1        \n" \
+             : "+a" (addr), "+r" (reg1) \
+             : "a" (fifo))
+
+#define MAC_ESP_FIFO_SIZE 16
+
+static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
+                                 u32 dma_count, int write, u8 cmd)
+{
+        unsigned long flags;
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
+        u8 *fifo = esp->regs + ESP_FDATA * 16;
+
+        local_irq_save(flags);
+
+        cmd &= ~ESP_CMD_DMA;
+        mep->error = 0;
+
+        if (write) {
+                scsi_esp_cmd(esp, cmd);
+
+                if (!mac_esp_wait_for_intr(esp)) {
+                        if (mac_esp_wait_for_fifo(esp))
+                                esp_count = 0;
+                } else {
+                        esp_count = 0;
+                }
+        } else {
+                scsi_esp_cmd(esp, ESP_CMD_FLUSH);
+
+                if (esp_count >= MAC_ESP_FIFO_SIZE)
+                        MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
+                else
+                        MAC_ESP_PIO_LOOP("%0@+,%2@", esp_count);
+
+                scsi_esp_cmd(esp, cmd);
+        }
+
+        while (esp_count) {
+                unsigned int n;
+
+                if (mac_esp_wait_for_intr(esp)) {
+                        mep->error = 1;
+                        break;
+                }
+
+                if (esp->sreg & ESP_STAT_SPAM) {
+                        printk(KERN_ERR PFX "gross error\n");
+                        mep->error = 1;
+                        break;
+                }
+
+                n = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
+
+                if (write) {
+                        if (n > esp_count)
+                                n = esp_count;
+                        esp_count -= n;
+
+                        MAC_ESP_PIO_LOOP("%2@,%0@+", n);
+
+                        if ((esp->sreg & ESP_STAT_PMASK) == ESP_STATP)
+                                break;
+
+                        if (esp_count) {
+                                esp->ireg = esp_read8(ESP_INTRPT);
+                                if (esp->ireg & ESP_INTR_DC)
+                                        break;
+
+                                scsi_esp_cmd(esp, ESP_CMD_TI);
+                        }
+                } else {
+                        esp->ireg = esp_read8(ESP_INTRPT);
+                        if (esp->ireg & ESP_INTR_DC)
+                                break;
+
+                        n = MAC_ESP_FIFO_SIZE - n;
+                        if (n > esp_count)
+                                n = esp_count;
+
+                        if (n == MAC_ESP_FIFO_SIZE) {
+                                MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
+                        } else {
+                                esp_count -= n;
+                                MAC_ESP_PIO_LOOP("%0@+,%2@", n);
+                        }
+
+                        scsi_esp_cmd(esp, ESP_CMD_TI);
+                }
+        }
+
+        local_irq_restore(flags);
+}
+
+static int mac_esp_irq_pending(struct esp *esp)
+{
+        if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
+                return 1;
+        return 0;
+}
+
+static u32 mac_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len)
+{
+        return dma_len > 0xFFFF ? 0xFFFF : dma_len;
+}
+
+static struct esp_driver_ops mac_esp_ops = {
+        .esp_write8       = mac_esp_write8,
+        .esp_read8        = mac_esp_read8,
+        .map_single       = mac_esp_map_single,
+        .map_sg           = mac_esp_map_sg,
+        .unmap_single     = mac_esp_unmap_single,
+        .unmap_sg         = mac_esp_unmap_sg,
+        .irq_pending      = mac_esp_irq_pending,
+        .dma_length_limit = mac_esp_dma_length_limit,
+        .reset_dma        = mac_esp_reset_dma,
+        .dma_drain        = mac_esp_dma_drain,
+        .dma_invalidate   = mac_esp_dma_invalidate,
+        .send_dma_cmd     = mac_esp_send_pdma_cmd,
+        .dma_error        = mac_esp_dma_error,
+};
+
+static int __devinit esp_mac_probe(struct platform_device *dev)
+{
+        struct scsi_host_template *tpnt = &scsi_esp_template;
+        struct Scsi_Host *host;
+        struct esp *esp;
+        int err;
+        int chips_present;
+        struct mac_esp_priv *mep;
+
+        if (!MACH_IS_MAC)
+                return -ENODEV;
+
+        switch (macintosh_config->scsi_type) {
+        case MAC_SCSI_QUADRA:
+        case MAC_SCSI_QUADRA3:
+                chips_present = 1;
+                break;
+        case MAC_SCSI_QUADRA2:
+                if ((macintosh_config->ident == MAC_MODEL_Q900) ||
+                    (macintosh_config->ident == MAC_MODEL_Q950))
+                        chips_present = 2;
+                else
+                        chips_present = 1;
+                break;
+        default:
+                chips_present = 0;
+        }
+
+        if (dev->id + 1 > chips_present)
+                return -ENODEV;
+
+        host = scsi_host_alloc(tpnt, sizeof(struct esp));
+
+        err = -ENOMEM;
+        if (!host)
+                goto fail;
+
+        host->max_id = 8;
+        host->use_clustering = DISABLE_CLUSTERING;
+        esp = shost_priv(host);
+
+        esp->host = host;
+        esp->dev = dev;
+
+        esp->command_block = kzalloc(16, GFP_KERNEL);
+        if (!esp->command_block)
+                goto fail_unlink;
+        esp->command_block_dma = (dma_addr_t)esp->command_block;
+
+        esp->scsi_id = 7;
+        host->this_id = esp->scsi_id;
+        esp->scsi_id_mask = 1 << esp->scsi_id;
+
+        mep = kzalloc(sizeof(struct mac_esp_priv), GFP_KERNEL);
+        if (!mep)
+                goto fail_free_command_block;
+        mep->esp = esp;
+        platform_set_drvdata(dev, mep);
+
+        switch (macintosh_config->scsi_type) {
+        case MAC_SCSI_QUADRA:
+                esp->cfreq     = 16500000;
+                esp->regs      = (void __iomem *)MAC_ESP_REGS_QUADRA;
+                mep->pdma_io   = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
+                mep->pdma_regs = NULL;
+                break;
+        case MAC_SCSI_QUADRA2:
+                esp->cfreq     = 25000000;
+                esp->regs      = (void __iomem *)(MAC_ESP_REGS_QUADRA2 +
+                                 dev->id * MAC_ESP_REGS_SPACING);
+                mep->pdma_io   = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
+                mep->pdma_regs = (void __iomem *)(MAC_ESP_PDMA_REG +
+                                 dev->id * MAC_ESP_PDMA_REG_SPACING);
+                nubus_writel(0x1d1, mep->pdma_regs);
+                break;
+        case MAC_SCSI_QUADRA3:
+                /* These quadras have a real DMA controller (the PSC) but we
+                 * don't know how to drive it so we must use PIO instead.
+                 */
+                esp->cfreq     = 25000000;
+                esp->regs      = (void __iomem *)MAC_ESP_REGS_QUADRA3;
+                mep->pdma_io   = NULL;
+                mep->pdma_regs = NULL;
+                break;
+        }
+
+        esp->ops = &mac_esp_ops;
+        if (mep->pdma_io == NULL) {
+                printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);
+                esp_write8(0, ESP_TCLOW);
+                esp_write8(0, ESP_TCMED);
+                esp->flags = ESP_FLAG_DISABLE_SYNC;
+                mac_esp_ops.send_dma_cmd = mac_esp_send_pio_cmd;
+        } else {
+                printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);
+        }
+
+        host->irq = IRQ_MAC_SCSI;
+        err = request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "Mac ESP",
+                          esp);
+        if (err < 0)
+                goto fail_free_priv;
+
+        err = scsi_esp_register(esp, &dev->dev);
+        if (err)
+                goto fail_free_irq;
+
+        return 0;
+
+fail_free_irq:
+        free_irq(host->irq, esp);
+fail_free_priv:
+        kfree(mep);
+fail_free_command_block:
+        kfree(esp->command_block);
+fail_unlink:
+        scsi_host_put(host);
+fail:
+        return err;
+}
+
+static int __devexit esp_mac_remove(struct platform_device *dev)
+{
+        struct mac_esp_priv *mep = platform_get_drvdata(dev);
+        struct esp *esp = mep->esp;
+        unsigned int irq = esp->host->irq;
+
+        scsi_esp_unregister(esp);
+
+        free_irq(irq, esp);
+
+        kfree(mep);
+
+        kfree(esp->command_block);
+
+        scsi_host_put(esp->host);
+
+        return 0;
+}
+
+static struct platform_driver esp_mac_driver = {
+        .probe    = esp_mac_probe,
+        .remove   = __devexit_p(esp_mac_remove),
+        .driver   = {
+                .name     = DRV_MODULE_NAME,
+        },
+};
+
+static int __init mac_esp_init(void)
+{
+        int err;
+
+        err = platform_driver_register(&esp_mac_driver);
+        if (err)
+                return err;
+
+        internal_esp = platform_device_alloc(DRV_MODULE_NAME, 0);
+        if (internal_esp && platform_device_add(internal_esp)) {
+                platform_device_put(internal_esp);
+                internal_esp = NULL;
+        }
+
+        external_esp = platform_device_alloc(DRV_MODULE_NAME, 1);
+        if (external_esp && platform_device_add(external_esp)) {
+                platform_device_put(external_esp);
+                external_esp = NULL;
+        }
+
+        if (internal_esp || external_esp) {
+                return 0;
+        } else {
+                platform_driver_unregister(&esp_mac_driver);
+                return -ENOMEM;
+        }
+}
+
+static void __exit mac_esp_exit(void)
+{
+        platform_driver_unregister(&esp_mac_driver);
+
+        if (internal_esp) {
+                platform_device_unregister(internal_esp);
+                internal_esp = NULL;
+        }
+        if (external_esp) {
+                platform_device_unregister(external_esp);
+                external_esp = NULL;
+        }
+}
+
+MODULE_DESCRIPTION("Mac ESP SCSI driver");
+MODULE_AUTHOR("Finn Thain <fthain@telegraphics.com.au>");
+MODULE_LICENSE("GPLv2");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(mac_esp_init);
+module_exit(mac_esp_exit);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index d61df036910c..287690853caf 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -609,8 +609,8 @@ qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
-qla2x00_state_show(struct device *dev, struct device_attribute *attr,
-                   char *buf)
+qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int len = 0;
@@ -814,7 +814,7 @@ static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
-static DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
+static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
                    qla2x00_zio_timer_store);
@@ -838,7 +838,7 @@ struct device_attribute *qla2x00_host_attrs[] = {
         &dev_attr_model_name,
         &dev_attr_model_desc,
         &dev_attr_pci_info,
-        &dev_attr_state,
+        &dev_attr_link_state,
         &dev_attr_zio,
         &dev_attr_zio_timer,
         &dev_attr_beacon,
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 9d12d9f26209..cbef785765cf 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -38,78 +38,38 @@ qla2xxx_copy_queues(scsi_qla_host_t *ha, void *ptr)
 }
 
 static int
-qla24xx_dump_memory(scsi_qla_host_t *ha, uint32_t *code_ram,
-    uint32_t cram_size, uint32_t *ext_mem, void **nxt)
+qla24xx_dump_ram(scsi_qla_host_t *ha, uint32_t addr, uint32_t *ram,
+    uint32_t ram_dwords, void **nxt)
 {
         int rval;
-        uint32_t cnt, stat, timer, risc_address, ext_mem_cnt;
-        uint16_t mb[4];
+        uint32_t cnt, stat, timer, dwords, idx;
+        uint16_t mb0;
         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+        dma_addr_t dump_dma = ha->gid_list_dma;
+        uint32_t *dump = (uint32_t *)ha->gid_list;
 
         rval = QLA_SUCCESS;
-        risc_address = ext_mem_cnt = 0;
-        memset(mb, 0, sizeof(mb));
+        mb0 = 0;
 
-        /* Code RAM. */
-        risc_address = 0x20000;
-        WRT_REG_WORD(&reg->mailbox0, MBC_READ_RAM_EXTENDED);
+        WRT_REG_WORD(&reg->mailbox0, MBC_DUMP_RISC_RAM_EXTENDED);
         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 
-        for (cnt = 0; cnt < cram_size / 4 && rval == QLA_SUCCESS;
-            cnt++, risc_address++) {
-                WRT_REG_WORD(&reg->mailbox1, LSW(risc_address));
-                WRT_REG_WORD(&reg->mailbox8, MSW(risc_address));
-                RD_REG_WORD(&reg->mailbox8);
-                WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
-
-                for (timer = 6000000; timer; timer--) {
-                        /* Check for pending interrupts. */
-                        stat = RD_REG_DWORD(&reg->host_status);
-                        if (stat & HSRX_RISC_INT) {
-                                stat &= 0xff;
+        dwords = GID_LIST_SIZE / 4;
+        for (cnt = 0; cnt < ram_dwords && rval == QLA_SUCCESS;
+            cnt += dwords, addr += dwords) {
+                if (cnt + dwords > ram_dwords)
+                        dwords = ram_dwords - cnt;
 
-                                if (stat == 0x1 || stat == 0x2 ||
-                                    stat == 0x10 || stat == 0x11) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
+                WRT_REG_WORD(&reg->mailbox1, LSW(addr));
+                WRT_REG_WORD(&reg->mailbox8, MSW(addr));
 
-                                        mb[0] = RD_REG_WORD(&reg->mailbox0);
-                                        mb[2] = RD_REG_WORD(&reg->mailbox2);
-                                        mb[3] = RD_REG_WORD(&reg->mailbox3);
+                WRT_REG_WORD(&reg->mailbox2, MSW(dump_dma));
+                WRT_REG_WORD(&reg->mailbox3, LSW(dump_dma));
+                WRT_REG_WORD(&reg->mailbox6, MSW(MSD(dump_dma)));
+                WRT_REG_WORD(&reg->mailbox7, LSW(MSD(dump_dma)));
 
-                                        WRT_REG_DWORD(&reg->hccr,
-                                            HCCRX_CLR_RISC_INT);
-                                        RD_REG_DWORD(&reg->hccr);
-                                        break;
-                                }
-
-                                /* Clear this intr; it wasn't a mailbox intr */
-                                WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
-                                RD_REG_DWORD(&reg->hccr);
-                        }
-                        udelay(5);
-                }
-
-                if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
-                        rval = mb[0] & MBS_MASK;
-                        code_ram[cnt] = htonl((mb[3] << 16) | mb[2]);
-                } else {
-                        rval = QLA_FUNCTION_FAILED;
-                }
-        }
-
-        if (rval == QLA_SUCCESS) {
-                /* External Memory. */
-                risc_address = 0x100000;
-                ext_mem_cnt = ha->fw_memory_size - 0x100000 + 1;
-                WRT_REG_WORD(&reg->mailbox0, MBC_READ_RAM_EXTENDED);
-                clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
-        }
-        for (cnt = 0; cnt < ext_mem_cnt && rval == QLA_SUCCESS;
-            cnt++, risc_address++) {
-                WRT_REG_WORD(&reg->mailbox1, LSW(risc_address));
-                WRT_REG_WORD(&reg->mailbox8, MSW(risc_address));
-                RD_REG_WORD(&reg->mailbox8);
+                WRT_REG_WORD(&reg->mailbox4, MSW(dwords));
+                WRT_REG_WORD(&reg->mailbox5, LSW(dwords));
                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
 
                 for (timer = 6000000; timer; timer--) {
@@ -123,9 +83,7 @@ qla24xx_dump_memory(scsi_qla_host_t *ha, uint32_t *code_ram,
                                         set_bit(MBX_INTERRUPT,
                                             &ha->mbx_cmd_flags);
 
-                                        mb[0] = RD_REG_WORD(&reg->mailbox0);
-                                        mb[2] = RD_REG_WORD(&reg->mailbox2);
-                                        mb[3] = RD_REG_WORD(&reg->mailbox3);
+                                        mb0 = RD_REG_WORD(&reg->mailbox0);
 
                                         WRT_REG_DWORD(&reg->hccr,
                                             HCCRX_CLR_RISC_INT);
@@ -141,17 +99,34 @@ qla24xx_dump_memory(scsi_qla_host_t *ha, uint32_t *code_ram,
                 }
 
                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
-                        rval = mb[0] & MBS_MASK;
-                        ext_mem[cnt] = htonl((mb[3] << 16) | mb[2]);
+                        rval = mb0 & MBS_MASK;
+                        for (idx = 0; idx < dwords; idx++)
+                                ram[cnt + idx] = swab32(dump[idx]);
                 } else {
                         rval = QLA_FUNCTION_FAILED;
                 }
         }
 
-        *nxt = rval == QLA_SUCCESS ? &ext_mem[cnt]: NULL;
+        *nxt = rval == QLA_SUCCESS ? &ram[cnt]: NULL;
         return rval;
 }
 
+static int
+qla24xx_dump_memory(scsi_qla_host_t *ha, uint32_t *code_ram,
+    uint32_t cram_size, void **nxt)
+{
+        int rval;
+
+        /* Code RAM. */
+        rval = qla24xx_dump_ram(ha, 0x20000, code_ram, cram_size / 4, nxt);
+        if (rval != QLA_SUCCESS)
+                return rval;
+
+        /* External Memory. */
+        return qla24xx_dump_ram(ha, 0x100000, *nxt,
+            ha->fw_memory_size - 0x100000 + 1, nxt);
+}
+
 static uint32_t *
 qla24xx_read_window(struct device_reg_24xx __iomem *reg, uint32_t iobase,
     uint32_t count, uint32_t *buf)
@@ -239,6 +214,90 @@ qla24xx_soft_reset(scsi_qla_host_t *ha)
         return rval;
 }
 
+static int
+qla2xxx_dump_ram(scsi_qla_host_t *ha, uint32_t addr, uint16_t *ram,
+    uint16_t ram_words, void **nxt)
+{
+        int rval;
+        uint32_t cnt, stat, timer, words, idx;
+        uint16_t mb0;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        dma_addr_t dump_dma = ha->gid_list_dma;
+        uint16_t *dump = (uint16_t *)ha->gid_list;
+
+        rval = QLA_SUCCESS;
+        mb0 = 0;
+
+        WRT_MAILBOX_REG(ha, reg, 0, MBC_DUMP_RISC_RAM_EXTENDED);
+        clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
+
+        words = GID_LIST_SIZE / 2;
+        for (cnt = 0; cnt < ram_words && rval == QLA_SUCCESS;
+            cnt += words, addr += words) {
+                if (cnt + words > ram_words)
+                        words = ram_words - cnt;
+
+                WRT_MAILBOX_REG(ha, reg, 1, LSW(addr));
+                WRT_MAILBOX_REG(ha, reg, 8, MSW(addr));
+
+                WRT_MAILBOX_REG(ha, reg, 2, MSW(dump_dma));
+                WRT_MAILBOX_REG(ha, reg, 3, LSW(dump_dma));
+                WRT_MAILBOX_REG(ha, reg, 6, MSW(MSD(dump_dma)));
+                WRT_MAILBOX_REG(ha, reg, 7, LSW(MSD(dump_dma)));
+
+                WRT_MAILBOX_REG(ha, reg, 4, words);
+                WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
+
+                for (timer = 6000000; timer; timer--) {
+                        /* Check for pending interrupts. */
+                        stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
+                        if (stat & HSR_RISC_INT) {
+                                stat &= 0xff;
+
+                                if (stat == 0x1 || stat == 0x2) {
+                                        set_bit(MBX_INTERRUPT,
+                                            &ha->mbx_cmd_flags);
+
+                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
+
+                                        /* Release mailbox registers. */
+                                        WRT_REG_WORD(&reg->semaphore, 0);
+                                        WRT_REG_WORD(&reg->hccr,
+                                            HCCR_CLR_RISC_INT);
+                                        RD_REG_WORD(&reg->hccr);
+                                        break;
+                                } else if (stat == 0x10 || stat == 0x11) {
+                                        set_bit(MBX_INTERRUPT,
+                                            &ha->mbx_cmd_flags);
+
+                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
+
+                                        WRT_REG_WORD(&reg->hccr,
+                                            HCCR_CLR_RISC_INT);
+                                        RD_REG_WORD(&reg->hccr);
+                                        break;
+                                }
+
+                                /* clear this intr; it wasn't a mailbox intr */
+                                WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
+                                RD_REG_WORD(&reg->hccr);
+                        }
+                        udelay(5);
+                }
+
+                if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
+                        rval = mb0 & MBS_MASK;
+                        for (idx = 0; idx < words; idx++)
+                                ram[cnt + idx] = swab16(dump[idx]);
+                } else {
+                        rval = QLA_FUNCTION_FAILED;
+                }
+        }
+
+        *nxt = rval == QLA_SUCCESS ? &ram[cnt]: NULL;
+        return rval;
+}
+
 static inline void
 qla2xxx_read_window(struct device_reg_2xxx __iomem *reg, uint32_t count,
     uint16_t *buf)
@@ -258,19 +317,14 @@ void
 qla2300_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
 {
         int             rval;
-        uint32_t        cnt, timer;
-        uint32_t        risc_address;
-        uint16_t        mb0, mb2;
+        uint32_t        cnt;
 
-        uint32_t        stat;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
         uint16_t __iomem *dmp_reg;
         unsigned long   flags;
         struct qla2300_fw_dump  *fw;
-        uint32_t        data_ram_cnt;
+        void            *nxt;
 
-        risc_address = data_ram_cnt = 0;
-        mb0 = mb2 = 0;
         flags = 0;
 
         if (!hardware_locked)
@@ -388,185 +442,23 @@ qla2300_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
                 }
         }
 
-        if (rval == QLA_SUCCESS) {
-                /* Get RISC SRAM. */
-                risc_address = 0x800;
-                WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_WORD);
-                clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
-        }
-        for (cnt = 0; cnt < sizeof(fw->risc_ram) / 2 && rval == QLA_SUCCESS;
-            cnt++, risc_address++) {
-                WRT_MAILBOX_REG(ha, reg, 1, (uint16_t)risc_address);
-                WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
-
-                for (timer = 6000000; timer; timer--) {
-                        /* Check for pending interrupts. */
-                        stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
-                        if (stat & HSR_RISC_INT) {
-                                stat &= 0xff;
-
-                                if (stat == 0x1 || stat == 0x2) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        /* Release mailbox registers. */
-                                        WRT_REG_WORD(&reg->semaphore, 0);
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                } else if (stat == 0x10 || stat == 0x11) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                }
-
-                                /* clear this intr; it wasn't a mailbox intr */
-                                WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
-                                RD_REG_WORD(&reg->hccr);
-                        }
-                        udelay(5);
-                }
-
-                if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
-                        rval = mb0 & MBS_MASK;
-                        fw->risc_ram[cnt] = htons(mb2);
-                } else {
-                        rval = QLA_FUNCTION_FAILED;
-                }
-        }
-
-        if (rval == QLA_SUCCESS) {
-                /* Get stack SRAM. */
-                risc_address = 0x10000;
-                WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_EXTENDED);
-                clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
-        }
-        for (cnt = 0; cnt < sizeof(fw->stack_ram) / 2 && rval == QLA_SUCCESS;
-            cnt++, risc_address++) {
-                WRT_MAILBOX_REG(ha, reg, 1, LSW(risc_address));
-                WRT_MAILBOX_REG(ha, reg, 8, MSW(risc_address));
-                WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
-
-                for (timer = 6000000; timer; timer--) {
-                        /* Check for pending interrupts. */
-                        stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
-                        if (stat & HSR_RISC_INT) {
-                                stat &= 0xff;
-
-                                if (stat == 0x1 || stat == 0x2) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        /* Release mailbox registers. */
-                                        WRT_REG_WORD(&reg->semaphore, 0);
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                } else if (stat == 0x10 || stat == 0x11) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                }
-
-                                /* clear this intr; it wasn't a mailbox intr */
-                                WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
-                                RD_REG_WORD(&reg->hccr);
-                        }
-                        udelay(5);
-                }
-
-                if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
-                        rval = mb0 & MBS_MASK;
-                        fw->stack_ram[cnt] = htons(mb2);
-                } else {
-                        rval = QLA_FUNCTION_FAILED;
-                }
-        }
-
-        if (rval == QLA_SUCCESS) {
-                /* Get data SRAM. */
-                risc_address = 0x11000;
-                data_ram_cnt = ha->fw_memory_size - risc_address + 1;
-                WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_EXTENDED);
-                clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
-        }
-        for (cnt = 0; cnt < data_ram_cnt && rval == QLA_SUCCESS;
-            cnt++, risc_address++) {
-                WRT_MAILBOX_REG(ha, reg, 1, LSW(risc_address));
-                WRT_MAILBOX_REG(ha, reg, 8, MSW(risc_address));
-                WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
-
-                for (timer = 6000000; timer; timer--) {
-                        /* Check for pending interrupts. */
-                        stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
-                        if (stat & HSR_RISC_INT) {
-                                stat &= 0xff;
-
-                                if (stat == 0x1 || stat == 0x2) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        /* Release mailbox registers. */
-                                        WRT_REG_WORD(&reg->semaphore, 0);
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                } else if (stat == 0x10 || stat == 0x11) {
-                                        set_bit(MBX_INTERRUPT,
-                                            &ha->mbx_cmd_flags);
-
-                                        mb0 = RD_MAILBOX_REG(ha, reg, 0);
-                                        mb2 = RD_MAILBOX_REG(ha, reg, 2);
-
-                                        WRT_REG_WORD(&reg->hccr,
-                                            HCCR_CLR_RISC_INT);
-                                        RD_REG_WORD(&reg->hccr);
-                                        break;
-                                }
+        /* Get RISC SRAM. */
+        if (rval == QLA_SUCCESS)
+                rval = qla2xxx_dump_ram(ha, 0x800, fw->risc_ram,
+                    sizeof(fw->risc_ram) / 2, &nxt);
 
-                                /* clear this intr; it wasn't a mailbox intr */
-                                WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
-                                RD_REG_WORD(&reg->hccr);
-                        }
-                        udelay(5);
-                }
+        /* Get stack SRAM. */
+        if (rval == QLA_SUCCESS)
+                rval = qla2xxx_dump_ram(ha, 0x10000, fw->stack_ram,
+                    sizeof(fw->stack_ram) / 2, &nxt);
 
-                if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
-                        rval = mb0 & MBS_MASK;
-                        fw->data_ram[cnt] = htons(mb2);
-                } else {
-                        rval = QLA_FUNCTION_FAILED;
-                }
-        }
+        /* Get data SRAM. */
+        if (rval == QLA_SUCCESS)
+                rval = qla2xxx_dump_ram(ha, 0x11000, fw->data_ram,
+                    ha->fw_memory_size - 0x11000 + 1, &nxt);
 
         if (rval == QLA_SUCCESS)
-                qla2xxx_copy_queues(ha, &fw->data_ram[cnt]);
+                qla2xxx_copy_queues(ha, nxt);
 
         if (rval != QLA_SUCCESS) {
                 qla_printk(KERN_WARNING, ha,
@@ -1010,7 +902,7 @@ qla24xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
                 goto qla24xx_fw_dump_failed_0;
 
         rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
-            fw->ext_mem, &nxt);
+            &nxt);
         if (rval != QLA_SUCCESS)
                 goto qla24xx_fw_dump_failed_0;
 
@@ -1318,7 +1210,7 @@ qla25xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
                 goto qla25xx_fw_dump_failed_0;
 
         rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
-            fw->ext_mem, &nxt);
+            &nxt);
         if (rval != QLA_SUCCESS)
                 goto qla25xx_fw_dump_failed_0;
 
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index 078f2a15f40b..cf194517400d 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -1036,22 +1036,6 @@ struct mid_db_entry_24xx {
         uint8_t reserved_1;
 };
 
- /*
- * Virtual Fabric ID type definition.
- */
-typedef struct vf_id {
-        uint16_t id : 12;
-        uint16_t priority : 4;
-} vf_id_t;
-
-/*
- * Virtual Fabric HopCt type definition.
- */
-typedef struct vf_hopct {
-        uint16_t reserved : 8;
-        uint16_t hopct : 8;
-} vf_hopct_t;
-
 /*
  * Virtual Port Control IOCB
  */
@@ -1082,10 +1066,10 @@ struct vp_ctrl_entry_24xx {
 
         uint8_t vp_idx_map[16];
         uint16_t flags;
-        struct vf_id    id;
+        uint16_t id;
         uint16_t reserved_4;
-        struct vf_hopct  hopct;
-        uint8_t reserved_5[8];
+        uint16_t hopct;
+        uint8_t reserved_5[24];
 };
 
 /*
@@ -1132,9 +1116,9 @@ struct vp_config_entry_24xx {
         uint16_t reserved_vp2;
         uint8_t port_name_idx2[WWN_SIZE];
         uint8_t node_name_idx2[WWN_SIZE];
-        struct vf_id    id;
+        uint16_t id;
         uint16_t reserved_4;
-        struct vf_hopct  hopct;
+        uint16_t hopct;
         uint8_t reserved_5;
 };
 
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 76eb4fecce65..f8827068d30f 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -152,10 +152,6 @@ extern int
 qla2x00_issue_iocb(scsi_qla_host_t *, void *, dma_addr_t, size_t);
 
 extern int
-qla2x00_issue_iocb_timeout(scsi_qla_host_t *, void *, dma_addr_t, size_t,
-    uint32_t);
-
-extern int
 qla2x00_abort_command(scsi_qla_host_t *, srb_t *);
 
 extern int
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 750d7ef83aae..4cb80b476c85 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -1583,8 +1583,8 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *ha)
         eiter->type = __constant_cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
         eiter->len = __constant_cpu_to_be16(4 + 4);
         max_frame_size = IS_FWI2_CAPABLE(ha) ?
-                (uint32_t) icb24->frame_payload_size:
-                (uint32_t) ha->init_cb->frame_payload_size;
+            le16_to_cpu(icb24->frame_payload_size):
+            le16_to_cpu(ha->init_cb->frame_payload_size);
         eiter->a.max_frame_size = cpu_to_be32(max_frame_size);
         size += 4 + 4;
 
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 01e26087c1dd..bbbc5a632a1d 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -3645,7 +3645,7 @@ qla24xx_nvram_config(scsi_qla_host_t *ha)
         if (le16_to_cpu(nv->login_timeout) < 4)
                 nv->login_timeout = __constant_cpu_to_le16(4);
         ha->login_timeout = le16_to_cpu(nv->login_timeout);
-        icb->login_timeout = cpu_to_le16(nv->login_timeout);
+        icb->login_timeout = nv->login_timeout;
 
         /* Set minimum RATOV to 100 tenths of a second. */
         ha->r_a_tov = 100;
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 285479b62d8f..5d9a64a7879b 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -409,6 +409,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                 }
 
                 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
+                set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
 
                 ha->flags.management_server_logged_in = 0;
                 qla2x00_post_aen_work(ha, FCH_EVT_LIP, mb[1]);
@@ -454,8 +455,6 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
 
                 ha->flags.management_server_logged_in = 0;
                 ha->link_data_rate = PORT_SPEED_UNKNOWN;
-                if (ql2xfdmienable)
-                        set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
                 qla2x00_post_aen_work(ha, FCH_EVT_LINKDOWN, 0);
                 break;
 
@@ -511,6 +510,7 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
                         set_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
                 }
                 set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
+                set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
 
                 ha->flags.gpsc_supported = 1;
                 ha->flags.management_server_logged_in = 0;
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 7d0a8a4c7719..210060420809 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -681,7 +681,7 @@ qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr)
  * Context:
  *      Kernel context.
  */
-int
+static int
 qla2x00_issue_iocb_timeout(scsi_qla_host_t *ha, void *buffer,
     dma_addr_t phys_addr, size_t size, uint32_t tov)
 {
@@ -784,7 +784,6 @@ qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp)
                 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
                     ha->host_no, rval));
         } else {
-                sp->flags |= SRB_ABORT_PENDING;
                 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
                     ha->host_no));
         }
@@ -1469,7 +1468,7 @@ qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
         lg->port_id[0] = al_pa;
         lg->port_id[1] = area;
         lg->port_id[2] = domain;
-        lg->vp_index = cpu_to_le16(ha->vp_idx);
+        lg->vp_index = ha->vp_idx;
         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
@@ -1724,7 +1723,7 @@ qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
         lg->port_id[0] = al_pa;
         lg->port_id[1] = area;
         lg->port_id[2] = domain;
-        lg->vp_index = cpu_to_le16(ha->vp_idx);
+        lg->vp_index = ha->vp_idx;
         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
@@ -2210,7 +2209,6 @@ qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
-                sp->flags |= SRB_ABORT_PENDING;
         }
 
         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
@@ -2644,12 +2642,11 @@ qla24xx_report_id_acquisition(scsi_qla_host_t *ha,
         struct vp_rpt_id_entry_24xx *rptid_entry)
 {
         uint8_t vp_idx;
+        uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
         scsi_qla_host_t *vha;
 
         if (rptid_entry->entry_status != 0)
                 return;
-        if (rptid_entry->entry_status != __constant_cpu_to_le16(CS_COMPLETE))
-                return;
 
         if (rptid_entry->format == 0) {
                 DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d,"
@@ -2659,17 +2656,17 @@ qla24xx_report_id_acquisition(scsi_qla_host_t *ha,
                         rptid_entry->port_id[2], rptid_entry->port_id[1],
                         rptid_entry->port_id[0]));
         } else if (rptid_entry->format == 1) {
-                vp_idx = LSB(rptid_entry->vp_idx);
+                vp_idx = LSB(stat);
                 DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled "
                     "- status %d - "
                     "with port id %02x%02x%02x\n",__func__,ha->host_no,
-                    vp_idx, MSB(rptid_entry->vp_idx),
+                    vp_idx, MSB(stat),
                     rptid_entry->port_id[2], rptid_entry->port_id[1],
                     rptid_entry->port_id[0]));
                 if (vp_idx == 0)
                         return;
 
-                if (MSB(rptid_entry->vp_idx) == 1)
+                if (MSB(stat) == 1)
                         return;
 
                 list_for_each_entry(vha, &ha->vp_list, vp_list)
@@ -2982,8 +2979,8 @@ qla84xx_verify_chip(struct scsi_qla_host *ha, uint16_t *status)
         /* We update the firmware with only one data sequence. */
         options |= VCO_END_OF_DATA;
 
-        retry = 0;
         do {
+                retry = 0;
                 memset(mn, 0, sizeof(*mn));
                 mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
                 mn->p.req.entry_count = 1;
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 8b33b163b1d4..3223fd16bcfe 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -67,7 +67,7 @@ static void qla2x00_free_device(scsi_qla_host_t *);
 
 static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha);
 
-int ql2xfdmienable;
+int ql2xfdmienable=1;
 module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR);
 MODULE_PARM_DESC(ql2xfdmienable,
                 "Enables FDMI registratons "
@@ -2135,7 +2135,7 @@ qla2x00_mem_free(scsi_qla_host_t *ha)
         kfree(ha->nvram);
 }
 
-struct qla_work_evt *
+static struct qla_work_evt *
 qla2x00_alloc_work(struct scsi_qla_host *ha, enum qla_work_type type,
     int locked)
 {
@@ -2152,7 +2152,7 @@ qla2x00_alloc_work(struct scsi_qla_host *ha, enum qla_work_type type,
         return e;
 }
 
-int
+static int
 qla2x00_post_work(struct scsi_qla_host *ha, struct qla_work_evt *e, int locked)
 {
         unsigned long flags;
@@ -2373,7 +2373,7 @@ qla2x00_do_dpc(void *data)
                                         } else {
                                                 fcport->login_retry = 0;
                                         }
-                                        if (fcport->login_retry == 0)
+                                        if (fcport->login_retry == 0 && status != QLA_SUCCESS)
                                                 fcport->loop_id = FC_NO_LOOP_ID;
                                 }
                                 if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
@@ -2599,6 +2599,10 @@ qla2x00_timer(scsi_qla_host_t *ha)
                 start_dpc++;
         }
 
+        /* Process any deferred work. */
+        if (!list_empty(&ha->work_list))
+                start_dpc++;
+
         /* Schedule the DPC routine if needed */
         if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) ||
             test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) ||
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index f42f17acf2cf..afeae2bfe7eb 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.02.01-k1"
+#define QLA2XXX_VERSION      "8.02.01-k2"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    2
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 3f34e9376b0a..b33e72516ef8 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -121,6 +121,7 @@ extern struct scsi_transport_template blank_transport_template;
 extern void __scsi_remove_device(struct scsi_device *);
 
 extern struct bus_type scsi_bus_type;
+extern struct attribute_group *scsi_sysfs_shost_attr_groups[];
 
 /* scsi_netlink.c */
 #ifdef CONFIG_SCSI_NETLINK
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index ed395154a5b1..3a1c99d5c775 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -190,10 +190,14 @@ void scsi_proc_host_rm(struct Scsi_Host *shost)
  */
 static int proc_print_scsidevice(struct device *dev, void *data)
 {
-        struct scsi_device *sdev = to_scsi_device(dev);
+        struct scsi_device *sdev;
         struct seq_file *s = data;
         int i;
 
+        if (!scsi_is_sdev_device(dev))
+                goto out;
+
+        sdev = to_scsi_device(dev);
         seq_printf(s,
                 "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
                 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
@@ -230,6 +234,7 @@ static int proc_print_scsidevice(struct device *dev, void *data)
         else
                 seq_printf(s, "\n");
 
+out:
         return 0;
 }
 
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index e67c14e31bab..fcd7455ffc39 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -322,6 +322,21 @@ out:
         return NULL;
 }
 
+static void scsi_target_destroy(struct scsi_target *starget)
+{
+        struct device *dev = &starget->dev;
+        struct Scsi_Host *shost = dev_to_shost(dev->parent);
+        unsigned long flags;
+
+        transport_destroy_device(dev);
+        spin_lock_irqsave(shost->host_lock, flags);
+        if (shost->hostt->target_destroy)
+                shost->hostt->target_destroy(starget);
+        list_del_init(&starget->siblings);
+        spin_unlock_irqrestore(shost->host_lock, flags);
+        put_device(dev);
+}
+
 static void scsi_target_dev_release(struct device *dev)
 {
         struct device *parent = dev->parent;
@@ -331,9 +346,14 @@ static void scsi_target_dev_release(struct device *dev)
         put_device(parent);
 }
 
+struct device_type scsi_target_type = {
+        .name =         "scsi_target",
+        .release =      scsi_target_dev_release,
+};
+
 int scsi_is_target_device(const struct device *dev)
 {
-        return dev->release == scsi_target_dev_release;
+        return dev->type == &scsi_target_type;
 }
 EXPORT_SYMBOL(scsi_is_target_device);
 
@@ -391,14 +411,17 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         device_initialize(dev);
         starget->reap_ref = 1;
         dev->parent = get_device(parent);
-        dev->release = scsi_target_dev_release;
         sprintf(dev->bus_id, "target%d:%d:%d",
                 shost->host_no, channel, id);
+#ifndef CONFIG_SYSFS_DEPRECATED
+        dev->bus = &scsi_bus_type;
+#endif
+        dev->type = &scsi_target_type;
         starget->id = id;
         starget->channel = channel;
         INIT_LIST_HEAD(&starget->siblings);
         INIT_LIST_HEAD(&starget->devices);
-        starget->state = STARGET_RUNNING;
+        starget->state = STARGET_CREATED;
         starget->scsi_level = SCSI_2;
  retry:
         spin_lock_irqsave(shost->host_lock, flags);
@@ -411,18 +434,6 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
         spin_unlock_irqrestore(shost->host_lock, flags);
         /* allocate and add */
         transport_setup_device(dev);
-        error = device_add(dev);
-        if (error) {
-                dev_err(dev, "target device_add failed, error %d\n", error);
-                spin_lock_irqsave(shost->host_lock, flags);
-                list_del_init(&starget->siblings);
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                transport_destroy_device(dev);
-                put_device(parent);
-                kfree(starget);
-                return NULL;
-        }
-        transport_add_device(dev);
         if (shost->hostt->target_alloc) {
                 error = shost->hostt->target_alloc(starget);
 
@@ -430,9 +441,7 @@ static struct scsi_target *scsi_alloc_target(struct device *parent,
                         dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
                         /* don't want scsi_target_reap to do the final
                          * put because it will be under the host lock */
-                        get_device(dev);
-                        scsi_target_reap(starget);
-                        put_device(dev);
+                        scsi_target_destroy(starget);
                         return NULL;
                 }
         }
@@ -459,18 +468,10 @@ static void scsi_target_reap_usercontext(struct work_struct *work)
 {
         struct scsi_target *starget =
                 container_of(work, struct scsi_target, ew.work);
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
-        unsigned long flags;
 
         transport_remove_device(&starget->dev);
         device_del(&starget->dev);
-        transport_destroy_device(&starget->dev);
-        spin_lock_irqsave(shost->host_lock, flags);
-        if (shost->hostt->target_destroy)
-                shost->hostt->target_destroy(starget);
-        list_del_init(&starget->siblings);
-        spin_unlock_irqrestore(shost->host_lock, flags);
-        put_device(&starget->dev);
+        scsi_target_destroy(starget);
 }
 
 /**
@@ -485,21 +486,25 @@ void scsi_target_reap(struct scsi_target *starget)
 {
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
         unsigned long flags;
+        enum scsi_target_state state;
+        int empty;
 
         spin_lock_irqsave(shost->host_lock, flags);
+        state = starget->state;
+        empty = --starget->reap_ref == 0 &&
+                list_empty(&starget->devices) ? 1 : 0;
+        spin_unlock_irqrestore(shost->host_lock, flags);
 
-        if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
-                BUG_ON(starget->state == STARGET_DEL);
-                starget->state = STARGET_DEL;
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                execute_in_process_context(scsi_target_reap_usercontext,
-                                           &starget->ew);
+        if (!empty)
                 return;
 
-        }
-        spin_unlock_irqrestore(shost->host_lock, flags);
-
-        return;
+        BUG_ON(state == STARGET_DEL);
+        starget->state = STARGET_DEL;
+        if (state == STARGET_CREATED)
+                scsi_target_destroy(starget);
+        else
+                execute_in_process_context(scsi_target_reap_usercontext,
+                                           &starget->ew);
 }
 
 /**
@@ -1048,8 +1053,9 @@ static int scsi_probe_and_add_lun(struct scsi_target *starget,
                                         scsi_inq_str(vend, result, 8, 16),
                                         scsi_inq_str(mod, result, 16, 32));
                         });
+
                 }
-                
+
                 res = SCSI_SCAN_TARGET_PRESENT;
                 goto out_free_result;
         }
@@ -1489,7 +1495,6 @@ struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
         if (scsi_host_scan_allowed(shost))
                 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
         mutex_unlock(&shost->scan_mutex);
-        transport_configure_device(&starget->dev);
         scsi_target_reap(starget);
         put_device(&starget->dev);
 
@@ -1570,7 +1575,6 @@ static void __scsi_scan_target(struct device *parent, unsigned int channel,
  out_reap:
         /* now determine if the target has any children at all
          * and if not, nuke it */
-        transport_configure_device(&starget->dev);
         scsi_target_reap(starget);
 
         put_device(&starget->dev);
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 67bb20ed45d2..049103f1d16f 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -21,6 +21,8 @@
 #include "scsi_priv.h"
 #include "scsi_logging.h"
 
+static struct device_type scsi_dev_type;
+
 static const struct {
         enum scsi_device_state  value;
         char                    *name;
@@ -249,18 +251,27 @@ shost_rd_attr(sg_tablesize, "%hu\n");
 shost_rd_attr(unchecked_isa_dma, "%d\n");
 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
 
-static struct device_attribute *scsi_sysfs_shost_attrs[] = {
-        &dev_attr_unique_id,
-        &dev_attr_host_busy,
-        &dev_attr_cmd_per_lun,
-        &dev_attr_can_queue,
-        &dev_attr_sg_tablesize,
-        &dev_attr_unchecked_isa_dma,
-        &dev_attr_proc_name,
-        &dev_attr_scan,
-        &dev_attr_hstate,
-        &dev_attr_supported_mode,
-        &dev_attr_active_mode,
+static struct attribute *scsi_sysfs_shost_attrs[] = {
+        &dev_attr_unique_id.attr,
+        &dev_attr_host_busy.attr,
+        &dev_attr_cmd_per_lun.attr,
+        &dev_attr_can_queue.attr,
+        &dev_attr_sg_tablesize.attr,
+        &dev_attr_unchecked_isa_dma.attr,
+        &dev_attr_proc_name.attr,
+        &dev_attr_scan.attr,
+        &dev_attr_hstate.attr,
+        &dev_attr_supported_mode.attr,
+        &dev_attr_active_mode.attr,
+        NULL
+};
+
+struct attribute_group scsi_shost_attr_group = {
+        .attrs =        scsi_sysfs_shost_attrs,
+};
+
+struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
+        &scsi_shost_attr_group,
         NULL
 };
 
@@ -335,7 +346,12 @@ static struct class sdev_class = {
 /* all probing is done in the individual ->probe routines */
 static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
 {
-        struct scsi_device *sdp = to_scsi_device(dev);
+        struct scsi_device *sdp;
+
+        if (dev->type != &scsi_dev_type)
+                return 0;
+
+        sdp = to_scsi_device(dev);
         if (sdp->no_uld_attach)
                 return 0;
         return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
@@ -351,10 +367,16 @@ static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 
 static int scsi_bus_suspend(struct device * dev, pm_message_t state)
 {
-        struct device_driver *drv = dev->driver;
-        struct scsi_device *sdev = to_scsi_device(dev);
+        struct device_driver *drv;
+        struct scsi_device *sdev;
         int err;
 
+        if (dev->type != &scsi_dev_type)
+                return 0;
+
+        drv = dev->driver;
+        sdev = to_scsi_device(dev);
+
         err = scsi_device_quiesce(sdev);
         if (err)
                 return err;
@@ -370,10 +392,16 @@ static int scsi_bus_suspend(struct device * dev, pm_message_t state)
 
 static int scsi_bus_resume(struct device * dev)
 {
-        struct device_driver *drv = dev->driver;
-        struct scsi_device *sdev = to_scsi_device(dev);
+        struct device_driver *drv;
+        struct scsi_device *sdev;
         int err = 0;
 
+        if (dev->type != &scsi_dev_type)
+                return 0;
+
+        drv = dev->driver;
+        sdev = to_scsi_device(dev);
+
         if (drv && drv->resume)
                 err = drv->resume(dev);
 
@@ -781,6 +809,27 @@ sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
+static int scsi_target_add(struct scsi_target *starget)
+{
+        int error;
+
+        if (starget->state != STARGET_CREATED)
+                return 0;
+
+        error = device_add(&starget->dev);
+        if (error) {
+                dev_err(&starget->dev, "target device_add failed, error %d\n", error);
+                get_device(&starget->dev);
+                scsi_target_reap(starget);
+                put_device(&starget->dev);
+                return error;
+        }
+        transport_add_device(&starget->dev);
+        starget->state = STARGET_RUNNING;
+
+        return 0;
+}
+
 static struct device_attribute sdev_attr_queue_type_rw =
         __ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
                sdev_store_queue_type_rw);
@@ -796,10 +845,16 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
 {
         int error, i;
         struct request_queue *rq = sdev->request_queue;
+        struct scsi_target *starget = sdev->sdev_target;
 
         if ((error = scsi_device_set_state(sdev, SDEV_RUNNING)) != 0)
                 return error;
 
+        error = scsi_target_add(starget);
+        if (error)
+                return error;
+
+        transport_configure_device(&starget->dev);
         error = device_add(&sdev->sdev_gendev);
         if (error) {
                 put_device(sdev->sdev_gendev.parent);
@@ -834,7 +889,7 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
                 goto out;
         }
 
-        error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL);
+        error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 
         if (error)
                 sdev_printk(KERN_INFO, sdev,
@@ -971,44 +1026,6 @@ int scsi_register_interface(struct class_interface *intf)
 }
 EXPORT_SYMBOL(scsi_register_interface);
 
-
-static struct device_attribute *class_attr_overridden(
-                struct device_attribute **attrs,
-                struct device_attribute *attr)
-{
-        int i;
-
-        if (!attrs)
-                return NULL;
-        for (i = 0; attrs[i]; i++)
-                if (!strcmp(attrs[i]->attr.name, attr->attr.name))
-                        return attrs[i];
-        return NULL;
-}
-
-static int class_attr_add(struct device *classdev,
-                struct device_attribute *attr)
-{
-        struct device_attribute *base_attr;
-
-        /*
-         * Spare the caller from having to copy things it's not interested in.
-         */
-        base_attr = class_attr_overridden(scsi_sysfs_shost_attrs, attr);
-        if (base_attr) {
-                /* extend permissions */
-                attr->attr.mode |= base_attr->attr.mode;
-
-                /* override null show/store with default */
-                if (!attr->show)
-                        attr->show = base_attr->show;
-                if (!attr->store)
-                        attr->store = base_attr->store;
-        }
-
-        return device_create_file(classdev, attr);
-}
-
 /**
  * scsi_sysfs_add_host - add scsi host to subsystem
  * @shost:     scsi host struct to add to subsystem
@@ -1018,20 +1035,11 @@ int scsi_sysfs_add_host(struct Scsi_Host *shost)
 {
         int error, i;
 
+        /* add host specific attributes */
         if (shost->hostt->shost_attrs) {
                 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
-                        error = class_attr_add(&shost->shost_dev,
-                                        shost->hostt->shost_attrs[i]);
-                        if (error)
-                                return error;
-                }
-        }
-
-        for (i = 0; scsi_sysfs_shost_attrs[i]; i++) {
-                if (!class_attr_overridden(shost->hostt->shost_attrs,
-                                        scsi_sysfs_shost_attrs[i])) {
                         error = device_create_file(&shost->shost_dev,
-                                        scsi_sysfs_shost_attrs[i]);
+                                        shost->hostt->shost_attrs[i]);
                         if (error)
                                 return error;
                 }
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 6b092a6c295d..5fd64e70029d 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -1961,12 +1961,17 @@ fc_timed_out(struct scsi_cmnd *scmd)
 }
 
 /*
- * Must be called with shost->host_lock held
+ * Called by fc_user_scan to locate an rport on the shost that
+ * matches the channel and target id, and invoke scsi_scan_target()
+ * on the rport.
  */
-static int fc_user_scan(struct Scsi_Host *shost, uint channel,
-                uint id, uint lun)
+static void
+fc_user_scan_tgt(struct Scsi_Host *shost, uint channel, uint id, uint lun)
 {
         struct fc_rport *rport;
+        unsigned long flags;
+
+        spin_lock_irqsave(shost->host_lock, flags);
 
         list_for_each_entry(rport, &fc_host_rports(shost), peers) {
                 if (rport->scsi_target_id == -1)
@@ -1975,13 +1980,54 @@ static int fc_user_scan(struct Scsi_Host *shost, uint channel,
                 if (rport->port_state != FC_PORTSTATE_ONLINE)
                         continue;
 
-                if ((channel == SCAN_WILD_CARD || channel == rport->channel) &&
-                    (id == SCAN_WILD_CARD || id == rport->scsi_target_id)) {
-                        scsi_scan_target(&rport->dev, rport->channel,
-                                         rport->scsi_target_id, lun, 1);
+                if ((channel == rport->channel) &&
+                    (id == rport->scsi_target_id)) {
+                        spin_unlock_irqrestore(shost->host_lock, flags);
+                        scsi_scan_target(&rport->dev, channel, id, lun, 1);
+                        return;
                 }
         }
 
+        spin_unlock_irqrestore(shost->host_lock, flags);
+}
+
+/*
+ * Called via sysfs scan routines. Necessary, as the FC transport
+ * wants to place all target objects below the rport object. So this
+ * routine must invoke the scsi_scan_target() routine with the rport
+ * object as the parent.
+ */
+static int
+fc_user_scan(struct Scsi_Host *shost, uint channel, uint id, uint lun)
+{
+        uint chlo, chhi;
+        uint tgtlo, tgthi;
+
+        if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
+            ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
+            ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
+                return -EINVAL;
+
+        if (channel == SCAN_WILD_CARD) {
+                chlo = 0;
+                chhi = shost->max_channel + 1;
+        } else {
+                chlo = channel;
+                chhi = channel + 1;
+        }
+
+        if (id == SCAN_WILD_CARD) {
+                tgtlo = 0;
+                tgthi = shost->max_id;
+        } else {
+                tgtlo = id;
+                tgthi = id + 1;
+        }
+
+        for ( ; chlo < chhi; chlo++)
+                for ( ; tgtlo < tgthi; tgtlo++)
+                        fc_user_scan_tgt(shost, chlo, tgtlo, lun);
+
         return 0;
 }
 
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 27ec625ab771..7899e3dda9bf 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -192,6 +192,16 @@ static void sas_non_host_smp_request(struct request_queue *q)
         sas_smp_request(q, rphy_to_shost(rphy), rphy);
 }
 
+static void sas_host_release(struct device *dev)
+{
+        struct Scsi_Host *shost = dev_to_shost(dev);
+        struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
+        struct request_queue *q = sas_host->q;
+
+        if (q)
+                blk_cleanup_queue(q);
+}
+
 static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
 {
         struct request_queue *q;
@@ -199,6 +209,7 @@ static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
         struct device *dev;
         char namebuf[BUS_ID_SIZE];
         const char *name;
+        void (*release)(struct device *);
 
         if (!to_sas_internal(shost->transportt)->f->smp_handler) {
                 printk("%s can't handle SMP requests\n", shost->hostt->name);
@@ -209,17 +220,19 @@ static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
                 q = blk_init_queue(sas_non_host_smp_request, NULL);
                 dev = &rphy->dev;
                 name = dev->bus_id;
+                release = NULL;
         } else {
                 q = blk_init_queue(sas_host_smp_request, NULL);
                 dev = &shost->shost_gendev;
                 snprintf(namebuf, sizeof(namebuf),
                          "sas_host%d", shost->host_no);
                 name = namebuf;
+                release = sas_host_release;
         }
         if (!q)
                 return -ENOMEM;
 
-        error = bsg_register_queue(q, dev, name);
+        error = bsg_register_queue(q, dev, name, release);
         if (error) {
                 blk_cleanup_queue(q);
                 return -ENOMEM;
@@ -253,7 +266,6 @@ static void sas_bsg_remove(struct Scsi_Host *shost, struct sas_rphy *rphy)
                 return;
 
         bsg_unregister_queue(q);
-        blk_cleanup_queue(q);
 }
 
 /*
@@ -1301,6 +1313,9 @@ static void sas_expander_release(struct device *dev)
         struct sas_rphy *rphy = dev_to_rphy(dev);
         struct sas_expander_device *edev = rphy_to_expander_device(rphy);
 
+        if (rphy->q)
+                blk_cleanup_queue(rphy->q);
+
         put_device(dev->parent);
         kfree(edev);
 }
@@ -1310,6 +1325,9 @@ static void sas_end_device_release(struct device *dev)
         struct sas_rphy *rphy = dev_to_rphy(dev);
         struct sas_end_device *edev = rphy_to_end_device(rphy);
 
+        if (rphy->q)
+                blk_cleanup_queue(rphy->q);
+
         put_device(dev->parent);
         kfree(edev);
 }
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index bc12b5d5d676..75a64a6cae8c 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -24,6 +24,7 @@
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
+#include <linux/sysfs.h>
 #include <scsi/scsi.h>
 #include "scsi_priv.h"
 #include <scsi/scsi_device.h>
@@ -1374,11 +1375,11 @@ static int spi_host_configure(struct transport_container *tc,
  * overloads the return by setting 1<<1 if the attribute should
  * be writeable */
 #define TARGET_ATTRIBUTE_HELPER(name) \
-        (si->f->show_##name ? 1 : 0) + \
-        (si->f->set_##name ? 2 : 0)
+        (si->f->show_##name ? S_IRUGO : 0) | \
+        (si->f->set_##name ? S_IWUSR : 0)
 
-static int target_attribute_is_visible(struct kobject *kobj,
-                                       struct attribute *attr, int i)
+static mode_t target_attribute_is_visible(struct kobject *kobj,
+                                          struct attribute *attr, int i)
 {
         struct device *cdev = container_of(kobj, struct device, kobj);
         struct scsi_target *starget = transport_class_to_starget(cdev);
@@ -1428,7 +1429,7 @@ static int target_attribute_is_visible(struct kobject *kobj,
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(hold_mcs);
         else if (attr == &dev_attr_revalidate.attr)
-                return 1;
+                return S_IWUSR;
 
         return 0;
 }
@@ -1462,25 +1463,9 @@ static int spi_target_configure(struct transport_container *tc,
                                 struct device *cdev)
 {
         struct kobject *kobj = &cdev->kobj;
-        int i;
-        struct attribute *attr;
-        int rc;
-
-        for (i = 0; (attr = target_attributes[i]) != NULL; i++) {
-                int j = target_attribute_group.is_visible(kobj, attr, i);
-
-                /* FIXME: as well as returning -EEXIST, which we'd like
-                 * to ignore, sysfs also does a WARN_ON and dumps a trace,
-                 * which is bad, so temporarily, skip attributes that are
-                 * already visible (the revalidate one) */
-                if (j && attr != &dev_attr_revalidate.attr)
-                        rc = sysfs_add_file_to_group(kobj, attr,
-                                                target_attribute_group.name);
-                /* and make the attribute writeable if we have a set
-                 * function */
-                if ((j & 1))
-                        rc = sysfs_chmod_file(kobj, attr, attr->mode | S_IWUSR);
-        }
+
+        /* force an update based on parameters read from the device */
+        sysfs_update_group(kobj, &target_attribute_group);
 
         return 0;
 }
diff --git a/drivers/scsi/sgiwd93.c b/drivers/scsi/sgiwd93.c
index 03e359670506..31fe6051c799 100644
--- a/drivers/scsi/sgiwd93.c
+++ b/drivers/scsi/sgiwd93.c
@@ -313,7 +313,8 @@ static struct platform_driver sgiwd93_driver = {
         .probe  = sgiwd93_probe,
         .remove = __devexit_p(sgiwd93_remove),
         .driver = {
-                .name   = "sgiwd93"
+                .name   = "sgiwd93",
+                .owner  = THIS_MODULE,
         }
 };
 
@@ -333,3 +334,4 @@ module_exit(sgiwd93_module_exit);
 MODULE_DESCRIPTION("SGI WD33C93 driver");
 MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:sgiwd93");
diff --git a/drivers/scsi/sni_53c710.c b/drivers/scsi/sni_53c710.c
index 0a6b45b1b003..2bbef4c45a0d 100644
--- a/drivers/scsi/sni_53c710.c
+++ b/drivers/scsi/sni_53c710.c
@@ -53,6 +53,7 @@
 MODULE_AUTHOR("Thomas Bogendörfer");
 MODULE_DESCRIPTION("SNI RM 53c710 SCSI Driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:snirm_53c710");
 
 #define SNIRM710_CLOCK  32
 
@@ -136,6 +137,7 @@ static struct platform_driver snirm710_driver = {
         .remove = __devexit_p(snirm710_driver_remove),
         .driver = {
                 .name   = "snirm_53c710",
+                .owner  = THIS_MODULE,
         },
 };
 
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index a860c3a9ae99..e8db66ad0bde 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -4322,7 +4322,7 @@ static void do_remove_sysfs_files(void)
 static ssize_t
 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
+        struct st_modedef *STm = dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
@@ -4334,7 +4334,7 @@ DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
 static ssize_t
 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
+        struct st_modedef *STm = dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
@@ -4346,7 +4346,7 @@ DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
 static ssize_t
 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
+        struct st_modedef *STm = dev_get_drvdata(dev);
         ssize_t l = 0;
         char *fmt;
 
@@ -4361,7 +4361,7 @@ static ssize_t
 st_defcompression_show(struct device *dev, struct device_attribute *attr,
                        char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
+        struct st_modedef *STm = dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
@@ -4373,7 +4373,7 @@ DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
 static ssize_t
 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
+        struct st_modedef *STm = dev_get_drvdata(dev);
         struct scsi_tape *STp;
         int i, j, options;
         ssize_t l = 0;
diff --git a/drivers/scsi/sun3x_esp.c b/drivers/scsi/sun3x_esp.c
index 06152c7fa689..7514b3a0390e 100644
--- a/drivers/scsi/sun3x_esp.c
+++ b/drivers/scsi/sun3x_esp.c
@@ -294,6 +294,7 @@ static struct platform_driver esp_sun3x_driver = {
         .remove         = __devexit_p(esp_sun3x_remove),
         .driver = {
                 .name   = "sun3x_esp",
+                .owner  = THIS_MODULE,
         },
 };
 
@@ -314,3 +315,4 @@ MODULE_VERSION(DRV_VERSION);
 
 module_init(sun3x_esp_init);
 module_exit(sun3x_esp_exit);
+MODULE_ALIAS("platform:sun3x_esp");
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index 58d7eee4fe81..640333b1e75c 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1715,13 +1715,12 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned in
 
 }
 
-static irqreturn_t ihdlr(int irq, unsigned int j) {
+static irqreturn_t ihdlr(unsigned int j)
+{
    struct scsi_cmnd *SCpnt;
    unsigned int i, k, c, status, tstatus, reg, ret;
    struct mscp *spp, *cpp;
-
-   if (sh[j]->irq != irq)
-       panic("%s: ihdlr, irq %d, sh[j]->irq %d.\n", BN(j), irq, sh[j]->irq);
+   int irq = sh[j]->irq;
 
    /* Check if this board need to be serviced */
    if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none;
@@ -1935,7 +1934,7 @@ static irqreturn_t do_interrupt_handler(int irq, void *shap) {
    if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE;
 
    spin_lock_irqsave(sh[j]->host_lock, spin_flags);
-   ret = ihdlr(irq, j);
+   ret = ihdlr(j);
    spin_unlock_irqrestore(sh[j]->host_lock, spin_flags);
    return ret;
 }