81 files changed, 1349 insertions, 1470 deletions

diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 31dcd9142d54..dc8d1a90971f 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -417,6 +417,6 @@ static void __exit agp_ali_cleanup(void)
 module_init(agp_ali_init);
 module_exit(agp_ali_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
 
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 2812ee2b165a..52f4361eb6e4 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -772,6 +772,6 @@ module_init(agp_amd64_init);
 module_exit(agp_amd64_cleanup);
 #endif
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>, Andi Kleen");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>, Andi Kleen");
 module_param(agp_try_unsupported, bool, 0);
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index ae2791b926b9..f1537eece07f 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -561,6 +561,6 @@ static void __exit agp_ati_cleanup(void)
 module_init(agp_ati_init);
 module_exit(agp_ati_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
 
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 3a3cc03d401c..8c617ad7497f 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -349,7 +349,7 @@ static __init int agp_setup(char *s)
 __setup("agp=", agp_setup);
 #endif
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_DESCRIPTION("AGP GART driver");
 MODULE_LICENSE("GPL and additional rights");
 MODULE_ALIAS_MISCDEV(AGPGART_MINOR);
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 1108665913e2..9cf6e9bb017e 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -2390,5 +2390,5 @@ static void __exit agp_intel_cleanup(void)
 module_init(agp_intel_init);
 module_exit(agp_intel_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
diff --git a/drivers/char/agp/nvidia-agp.c b/drivers/char/agp/nvidia-agp.c
index 5bbed3d79db9..16acee2de117 100644
--- a/drivers/char/agp/nvidia-agp.c
+++ b/drivers/char/agp/nvidia-agp.c
@@ -1,7 +1,7 @@
 /*
  * Nvidia AGPGART routines.
  * Based upon a 2.4 agpgart diff by the folks from NVIDIA, and hacked up
- * to work in 2.5 by Dave Jones <davej@codemonkey.org.uk>
+ * to work in 2.5 by Dave Jones <davej@redhat.com>
  */
 
 #include <linux/module.h>
diff --git a/drivers/char/agp/via-agp.c b/drivers/char/agp/via-agp.c
index 9f4d49e1b59a..d3bd243867fc 100644
--- a/drivers/char/agp/via-agp.c
+++ b/drivers/char/agp/via-agp.c
@@ -595,4 +595,4 @@ module_init(agp_via_init);
 module_exit(agp_via_cleanup);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index f3cfb4c76125..408f5f92cb4e 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -219,7 +219,7 @@ static void hpet_timer_set_irq(struct hpet_dev *devp)
         for (irq = find_first_bit(&v, HPET_MAX_IRQ); irq < HPET_MAX_IRQ;
                 irq = find_next_bit(&v, HPET_MAX_IRQ, 1 + irq)) {
 
-                if (irq >= NR_IRQS) {
+                if (irq >= nr_irqs) {
                         irq = HPET_MAX_IRQ;
                         break;
                 }
diff --git a/drivers/char/random.c b/drivers/char/random.c
index c8752eaad483..705a839f1796 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -558,9 +558,26 @@ struct timer_rand_state {
         unsigned dont_count_entropy:1;
 };
 
-static struct timer_rand_state input_timer_state;
 static struct timer_rand_state *irq_timer_state[NR_IRQS];
 
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
+{
+        if (irq >= nr_irqs)
+                return NULL;
+
+        return irq_timer_state[irq];
+}
+
+static void set_timer_rand_state(unsigned int irq, struct timer_rand_state *state)
+{
+        if (irq >= nr_irqs)
+                return;
+
+        irq_timer_state[irq] = state;
+}
+
+static struct timer_rand_state input_timer_state;
+
 /*
  * This function adds entropy to the entropy "pool" by using timing
  * delays.  It uses the timer_rand_state structure to make an estimate
@@ -648,11 +665,15 @@ EXPORT_SYMBOL_GPL(add_input_randomness);
 
 void add_interrupt_randomness(int irq)
 {
-        if (irq >= NR_IRQS || irq_timer_state[irq] == NULL)
+        struct timer_rand_state *state;
+
+        state = get_timer_rand_state(irq);
+
+        if (state == NULL)
                 return;
 
         DEBUG_ENT("irq event %d\n", irq);
-        add_timer_randomness(irq_timer_state[irq], 0x100 + irq);
+        add_timer_randomness(state, 0x100 + irq);
 }
 
 #ifdef CONFIG_BLOCK
@@ -912,7 +933,12 @@ void rand_initialize_irq(int irq)
 {
         struct timer_rand_state *state;
 
-        if (irq >= NR_IRQS || irq_timer_state[irq])
+        if (irq >= nr_irqs)
+                return;
+
+        state = get_timer_rand_state(irq);
+
+        if (state)
                 return;
 
         /*
@@ -921,7 +947,7 @@ void rand_initialize_irq(int irq)
          */
         state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
         if (state)
-                irq_timer_state[irq] = state;
+                set_timer_rand_state(irq, state);
 }
 
 #ifdef CONFIG_BLOCK
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index d0c0d64ed366..ce0d9da52a8a 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -168,7 +168,7 @@ static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
 static struct sysrq_key_op sysrq_show_timers_op = {
         .handler        = sysrq_handle_show_timers,
         .help_msg       = "show-all-timers(Q)",
-        .action_msg     = "Show pending hrtimers (no others)",
+        .action_msg     = "Show clockevent devices & pending hrtimers (no others)",
 };
 
 static void sysrq_handle_mountro(int key, struct tty_struct *tty)
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index ffe9b4e3072e..54c837288d19 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -641,7 +641,7 @@ static int __devinit giu_probe(struct platform_device *dev)
         }
 
         irq = platform_get_irq(dev, 0);
-        if (irq < 0 || irq >= NR_IRQS)
+        if (irq < 0 || irq >= nr_irqs)
                 return -EBUSY;
 
         return cascade_irq(irq, giu_get_irq);
diff --git a/drivers/clocksource/acpi_pm.c b/drivers/clocksource/acpi_pm.c
index 71d2ac4e3f46..c20171078d1d 100644
--- a/drivers/clocksource/acpi_pm.c
+++ b/drivers/clocksource/acpi_pm.c
@@ -237,9 +237,12 @@ static int __init parse_pmtmr(char *arg)
 
         if (strict_strtoul(arg, 16, &base))
                 return -EINVAL;
-
+#ifdef CONFIG_X86_64
+        if (base > UINT_MAX)
+                return -ERANGE;
+#endif
         printk(KERN_INFO "PMTMR IOPort override: 0x%04x -> 0x%04lx\n",
-               (unsigned int)pmtmr_ioport, base);
+               pmtmr_ioport, base);
         pmtmr_ioport = base;
 
         return 1;
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index cd303901eb5b..904e57558bb5 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -48,13 +48,13 @@ config DW_DMAC
           can be integrated in chips such as the Atmel AT32ap7000.
 
 config FSL_DMA
-        bool "Freescale MPC85xx/MPC83xx DMA support"
-        depends on PPC
+        tristate "Freescale Elo and Elo Plus DMA support"
+        depends on FSL_SOC
         select DMA_ENGINE
         ---help---
-          Enable support for the Freescale DMA engine. Now, it support
-          MPC8560/40, MPC8555, MPC8548 and MPC8641 processors.
-          The MPC8349, MPC8360 is also supported.
+          Enable support for the Freescale Elo and Elo Plus DMA controllers.
+          The Elo is the DMA controller on some 82xx and 83xx parts, and the
+          Elo Plus is the DMA controller on 85xx and 86xx parts.
 
 config MV_XOR
         bool "Marvell XOR engine support"
diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
index a08d19704743..d1e381e35a9e 100644
--- a/drivers/dma/dmatest.c
+++ b/drivers/dma/dmatest.c
@@ -325,7 +325,12 @@ static enum dma_state_client dmatest_add_channel(struct dma_chan *chan)
         struct dmatest_thread   *thread;
         unsigned int            i;
 
-        dtc = kmalloc(sizeof(struct dmatest_chan), GFP_ATOMIC);
+        /* Have we already been told about this channel? */
+        list_for_each_entry(dtc, &dmatest_channels, node)
+                if (dtc->chan == chan)
+                        return DMA_DUP;
+
+        dtc = kmalloc(sizeof(struct dmatest_chan), GFP_KERNEL);
         if (!dtc) {
                 pr_warning("dmatest: No memory for %s\n", chan->dev.bus_id);
                 return DMA_NAK;
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index c0059ca58340..0b95dcce447e 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -370,7 +370,10 @@ static int fsl_dma_alloc_chan_resources(struct dma_chan *chan,
                                         struct dma_client *client)
 {
         struct fsl_dma_chan *fsl_chan = to_fsl_chan(chan);
-        LIST_HEAD(tmp_list);
+
+        /* Has this channel already been allocated? */
+        if (fsl_chan->desc_pool)
+                return 1;
 
         /* We need the descriptor to be aligned to 32bytes
          * for meeting FSL DMA specification requirement.
@@ -410,6 +413,8 @@ static void fsl_dma_free_chan_resources(struct dma_chan *chan)
         }
         spin_unlock_irqrestore(&fsl_chan->desc_lock, flags);
         dma_pool_destroy(fsl_chan->desc_pool);
+
+        fsl_chan->desc_pool = NULL;
 }
 
 static struct dma_async_tx_descriptor *
@@ -786,159 +791,29 @@ static void dma_do_tasklet(unsigned long data)
         fsl_chan_ld_cleanup(fsl_chan);
 }
 
-static void fsl_dma_callback_test(void *param)
-{
-        struct fsl_dma_chan *fsl_chan = param;
-        if (fsl_chan)
-                dev_dbg(fsl_chan->dev, "selftest: callback is ok!\n");
-}
-
-static int fsl_dma_self_test(struct fsl_dma_chan *fsl_chan)
-{
-        struct dma_chan *chan;
-        int err = 0;
-        dma_addr_t dma_dest, dma_src;
-        dma_cookie_t cookie;
-        u8 *src, *dest;
-        int i;
-        size_t test_size;
-        struct dma_async_tx_descriptor *tx1, *tx2, *tx3;
-
-        test_size = 4096;
-
-        src = kmalloc(test_size * 2, GFP_KERNEL);
-        if (!src) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc memory for test!\n");
-                return -ENOMEM;
-        }
-
-        dest = src + test_size;
-
-        for (i = 0; i < test_size; i++)
-                src[i] = (u8) i;
-
-        chan = &fsl_chan->common;
-
-        if (fsl_dma_alloc_chan_resources(chan, NULL) < 1) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc resources for DMA\n");
-                err = -ENODEV;
-                goto out;
-        }
-
-        /* TX 1 */
-        dma_src = dma_map_single(fsl_chan->dev, src, test_size / 2,
-                                 DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest, test_size / 2,
-                                  DMA_FROM_DEVICE);
-        tx1 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 2, 0);
-        async_tx_ack(tx1);
-
-        cookie = fsl_dma_tx_submit(tx1);
-        fsl_dma_memcpy_issue_pending(chan);
-        msleep(2);
-
-        if (fsl_dma_is_complete(chan, cookie, NULL, NULL) != DMA_SUCCESS) {
-                dev_err(fsl_chan->dev, "selftest: Time out!\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        /* Test free and re-alloc channel resources */
-        fsl_dma_free_chan_resources(chan);
-
-        if (fsl_dma_alloc_chan_resources(chan, NULL) < 1) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc resources for DMA\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        /* Continue to test
-         * TX 2
-         */
-        dma_src = dma_map_single(fsl_chan->dev, src + test_size / 2,
-                                        test_size / 4, DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest + test_size / 2,
-                                        test_size / 4, DMA_FROM_DEVICE);
-        tx2 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 4, 0);
-        async_tx_ack(tx2);
-
-        /* TX 3 */
-        dma_src = dma_map_single(fsl_chan->dev, src + test_size * 3 / 4,
-                                        test_size / 4, DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest + test_size * 3 / 4,
-                                        test_size / 4, DMA_FROM_DEVICE);
-        tx3 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 4, 0);
-        async_tx_ack(tx3);
-
-        /* Interrupt tx test */
-        tx1 = fsl_dma_prep_interrupt(chan, 0);
-        async_tx_ack(tx1);
-        cookie = fsl_dma_tx_submit(tx1);
-
-        /* Test exchanging the prepared tx sort */
-        cookie = fsl_dma_tx_submit(tx3);
-        cookie = fsl_dma_tx_submit(tx2);
-
-        if (dma_has_cap(DMA_INTERRUPT, ((struct fsl_dma_device *)
-            dev_get_drvdata(fsl_chan->dev->parent))->common.cap_mask)) {
-                tx3->callback = fsl_dma_callback_test;
-                tx3->callback_param = fsl_chan;
-        }
-        fsl_dma_memcpy_issue_pending(chan);
-        msleep(2);
-
-        if (fsl_dma_is_complete(chan, cookie, NULL, NULL) != DMA_SUCCESS) {
-                dev_err(fsl_chan->dev, "selftest: Time out!\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        err = memcmp(src, dest, test_size);
-        if (err) {
-                for (i = 0; (*(src + i) == *(dest + i)) && (i < test_size);
-                                i++);
-                dev_err(fsl_chan->dev, "selftest: Test failed, data %d/%ld is "
-                                "error! src 0x%x, dest 0x%x\n",
-                                i, (long)test_size, *(src + i), *(dest + i));
-        }
-
-free_resources:
-        fsl_dma_free_chan_resources(chan);
-out:
-        kfree(src);
-        return err;
-}
-
-static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
-                        const struct of_device_id *match)
+static int __devinit fsl_dma_chan_probe(struct fsl_dma_device *fdev,
+        struct device_node *node, u32 feature, const char *compatible)
 {
-        struct fsl_dma_device *fdev;
         struct fsl_dma_chan *new_fsl_chan;
         int err;
 
-        fdev = dev_get_drvdata(dev->dev.parent);
-        BUG_ON(!fdev);
-
         /* alloc channel */
         new_fsl_chan = kzalloc(sizeof(struct fsl_dma_chan), GFP_KERNEL);
         if (!new_fsl_chan) {
-                dev_err(&dev->dev, "No free memory for allocating "
+                dev_err(fdev->dev, "No free memory for allocating "
                                 "dma channels!\n");
                 return -ENOMEM;
         }
 
         /* get dma channel register base */
-        err = of_address_to_resource(dev->node, 0, &new_fsl_chan->reg);
+        err = of_address_to_resource(node, 0, &new_fsl_chan->reg);
         if (err) {
-                dev_err(&dev->dev, "Can't get %s property 'reg'\n",
-                                dev->node->full_name);
+                dev_err(fdev->dev, "Can't get %s property 'reg'\n",
+                                node->full_name);
                 goto err_no_reg;
         }
 
-        new_fsl_chan->feature = *(u32 *)match->data;
+        new_fsl_chan->feature = feature;
 
         if (!fdev->feature)
                 fdev->feature = new_fsl_chan->feature;
@@ -948,13 +823,13 @@ static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
          */
         WARN_ON(fdev->feature != new_fsl_chan->feature);
 
-        new_fsl_chan->dev = &dev->dev;
+        new_fsl_chan->dev = &new_fsl_chan->common.dev;
         new_fsl_chan->reg_base = ioremap(new_fsl_chan->reg.start,
                         new_fsl_chan->reg.end - new_fsl_chan->reg.start + 1);
 
         new_fsl_chan->id = ((new_fsl_chan->reg.start - 0x100) & 0xfff) >> 7;
         if (new_fsl_chan->id > FSL_DMA_MAX_CHANS_PER_DEVICE) {
-                dev_err(&dev->dev, "There is no %d channel!\n",
+                dev_err(fdev->dev, "There is no %d channel!\n",
                                 new_fsl_chan->id);
                 err = -EINVAL;
                 goto err_no_chan;
@@ -988,29 +863,23 @@ static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
                         &fdev->common.channels);
         fdev->common.chancnt++;
 
-        new_fsl_chan->irq = irq_of_parse_and_map(dev->node, 0);
+        new_fsl_chan->irq = irq_of_parse_and_map(node, 0);
         if (new_fsl_chan->irq != NO_IRQ) {
                 err = request_irq(new_fsl_chan->irq,
                                         &fsl_dma_chan_do_interrupt, IRQF_SHARED,
                                         "fsldma-channel", new_fsl_chan);
                 if (err) {
-                        dev_err(&dev->dev, "DMA channel %s request_irq error "
-                                "with return %d\n", dev->node->full_name, err);
+                        dev_err(fdev->dev, "DMA channel %s request_irq error "
+                                "with return %d\n", node->full_name, err);
                         goto err_no_irq;
                 }
         }
 
-        err = fsl_dma_self_test(new_fsl_chan);
-        if (err)
-                goto err_self_test;
-
-        dev_info(&dev->dev, "#%d (%s), irq %d\n", new_fsl_chan->id,
-                                match->compatible, new_fsl_chan->irq);
+        dev_info(fdev->dev, "#%d (%s), irq %d\n", new_fsl_chan->id,
+                                compatible, new_fsl_chan->irq);
 
         return 0;
 
-err_self_test:
-        free_irq(new_fsl_chan->irq, new_fsl_chan);
 err_no_irq:
         list_del(&new_fsl_chan->common.device_node);
 err_no_chan:
@@ -1020,38 +889,20 @@ err_no_reg:
         return err;
 }
 
-const u32 mpc8540_dma_ip_feature = FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN;
-const u32 mpc8349_dma_ip_feature = FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN;
-
-static struct of_device_id of_fsl_dma_chan_ids[] = {
-        {
-                .compatible = "fsl,eloplus-dma-channel",
-                .data = (void *)&mpc8540_dma_ip_feature,
-        },
-        {
-                .compatible = "fsl,elo-dma-channel",
-                .data = (void *)&mpc8349_dma_ip_feature,
-        },
-        {}
-};
-
-static struct of_platform_driver of_fsl_dma_chan_driver = {
-        .name = "of-fsl-dma-channel",
-        .match_table = of_fsl_dma_chan_ids,
-        .probe = of_fsl_dma_chan_probe,
-};
-
-static __init int of_fsl_dma_chan_init(void)
+static void fsl_dma_chan_remove(struct fsl_dma_chan *fchan)
 {
-        return of_register_platform_driver(&of_fsl_dma_chan_driver);
+        free_irq(fchan->irq, fchan);
+        list_del(&fchan->common.device_node);
+        iounmap(fchan->reg_base);
+        kfree(fchan);
 }
 
 static int __devinit of_fsl_dma_probe(struct of_device *dev,
                         const struct of_device_id *match)
 {
         int err;
-        unsigned int irq;
         struct fsl_dma_device *fdev;
+        struct device_node *child;
 
         fdev = kzalloc(sizeof(struct fsl_dma_device), GFP_KERNEL);
         if (!fdev) {
@@ -1085,9 +936,9 @@ static int __devinit of_fsl_dma_probe(struct of_device *dev,
         fdev->common.device_issue_pending = fsl_dma_memcpy_issue_pending;
         fdev->common.dev = &dev->dev;
 
-        irq = irq_of_parse_and_map(dev->node, 0);
-        if (irq != NO_IRQ) {
-                err = request_irq(irq, &fsl_dma_do_interrupt, IRQF_SHARED,
+        fdev->irq = irq_of_parse_and_map(dev->node, 0);
+        if (fdev->irq != NO_IRQ) {
+                err = request_irq(fdev->irq, &fsl_dma_do_interrupt, IRQF_SHARED,
                                         "fsldma-device", fdev);
                 if (err) {
                         dev_err(&dev->dev, "DMA device request_irq error "
@@ -1097,7 +948,21 @@ static int __devinit of_fsl_dma_probe(struct of_device *dev,
         }
 
         dev_set_drvdata(&(dev->dev), fdev);
-        of_platform_bus_probe(dev->node, of_fsl_dma_chan_ids, &dev->dev);
+
+        /* We cannot use of_platform_bus_probe() because there is no
+         * of_platform_bus_remove.  Instead, we manually instantiate every DMA
+         * channel object.
+         */
+        for_each_child_of_node(dev->node, child) {
+                if (of_device_is_compatible(child, "fsl,eloplus-dma-channel"))
+                        fsl_dma_chan_probe(fdev, child,
+                                FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN,
+                                "fsl,eloplus-dma-channel");
+                if (of_device_is_compatible(child, "fsl,elo-dma-channel"))
+                        fsl_dma_chan_probe(fdev, child,
+                                FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN,
+                                "fsl,elo-dma-channel");
+        }
 
         dma_async_device_register(&fdev->common);
         return 0;
@@ -1109,6 +974,30 @@ err_no_reg:
         return err;
 }
 
+static int of_fsl_dma_remove(struct of_device *of_dev)
+{
+        struct fsl_dma_device *fdev;
+        unsigned int i;
+
+        fdev = dev_get_drvdata(&of_dev->dev);
+
+        dma_async_device_unregister(&fdev->common);
+
+        for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++)
+                if (fdev->chan[i])
+                        fsl_dma_chan_remove(fdev->chan[i]);
+
+        if (fdev->irq != NO_IRQ)
+                free_irq(fdev->irq, fdev);
+
+        iounmap(fdev->reg_base);
+
+        kfree(fdev);
+        dev_set_drvdata(&of_dev->dev, NULL);
+
+        return 0;
+}
+
 static struct of_device_id of_fsl_dma_ids[] = {
         { .compatible = "fsl,eloplus-dma", },
         { .compatible = "fsl,elo-dma", },
@@ -1116,15 +1005,32 @@ static struct of_device_id of_fsl_dma_ids[] = {
 };
 
 static struct of_platform_driver of_fsl_dma_driver = {
-        .name = "of-fsl-dma",
+        .name = "fsl-elo-dma",
         .match_table = of_fsl_dma_ids,
         .probe = of_fsl_dma_probe,
+        .remove = of_fsl_dma_remove,
 };
 
 static __init int of_fsl_dma_init(void)
 {
-        return of_register_platform_driver(&of_fsl_dma_driver);
+        int ret;
+
+        pr_info("Freescale Elo / Elo Plus DMA driver\n");
+
+        ret = of_register_platform_driver(&of_fsl_dma_driver);
+        if (ret)
+                pr_err("fsldma: failed to register platform driver\n");
+
+        return ret;
+}
+
+static void __exit of_fsl_dma_exit(void)
+{
+        of_unregister_platform_driver(&of_fsl_dma_driver);
 }
 
-subsys_initcall(of_fsl_dma_chan_init);
 subsys_initcall(of_fsl_dma_init);
+module_exit(of_fsl_dma_exit);
+
+MODULE_DESCRIPTION("Freescale Elo / Elo Plus DMA driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/dma/fsldma.h b/drivers/dma/fsldma.h
index 6faf07ba0d0e..4f21a512d848 100644
--- a/drivers/dma/fsldma.h
+++ b/drivers/dma/fsldma.h
@@ -114,6 +114,7 @@ struct fsl_dma_device {
         struct dma_device common;
         struct fsl_dma_chan *chan[FSL_DMA_MAX_CHANS_PER_DEVICE];
         u32 feature;            /* The same as DMA channels */
+        int irq;                /* Channel IRQ */
 };
 
 /* Define macros for fsl_dma_chan->feature property */
diff --git a/drivers/dma/ioat_dma.c b/drivers/dma/ioat_dma.c
index bc8c6e3470ca..1ef68b315657 100644
--- a/drivers/dma/ioat_dma.c
+++ b/drivers/dma/ioat_dma.c
@@ -971,11 +971,9 @@ static struct ioat_desc_sw *ioat_dma_get_next_descriptor(
         switch (ioat_chan->device->version) {
         case IOAT_VER_1_2:
                 return ioat1_dma_get_next_descriptor(ioat_chan);
-                break;
         case IOAT_VER_2_0:
         case IOAT_VER_3_0:
                 return ioat2_dma_get_next_descriptor(ioat_chan);
-                break;
         }
         return NULL;
 }
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 22edc4273ef6..faa1cc66e9cf 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1143,7 +1143,7 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 
                 if (!is_out) {
                         int             irq = gpio_to_irq(gpio);
-                        struct irq_desc *desc = irq_desc + irq;
+                        struct irq_desc *desc = irq_to_desc(irq);
 
                         /* This races with request_irq(), set_irq_type(),
                          * and set_irq_wake() ... but those are "rare".
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 74a369a6116f..a820ca6fc327 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -84,21 +84,40 @@ config BLK_DEV_IDE_SATA
 
           If unsure, say N.
 
-config BLK_DEV_IDEDISK
-        tristate "Include IDE/ATA-2 DISK support"
-        ---help---
-          This will include enhanced support for MFM/RLL/IDE hard disks.  If
-          you have a MFM/RLL/IDE disk, and there is no special reason to use
-          the old hard disk driver instead, say Y.  If you have an SCSI-only
-          system, you can say N here.
+config IDE_GD
+        tristate "generic ATA/ATAPI disk support"
+        default y
+        help
+          Support for ATA/ATAPI disks (including ATAPI floppy drives).
 
-          To compile this driver as a module, choose M here: the
-          module will be called ide-disk.
-          Do not compile this driver as a module if your root file system
-          (the one containing the directory /) is located on the IDE disk.
+          To compile this driver as a module, choose M here.
+          The module will be called ide-gd_mod.
+
+          If unsure, say Y.
+
+config IDE_GD_ATA
+        bool "ATA disk support"
+        depends on IDE_GD
+        default y
+        help
+          This will include support for ATA hard disks.
 
           If unsure, say Y.
 
+config IDE_GD_ATAPI
+        bool "ATAPI floppy support"
+        depends on IDE_GD
+        select IDE_ATAPI
+        help
+          This will include support for ATAPI floppy drives
+          (i.e. Iomega ZIP or MKE LS-120).
+
+          For information about jumper settings and the question
+          of when a ZIP drive uses a partition table, see
+          <http://www.win.tue.nl/~aeb/linux/zip/zip-1.html>.
+
+          If unsure, say N.
+
 config BLK_DEV_IDECS
         tristate "PCMCIA IDE support"
         depends on PCMCIA
@@ -163,29 +182,6 @@ config BLK_DEV_IDETAPE
           To compile this driver as a module, choose M here: the
           module will be called ide-tape.
 
-config BLK_DEV_IDEFLOPPY
-        tristate "Include IDE/ATAPI FLOPPY support"
-        select IDE_ATAPI
-        ---help---
-          If you have an IDE floppy drive which uses the ATAPI protocol,
-          answer Y.  ATAPI is a newer protocol used by IDE CD-ROM/tape/floppy
-          drives, similar to the SCSI protocol.
-
-          The LS-120 and the IDE/ATAPI Iomega ZIP drive are also supported by
-          this driver. For information about jumper settings and the question
-          of when a ZIP drive uses a partition table, see
-          <http://www.win.tue.nl/~aeb/linux/zip/zip-1.html>.
-          (ATAPI PD-CD/CDR drives are not supported by this driver; support
-          for PD-CD/CDR drives is available if you answer Y to
-          "SCSI emulation support", below).
-
-          If you say Y here, the FLOPPY drive will be identified along with
-          other IDE devices, as "hdb" or "hdc", or something similar (check
-          the boot messages with dmesg).
-
-          To compile this driver as a module, choose M here: the
-          module will be called ide-floppy.
-
 config BLK_DEV_IDESCSI
         tristate "SCSI emulation support (DEPRECATED)"
         depends on SCSI
@@ -332,7 +328,7 @@ config IDEPCI_PCIBUS_ORDER
 # TODO: split it on per host driver config options (or module parameters)
 config BLK_DEV_OFFBOARD
         bool "Boot off-board chipsets first support (DEPRECATED)"
-        depends on BLK_DEV_IDEPCI && (BLK_DEV_AEC62XX || BLK_DEV_GENERIC || BLK_DEV_HPT34X || BLK_DEV_HPT366 || BLK_DEV_PDC202XX_NEW || BLK_DEV_PDC202XX_OLD || BLK_DEV_TC86C001)
+        depends on BLK_DEV_IDEPCI && (BLK_DEV_AEC62XX || BLK_DEV_GENERIC || BLK_DEV_HPT366 || BLK_DEV_PDC202XX_NEW || BLK_DEV_PDC202XX_OLD || BLK_DEV_TC86C001)
         help
           Normally, IDE controllers built into the motherboard (on-board
           controllers) are assigned to ide0 and ide1 while those on add-in PCI
@@ -482,28 +478,6 @@ config BLK_DEV_CS5535
 
           It is safe to say Y to this question.
 
-config BLK_DEV_HPT34X
-        tristate "HPT34X chipset support"
-        depends on BROKEN
-        select BLK_DEV_IDEDMA_PCI
-        help
-          This driver adds up to 4 more EIDE devices sharing a single
-          interrupt. The HPT343 chipset in its current form is a non-bootable
-          controller; the HPT345/HPT363 chipset is a bootable (needs BIOS FIX)
-          PCI UDMA controllers. This driver requires dynamic tuning of the
-          chipset during the ide-probe at boot time. It is reported to support
-          DVD II drives, by the manufacturer.
-
-config HPT34X_AUTODMA
-        bool "HPT34X AUTODMA support (EXPERIMENTAL)"
-        depends on BLK_DEV_HPT34X && EXPERIMENTAL
-        help
-          This is a dangerous thing to attempt currently! Please read the
-          comments at the top of <file:drivers/ide/pci/hpt34x.c>.  If you say Y
-          here, then say Y to "Use DMA by default when available" as well.
-
-          If unsure, say N.
-
 config BLK_DEV_HPT366
         tristate "HPT36X/37X chipset support"
         select BLK_DEV_IDEDMA_PCI
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index ceaf779054ea..093d3248ca89 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -37,18 +37,25 @@ obj-$(CONFIG_IDE_H8300)			+= h8300/
 obj-$(CONFIG_IDE_GENERIC)               += ide-generic.o
 obj-$(CONFIG_BLK_DEV_IDEPNP)            += ide-pnp.o
 
-ide-disk_mod-y += ide-disk.o ide-disk_ioctl.o
+ide-gd_mod-y += ide-gd.o
 ide-cd_mod-y += ide-cd.o ide-cd_ioctl.o ide-cd_verbose.o
-ide-floppy_mod-y += ide-floppy.o ide-floppy_ioctl.o
 
+ifeq ($(CONFIG_IDE_GD_ATA), y)
+        ide-gd_mod-y += ide-disk.o ide-disk_ioctl.o
 ifeq ($(CONFIG_IDE_PROC_FS), y)
-        ide-disk_mod-y += ide-disk_proc.o
-        ide-floppy_mod-y += ide-floppy_proc.o
+        ide-gd_mod-y += ide-disk_proc.o
+endif
+endif
+
+ifeq ($(CONFIG_IDE_GD_ATAPI), y)
+        ide-gd_mod-y += ide-floppy.o ide-floppy_ioctl.o
+ifeq ($(CONFIG_IDE_PROC_FS), y)
+        ide-gd_mod-y += ide-floppy_proc.o
+endif
 endif
 
-obj-$(CONFIG_BLK_DEV_IDEDISK)           += ide-disk_mod.o
+obj-$(CONFIG_IDE_GD)                    += ide-gd_mod.o
 obj-$(CONFIG_BLK_DEV_IDECD)             += ide-cd_mod.o
-obj-$(CONFIG_BLK_DEV_IDEFLOPPY)         += ide-floppy_mod.o
 obj-$(CONFIG_BLK_DEV_IDETAPE)           += ide-tape.o
 
 ifeq ($(CONFIG_BLK_DEV_IDECS), y)
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 2e305714c209..4e58b9e7a58a 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -191,7 +191,7 @@ int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
 {
         struct ide_atapi_pc pc;
 
-        if (drive->atapi_flags & IDE_AFLAG_NO_DOORLOCK)
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
                 return 0;
 
         ide_init_pc(&pc);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 3308b1cd3a33..13265a8827da 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -99,7 +99,7 @@ static void ide_cd_put(struct cdrom_info *cd)
 /* Mark that we've seen a media change and invalidate our internal buffers. */
 static void cdrom_saw_media_change(ide_drive_t *drive)
 {
-        drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
+        drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
         drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
 }
 
@@ -340,8 +340,8 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
         }
 
         ide_debug_log(IDE_DBG_RQ, "%s: stat: 0x%x, good_stat: 0x%x, "
-                      "rq->cmd_type: 0x%x, err: 0x%x\n", __func__, stat,
-                      good_stat, rq->cmd_type, err);
+                      "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x, err: 0x%x\n",
+                      __func__, stat, good_stat, rq->cmd[0], rq->cmd_type, err);
 
         if (blk_sense_request(rq)) {
                 /*
@@ -843,13 +843,10 @@ static void ide_cd_restore_request(ide_drive_t *drive, struct request *rq)
         rq->q->prep_rq_fn(rq->q, rq);
 }
 
-/*
- * All other packet commands.
- */
 static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct request *rq)
 {
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+        ide_debug_log(IDE_DBG_FUNC, "Call %s, rq->cmd[0]: 0x%x\n",
+                      __func__, rq->cmd[0]);
 
         /*
          * Some of the trailing request sense fields are optional,
@@ -876,7 +873,7 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
         if (!sense)
                 sense = &local_sense;
 
-        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x, "
+        ide_debug_log(IDE_DBG_PC, "Call %s, cmd[0]: 0x%x, write: 0x%x, "
                       "timeout: %d, cmd_flags: 0x%x\n", __func__, cmd[0], write,
                       timeout, cmd_flags);
 
@@ -1177,8 +1174,9 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         unsigned short sectors_per_frame =
                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 
-        ide_debug_log(IDE_DBG_RQ, "Call %s, write: 0x%x, secs_per_frame: %u\n",
-                      __func__, write, sectors_per_frame);
+        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x, "
+                      "secs_per_frame: %u\n",
+                      __func__, rq->cmd[0], write, sectors_per_frame);
 
         if (write) {
                 /* disk has become write protected */
@@ -1221,7 +1219,8 @@ static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
 static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 {
 
-        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd_type: 0x%x\n", __func__,
+        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, "
+                      "rq->cmd_type: 0x%x\n", __func__, rq->cmd[0],
                       rq->cmd_type);
 
         if (blk_pc_request(rq))
@@ -1257,9 +1256,6 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
         }
 }
 
-/*
- * cdrom driver request routine.
- */
 static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                                         sector_t block)
 {
@@ -1267,8 +1263,10 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
         ide_handler_t *fn;
         int xferlen;
 
-        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd_type: 0x%x, block: %llu\n",
-                      __func__, rq->cmd_type, (unsigned long long)block);
+        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, "
+                      "rq->cmd_type: 0x%x, block: %llu\n",
+                      __func__, rq->cmd[0], rq->cmd_type,
+                      (unsigned long long)block);
 
         if (blk_fs_request(rq)) {
                 if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
@@ -1412,6 +1410,10 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
 
         *capacity = 1 + be32_to_cpu(capbuf.lba);
         *sectors_per_frame = blocklen >> SECTOR_BITS;
+
+        ide_debug_log(IDE_DBG_PROBE, "%s: cap: %lu, sectors_per_frame: %lu\n",
+                      __func__, *capacity, *sectors_per_frame);
+
         return 0;
 }
 
@@ -1643,6 +1645,9 @@ void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
                 maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
         }
 
+        ide_debug_log(IDE_DBG_PROBE, "%s: curspeed: %u, maxspeed: %u\n",
+                      __func__, curspeed, maxspeed);
+
         cd->current_speed = (curspeed + (176/2)) / 176;
         cd->max_speed = (maxspeed + (176/2)) / 176;
 }
@@ -1732,7 +1737,7 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
                 return 0;
 
         if ((buf[8 + 6] & 0x01) == 0)
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
         if (buf[8 + 6] & 0x08)
                 drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
         if (buf[8 + 3] & 0x01)
@@ -1777,7 +1782,7 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
                 printk(KERN_CONT " DVD%s%s",
                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
-                                 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
+                                 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM");
 
         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
                 printk(KERN_CONT " CD%s%s",
@@ -1908,6 +1913,16 @@ static const struct ide_proc_devset idecd_settings[] = {
         IDE_PROC_DEVSET(dsc_overlap, 0, 1),
         { 0 },
 };
+
+static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive)
+{
+        return idecd_proc;
+}
+
+static const struct ide_proc_devset *ide_cd_proc_devsets(ide_drive_t *drive)
+{
+        return idecd_settings;
+}
 #endif
 
 static const struct cd_list_entry ide_cd_quirks_list[] = {
@@ -1986,8 +2001,8 @@ static int ide_cdrom_setup(ide_drive_t *drive)
         if (!drive->queue->unplug_delay)
                 drive->queue->unplug_delay = 1;
 
-        drive->atapi_flags = IDE_AFLAG_MEDIA_CHANGED | IDE_AFLAG_NO_EJECT |
-                       ide_cd_flags(id);
+        drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
+        drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
 
         if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
             fw_rev[4] == '1' && fw_rev[6] <= '2')
@@ -2069,8 +2084,8 @@ static ide_driver_t ide_cdrom_driver = {
         .end_request            = ide_end_request,
         .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idecd_proc,
-        .settings               = idecd_settings,
+        .proc_entries           = ide_cd_proc_entries,
+        .proc_devsets           = ide_cd_proc_devsets,
 #endif
 };
 
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index 74231b41f611..df3df0041eb6 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -86,8 +86,8 @@ int ide_cdrom_check_media_change_real(struct cdrom_device_info *cdi,
 
         if (slot_nr == CDSL_CURRENT) {
                 (void) cdrom_check_status(drive, NULL);
-                retval = (drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED) ? 1 : 0;
-                drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
+                retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
+                drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
                 return retval;
         } else {
                 return -EINVAL;
@@ -136,7 +136,7 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
                 sense = &my_sense;
 
         /* If the drive cannot lock the door, just pretend. */
-        if (drive->atapi_flags & IDE_AFLAG_NO_DOORLOCK) {
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) {
                 stat = 0;
         } else {
                 unsigned char cmd[BLK_MAX_CDB];
@@ -157,7 +157,7 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
             (sense->asc == 0x24 || sense->asc == 0x20)) {
                 printk(KERN_ERR "%s: door locking not supported\n",
                         drive->name);
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
                 stat = 0;
         }
 
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 3853bde8eedc..223750c1b5a6 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -14,9 +14,6 @@
  * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
  */
 
-#define IDEDISK_VERSION "1.18"
-
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
@@ -39,46 +36,8 @@
 #include <asm/io.h>
 #include <asm/div64.h>
 
-#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
-#define IDE_DISK_MINORS         (1 << PARTN_BITS)
-#else
-#define IDE_DISK_MINORS         0
-#endif
-
 #include "ide-disk.h"
 
-static DEFINE_MUTEX(idedisk_ref_mutex);
-
-#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
-
-static void ide_disk_release(struct kref *);
-
-static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = NULL;
-
-        mutex_lock(&idedisk_ref_mutex);
-        idkp = ide_disk_g(disk);
-        if (idkp) {
-                if (ide_device_get(idkp->drive))
-                        idkp = NULL;
-                else
-                        kref_get(&idkp->kref);
-        }
-        mutex_unlock(&idedisk_ref_mutex);
-        return idkp;
-}
-
-static void ide_disk_put(struct ide_disk_obj *idkp)
-{
-        ide_drive_t *drive = idkp->drive;
-
-        mutex_lock(&idedisk_ref_mutex);
-        kref_put(&idkp->kref, ide_disk_release);
-        ide_device_put(drive);
-        mutex_unlock(&idedisk_ref_mutex);
-}
-
 static const u8 ide_rw_cmds[] = {
         ATA_CMD_READ_MULTI,
         ATA_CMD_WRITE_MULTI,
@@ -374,7 +333,7 @@ static void idedisk_check_hpa(ide_drive_t *drive)
         }
 }
 
-static void init_idedisk_capacity(ide_drive_t *drive)
+static int ide_disk_get_capacity(ide_drive_t *drive)
 {
         u16 *id = drive->id;
         int lba;
@@ -403,11 +362,28 @@ static void init_idedisk_capacity(ide_drive_t *drive)
                 if (ata_id_hpa_enabled(id))
                         idedisk_check_hpa(drive);
         }
-}
 
-sector_t ide_disk_capacity(ide_drive_t *drive)
-{
-        return drive->capacity64;
+        /* limit drive capacity to 137GB if LBA48 cannot be used */
+        if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
+            drive->capacity64 > 1ULL << 28) {
+                printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
+                       "%llu sectors (%llu MB)\n",
+                       drive->name, (unsigned long long)drive->capacity64,
+                       sectors_to_MB(drive->capacity64));
+                drive->capacity64 = 1ULL << 28;
+        }
+
+        if ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
+            (drive->dev_flags & IDE_DFLAG_LBA48)) {
+                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);
+                } else
+                        drive->dev_flags &= ~IDE_DFLAG_LBA48;
+        }
+
+        return 0;
 }
 
 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
@@ -508,7 +484,7 @@ static void update_ordered(ide_drive_t *drive)
                  * time we have trimmed the drive capacity if LBA48 is
                  * not available so we don't need to recheck that.
                  */
-                capacity = ide_disk_capacity(drive);
+                capacity = ide_gd_capacity(drive);
                 barrier = ata_id_flush_enabled(id) &&
                         (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
                         ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
@@ -616,7 +592,12 @@ ide_ext_devset_rw(wcache, wcache);
 
 ide_ext_devset_rw_sync(nowerr, nowerr);
 
-static void idedisk_setup(ide_drive_t *drive)
+static int ide_disk_check(ide_drive_t *drive, const char *s)
+{
+        return 1;
+}
+
+static void ide_disk_setup(ide_drive_t *drive)
 {
         struct ide_disk_obj *idkp = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
@@ -652,33 +633,13 @@ static void idedisk_setup(ide_drive_t *drive)
                          drive->queue->max_sectors / 2);
 
         /* calculate drive capacity, and select LBA if possible */
-        init_idedisk_capacity(drive);
-
-        /* limit drive capacity to 137GB if LBA48 cannot be used */
-        if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
-            drive->capacity64 > 1ULL << 28) {
-                printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
-                       "%llu sectors (%llu MB)\n",
-                       drive->name, (unsigned long long)drive->capacity64,
-                       sectors_to_MB(drive->capacity64));
-                drive->capacity64 = 1ULL << 28;
-        }
-
-        if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
-            (drive->dev_flags & IDE_DFLAG_LBA48)) {
-                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);
-                } else
-                        drive->dev_flags &= ~IDE_DFLAG_LBA48;
-        }
+        ide_disk_get_capacity(drive);
 
         /*
          * if possible, give fdisk access to more of the drive,
          * by correcting bios_cyls:
          */
-        capacity = ide_disk_capacity(drive);
+        capacity = ide_gd_capacity(drive);
 
         if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
                 if (ata_id_lba48_enabled(drive->id)) {
@@ -718,9 +679,17 @@ static void idedisk_setup(ide_drive_t *drive)
                 drive->dev_flags |= IDE_DFLAG_WCACHE;
 
         set_wcache(drive, 1);
+
+        if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
+            (drive->head == 0 || drive->head > 16)) {
+                printk(KERN_ERR "%s: invalid geometry: %d physical heads?\n",
+                        drive->name, drive->head);
+                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
+        } else
+                drive->dev_flags |= IDE_DFLAG_ATTACH;
 }
 
-static void ide_cacheflush_p(ide_drive_t *drive)
+static void ide_disk_flush(ide_drive_t *drive)
 {
         if (ata_id_flush_enabled(drive->id) == 0 ||
             (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
@@ -730,267 +699,40 @@ static void ide_cacheflush_p(ide_drive_t *drive)
                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 }
 
-static void ide_disk_remove(ide_drive_t *drive)
-{
-        struct ide_disk_obj *idkp = drive->driver_data;
-        struct gendisk *g = idkp->disk;
-
-        ide_proc_unregister_driver(drive, idkp->driver);
-
-        del_gendisk(g);
-
-        ide_cacheflush_p(drive);
-
-        ide_disk_put(idkp);
-}
-
-static void ide_disk_release(struct kref *kref)
-{
-        struct ide_disk_obj *idkp = to_ide_disk(kref);
-        ide_drive_t *drive = idkp->drive;
-        struct gendisk *g = idkp->disk;
-
-        drive->driver_data = NULL;
-        g->private_data = NULL;
-        put_disk(g);
-        kfree(idkp);
-}
-
-static int ide_disk_probe(ide_drive_t *drive);
-
-/*
- * On HPA drives the capacity needs to be
- * reinitilized on resume otherwise the disk
- * can not be used and a hard reset is required
- */
-static void ide_disk_resume(ide_drive_t *drive)
+static int ide_disk_init_media(ide_drive_t *drive, struct gendisk *disk)
 {
-        if (ata_id_hpa_enabled(drive->id))
-                init_idedisk_capacity(drive);
-}
-
-static void ide_device_shutdown(ide_drive_t *drive)
-{
-#ifdef  CONFIG_ALPHA
-        /* On Alpha, halt(8) doesn't actually turn the machine off,
-           it puts you into the sort of firmware monitor. Typically,
-           it's used to boot another kernel image, so it's not much
-           different from reboot(8). Therefore, we don't need to
-           spin down the disk in this case, especially since Alpha
-           firmware doesn't handle disks in standby mode properly.
-           On the other hand, it's reasonably safe to turn the power
-           off when the shutdown process reaches the firmware prompt,
-           as the firmware initialization takes rather long time -
-           at least 10 seconds, which should be sufficient for
-           the disk to expire its write cache. */
-        if (system_state != SYSTEM_POWER_OFF) {
-#else
-        if (system_state == SYSTEM_RESTART) {
-#endif
-                ide_cacheflush_p(drive);
-                return;
-        }
-
-        printk(KERN_INFO "Shutdown: %s\n", drive->name);
-
-        drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
+        return 0;
 }
 
-static ide_driver_t idedisk_driver = {
-        .gen_driver = {
-                .owner          = THIS_MODULE,
-                .name           = "ide-disk",
-                .bus            = &ide_bus_type,
-        },
-        .probe                  = ide_disk_probe,
-        .remove                 = ide_disk_remove,
-        .resume                 = ide_disk_resume,
-        .shutdown               = ide_device_shutdown,
-        .version                = IDEDISK_VERSION,
-        .do_request             = ide_do_rw_disk,
-        .end_request            = ide_end_request,
-        .error                  = __ide_error,
-#ifdef CONFIG_IDE_PROC_FS
-        .proc                   = ide_disk_proc,
-        .settings               = ide_disk_settings,
-#endif
-};
-
-static int idedisk_set_doorlock(ide_drive_t *drive, int on)
+static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,
+                                 int on)
 {
         ide_task_t task;
+        int ret;
+
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
+                return 0;
 
         memset(&task, 0, sizeof(task));
         task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-        return ide_no_data_taskfile(drive, &task);
-}
-
-static int idedisk_open(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_disk_obj *idkp;
-        ide_drive_t *drive;
-
-        idkp = ide_disk_get(disk);
-        if (idkp == NULL)
-                return -ENXIO;
-
-        drive = idkp->drive;
-
-        idkp->openers++;
-
-        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
-                check_disk_change(inode->i_bdev);
-                /*
-                 * Ignore the return code from door_lock,
-                 * since the open() has already succeeded,
-                 * and the door_lock is irrelevant at this point.
-                 */
-                if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
-                    idedisk_set_doorlock(drive, 1))
-                        drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
-        }
-        return 0;
-}
-
-static int idedisk_release(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        ide_drive_t *drive = idkp->drive;
-
-        if (idkp->openers == 1)
-                ide_cacheflush_p(drive);
-
-        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
-                if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
-                    idedisk_set_doorlock(drive, 0))
-                        drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
-        }
+        ret = ide_no_data_taskfile(drive, &task);
 
-        idkp->openers--;
+        if (ret)
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
 
-        ide_disk_put(idkp);
-
-        return 0;
-}
-
-static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
-        ide_drive_t *drive = idkp->drive;
-
-        geo->heads = drive->bios_head;
-        geo->sectors = drive->bios_sect;
-        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
-        return 0;
+        return ret;
 }
 
-static int idedisk_media_changed(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        ide_drive_t *drive = idkp->drive;
-
-        /* do not scan partitions twice if this is a removable device */
-        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-                return 0;
-        }
-
-        /* if removable, always assume it was changed */
-        return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
-}
-
-static int idedisk_revalidate_disk(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        set_capacity(disk, ide_disk_capacity(idkp->drive));
-        return 0;
-}
-
-static struct block_device_operations idedisk_ops = {
-        .owner                  = THIS_MODULE,
-        .open                   = idedisk_open,
-        .release                = idedisk_release,
-        .ioctl                  = ide_disk_ioctl,
-        .getgeo                 = idedisk_getgeo,
-        .media_changed          = idedisk_media_changed,
-        .revalidate_disk        = idedisk_revalidate_disk
+const struct ide_disk_ops ide_ata_disk_ops = {
+        .check          = ide_disk_check,
+        .get_capacity   = ide_disk_get_capacity,
+        .setup          = ide_disk_setup,
+        .flush          = ide_disk_flush,
+        .init_media     = ide_disk_init_media,
+        .set_doorlock   = ide_disk_set_doorlock,
+        .do_request     = ide_do_rw_disk,
+        .end_request    = ide_end_request,
+        .ioctl          = ide_disk_ioctl,
 };
-
-MODULE_DESCRIPTION("ATA DISK Driver");
-
-static int ide_disk_probe(ide_drive_t *drive)
-{
-        struct ide_disk_obj *idkp;
-        struct gendisk *g;
-
-        /* strstr("foo", "") is non-NULL */
-        if (!strstr("ide-disk", drive->driver_req))
-                goto failed;
-
-        if (drive->media != ide_disk)
-                goto failed;
-
-        idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
-        if (!idkp)
-                goto failed;
-
-        g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
-        if (!g)
-                goto out_free_idkp;
-
-        ide_init_disk(g, drive);
-
-        kref_init(&idkp->kref);
-
-        idkp->drive = drive;
-        idkp->driver = &idedisk_driver;
-        idkp->disk = g;
-
-        g->private_data = &idkp->driver;
-
-        drive->driver_data = idkp;
-
-        idedisk_setup(drive);
-        if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
-            (drive->head == 0 || drive->head > 16)) {
-                printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
-                        drive->name, drive->head);
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-        } else
-                drive->dev_flags |= IDE_DFLAG_ATTACH;
-
-        g->minors = IDE_DISK_MINORS;
-        g->driverfs_dev = &drive->gendev;
-        g->flags |= GENHD_FL_EXT_DEVT;
-        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
-                g->flags = GENHD_FL_REMOVABLE;
-        set_capacity(g, ide_disk_capacity(drive));
-        g->fops = &idedisk_ops;
-        add_disk(g);
-        return 0;
-
-out_free_idkp:
-        kfree(idkp);
-failed:
-        return -ENODEV;
-}
-
-static void __exit idedisk_exit(void)
-{
-        driver_unregister(&idedisk_driver.gen_driver);
-}
-
-static int __init idedisk_init(void)
-{
-        return driver_register(&idedisk_driver.gen_driver);
-}
-
-MODULE_ALIAS("ide:*m-disk*");
-MODULE_ALIAS("ide-disk");
-module_init(idedisk_init);
-module_exit(idedisk_exit);
-MODULE_LICENSE("GPL");
diff --git a/drivers/ide/ide-disk.h b/drivers/ide/ide-disk.h
index a82fa4355665..b234b0feaf7b 100644
--- a/drivers/ide/ide-disk.h
+++ b/drivers/ide/ide-disk.h
@@ -1,19 +1,11 @@
 #ifndef __IDE_DISK_H
 #define __IDE_DISK_H
 
-struct ide_disk_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
-        unsigned int    openers;        /* protected by BKL for now */
-};
-
-#define ide_disk_g(disk) \
-        container_of((disk)->private_data, struct ide_disk_obj, driver)
+#include "ide-gd.h"
 
+#ifdef CONFIG_IDE_GD_ATA
 /* ide-disk.c */
-sector_t ide_disk_capacity(ide_drive_t *);
+extern const struct ide_disk_ops ide_ata_disk_ops;
 ide_decl_devset(address);
 ide_decl_devset(multcount);
 ide_decl_devset(nowerr);
@@ -21,12 +13,17 @@ ide_decl_devset(wcache);
 ide_decl_devset(acoustic);
 
 /* ide-disk_ioctl.c */
-int ide_disk_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+int ide_disk_ioctl(ide_drive_t *, struct inode *, struct file *, unsigned int,
+                   unsigned long);
 
 #ifdef CONFIG_IDE_PROC_FS
 /* ide-disk_proc.c */
 extern ide_proc_entry_t ide_disk_proc[];
 extern const struct ide_proc_devset ide_disk_settings[];
 #endif
+#else
+#define ide_disk_proc           NULL
+#define ide_disk_settings       NULL
+#endif
 
 #endif /* __IDE_DISK_H */
diff --git a/drivers/ide/ide-disk_ioctl.c b/drivers/ide/ide-disk_ioctl.c
index a6cf1a03a806..a49698bcf966 100644
--- a/drivers/ide/ide-disk_ioctl.c
+++ b/drivers/ide/ide-disk_ioctl.c
@@ -13,12 +13,10 @@ static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
 { 0 }
 };
 
-int ide_disk_ioctl(struct inode *inode, struct file *file,
+int ide_disk_ioctl(ide_drive_t *drive, struct inode *inode, struct file *file,
                    unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
-        struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
-        ide_drive_t *drive = idkp->drive;
         int err;
 
         err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
diff --git a/drivers/ide/ide-disk_proc.c b/drivers/ide/ide-disk_proc.c
index 4724976afe71..1146f4204c6e 100644
--- a/drivers/ide/ide-disk_proc.c
+++ b/drivers/ide/ide-disk_proc.c
@@ -56,7 +56,7 @@ static int proc_idedisk_read_capacity
         ide_drive_t*drive = (ide_drive_t *)data;
         int len;
 
-        len = sprintf(page, "%llu\n", (long long)ide_disk_capacity(drive));
+        len = sprintf(page, "%llu\n", (long long)ide_gd_capacity(drive));
 
         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
diff --git a/drivers/ide/ide-dma-sff.c b/drivers/ide/ide-dma-sff.c
index 0903782689e9..cac431f0df17 100644
--- a/drivers/ide/ide-dma-sff.c
+++ b/drivers/ide/ide-dma-sff.c
@@ -130,7 +130,7 @@ int ide_build_dmatable(ide_drive_t *drive, struct request *rq)
                         xcount = bcount & 0xffff;
                         if (is_trm290)
                                 xcount = ((xcount >> 2) - 1) << 16;
-                        if (xcount == 0x0000) {
+                        else if (xcount == 0x0000) {
                                 if (count++ >= PRD_ENTRIES)
                                         goto use_pio_instead;
                                 *table++ = cpu_to_le32(0x8000);
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index cf0aa25470ee..aeb1ad782f54 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -15,12 +15,6 @@
  * Documentation/ide/ChangeLog.ide-floppy.1996-2002
  */
 
-#define DRV_NAME "ide-floppy"
-#define PFX DRV_NAME ": "
-
-#define IDEFLOPPY_VERSION "1.00"
-
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
@@ -49,19 +43,6 @@
 
 #include "ide-floppy.h"
 
-/* module parameters */
-static unsigned long debug_mask;
-module_param(debug_mask, ulong, 0644);
-
-/* define to see debug info */
-#define IDEFLOPPY_DEBUG_LOG     0
-
-#if IDEFLOPPY_DEBUG_LOG
-#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
-#else
-#define ide_debug_log(lvl, fmt, args...) do {} while (0)
-#endif
-
 /*
  * After each failed packet command we issue a request sense command and retry
  * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
@@ -83,43 +64,13 @@ module_param(debug_mask, ulong, 0644);
 /* Error code returned in rq->errors to the higher part of the driver. */
 #define IDEFLOPPY_ERROR_GENERAL         101
 
-static DEFINE_MUTEX(idefloppy_ref_mutex);
-
-static void idefloppy_cleanup_obj(struct kref *);
-
-static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = NULL;
-
-        mutex_lock(&idefloppy_ref_mutex);
-        floppy = ide_drv_g(disk, ide_floppy_obj);
-        if (floppy) {
-                if (ide_device_get(floppy->drive))
-                        floppy = NULL;
-                else
-                        kref_get(&floppy->kref);
-        }
-        mutex_unlock(&idefloppy_ref_mutex);
-        return floppy;
-}
-
-static void ide_floppy_put(struct ide_floppy_obj *floppy)
-{
-        ide_drive_t *drive = floppy->drive;
-
-        mutex_lock(&idefloppy_ref_mutex);
-        kref_put(&floppy->kref, idefloppy_cleanup_obj);
-        ide_device_put(drive);
-        mutex_unlock(&idefloppy_ref_mutex);
-}
-
 /*
  * Used to finish servicing a request. For read/write requests, we will call
  * ide_end_request to pass to the next buffer.
  */
-static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
+static int ide_floppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct request *rq = HWGROUP(drive)->rq;
         int error;
 
@@ -161,12 +112,12 @@ static void idefloppy_update_buffers(ide_drive_t *drive,
         struct bio *bio = rq->bio;
 
         while ((bio = rq->bio) != NULL)
-                idefloppy_end_request(drive, 1, 0);
+                ide_floppy_end_request(drive, 1, 0);
 }
 
 static void ide_floppy_callback(ide_drive_t *drive, int dsc)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc *pc = drive->pc;
         int uptodate = pc->error ? 0 : 1;
 
@@ -200,10 +151,10 @@ static void ide_floppy_callback(ide_drive_t *drive, int dsc)
                                "Aborting request!\n");
         }
 
-        idefloppy_end_request(drive, uptodate, 0);
+        ide_floppy_end_request(drive, uptodate, 0);
 }
 
-static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
+static void ide_floppy_report_error(struct ide_disk_obj *floppy,
                                     struct ide_atapi_pc *pc)
 {
         /* supress error messages resulting from Medium not present */
@@ -222,7 +173,7 @@ static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
 static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
                 struct ide_atapi_pc *pc)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
 
         if (floppy->failed_pc == NULL &&
             pc->c[0] != GPCMD_REQUEST_SENSE)
@@ -286,7 +237,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
                                     struct ide_atapi_pc *pc, struct request *rq,
                                     unsigned long sector)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         int block = sector / floppy->bs_factor;
         int blocks = rq->nr_sectors / floppy->bs_factor;
         int cmd = rq_data_dir(rq);
@@ -310,7 +261,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
         pc->flags |= PC_FLAG_DMA_OK;
 }
 
-static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
+static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
                 struct ide_atapi_pc *pc, struct request *rq)
 {
         ide_init_pc(pc);
@@ -329,13 +280,12 @@ static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
         pc->req_xfer = pc->buf_size = rq->data_len;
 }
 
-static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
-                struct request *rq, sector_t block_s)
+static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
+                                             struct request *rq, sector_t block)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
         struct ide_atapi_pc *pc;
-        unsigned long block = (unsigned long)block_s;
 
         ide_debug_log(IDE_DBG_FUNC, "%s: dev: %s, cmd: 0x%x, cmd_type: %x, "
                       "errors: %d\n",
@@ -353,7 +303,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                 else
                         printk(KERN_ERR PFX "%s: I/O error\n", drive->name);
 
-                idefloppy_end_request(drive, 0, 0);
+                ide_floppy_end_request(drive, 0, 0);
                 return ide_stopped;
         }
         if (blk_fs_request(rq)) {
@@ -361,11 +311,11 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                     (rq->nr_sectors % floppy->bs_factor)) {
                         printk(KERN_ERR PFX "%s: unsupported r/w rq size\n",
                                 drive->name);
-                        idefloppy_end_request(drive, 0, 0);
+                        ide_floppy_end_request(drive, 0, 0);
                         return ide_stopped;
                 }
                 pc = &floppy->queued_pc;
-                idefloppy_create_rw_cmd(drive, pc, rq, block);
+                idefloppy_create_rw_cmd(drive, pc, rq, (unsigned long)block);
         } else if (blk_special_request(rq)) {
                 pc = (struct ide_atapi_pc *) rq->buffer;
         } else if (blk_pc_request(rq)) {
@@ -373,7 +323,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                 idefloppy_blockpc_cmd(floppy, pc, rq);
         } else {
                 blk_dump_rq_flags(rq, PFX "unsupported command in queue");
-                idefloppy_end_request(drive, 0, 0);
+                ide_floppy_end_request(drive, 0, 0);
                 return ide_stopped;
         }
 
@@ -394,7 +344,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
  */
 static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         struct ide_atapi_pc pc;
         u8 *page;
@@ -410,11 +360,11 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
         }
 
         if (pc.buf[3] & 0x80)
-                drive->atapi_flags |= IDE_AFLAG_WP;
+                drive->dev_flags |= IDE_DFLAG_WP;
         else
-                drive->atapi_flags &= ~IDE_AFLAG_WP;
+                drive->dev_flags &= ~IDE_DFLAG_WP;
 
-        set_disk_ro(disk, !!(drive->atapi_flags & IDE_AFLAG_WP));
+        set_disk_ro(disk, !!(drive->dev_flags & IDE_DFLAG_WP));
 
         page = &pc.buf[8];
 
@@ -445,7 +395,9 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
                         drive->name, lba_capacity, capacity);
                 floppy->blocks = floppy->block_size ?
                         capacity / floppy->block_size : 0;
+                drive->capacity64 = floppy->blocks * floppy->bs_factor;
         }
+
         return 0;
 }
 
@@ -455,7 +407,7 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
  */
 static int ide_floppy_get_capacity(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         struct ide_atapi_pc pc;
         u8 *cap_desc;
@@ -466,7 +418,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
         drive->bios_head = drive->bios_sect = 0;
         floppy->blocks = 0;
         floppy->bs_factor = 1;
-        set_capacity(floppy->disk, 0);
+        drive->capacity64 = 0;
 
         ide_floppy_create_read_capacity_cmd(&pc);
         if (ide_queue_pc_tail(drive, disk, &pc)) {
@@ -523,6 +475,8 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
                                                "non 512 bytes block size not "
                                                "fully supported\n",
                                                drive->name);
+                                drive->capacity64 =
+                                        floppy->blocks * floppy->bs_factor;
                                 rc = 0;
                         }
                         break;
@@ -547,21 +501,12 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
         if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
                 (void) ide_floppy_get_flexible_disk_page(drive);
 
-        set_capacity(disk, floppy->blocks * floppy->bs_factor);
-
         return rc;
 }
 
-sector_t ide_floppy_capacity(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy = drive->driver_data;
-        unsigned long capacity = floppy->blocks * floppy->bs_factor;
-
-        return capacity;
-}
-
-static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
+static void ide_floppy_setup(ide_drive_t *drive)
 {
+        struct ide_disk_obj *floppy = drive->driver_data;
         u16 *id = drive->id;
 
         drive->pc_callback       = ide_floppy_callback;
@@ -592,252 +537,42 @@ static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
                 blk_queue_max_sectors(drive->queue, 64);
                 drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
                 /* IOMEGA Clik! drives do not support lock/unlock commands */
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
         }
 
         (void) ide_floppy_get_capacity(drive);
 
         ide_proc_register_driver(drive, floppy->driver);
-}
 
-static void ide_floppy_remove(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy = drive->driver_data;
-        struct gendisk *g = floppy->disk;
-
-        ide_proc_unregister_driver(drive, floppy->driver);
-
-        del_gendisk(g);
-
-        ide_floppy_put(floppy);
+        drive->dev_flags |= IDE_DFLAG_ATTACH;
 }
 
-static void idefloppy_cleanup_obj(struct kref *kref)
+static void ide_floppy_flush(ide_drive_t *drive)
 {
-        struct ide_floppy_obj *floppy = to_ide_drv(kref, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-        struct gendisk *g = floppy->disk;
-
-        drive->driver_data = NULL;
-        g->private_data = NULL;
-        put_disk(g);
-        kfree(floppy);
 }
 
-static int ide_floppy_probe(ide_drive_t *);
-
-static ide_driver_t idefloppy_driver = {
-        .gen_driver = {
-                .owner          = THIS_MODULE,
-                .name           = "ide-floppy",
-                .bus            = &ide_bus_type,
-        },
-        .probe                  = ide_floppy_probe,
-        .remove                 = ide_floppy_remove,
-        .version                = IDEFLOPPY_VERSION,
-        .do_request             = idefloppy_do_request,
-        .end_request            = idefloppy_end_request,
-        .error                  = __ide_error,
-#ifdef CONFIG_IDE_PROC_FS
-        .proc                   = ide_floppy_proc,
-        .settings               = ide_floppy_settings,
-#endif
-};
-
-static int idefloppy_open(struct inode *inode, struct file *filp)
+static int ide_floppy_init_media(ide_drive_t *drive, struct gendisk *disk)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_floppy_obj *floppy;
-        ide_drive_t *drive;
         int ret = 0;
 
-        floppy = ide_floppy_get(disk);
-        if (!floppy)
-                return -ENXIO;
-
-        drive = floppy->drive;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        floppy->openers++;
-
-        if (floppy->openers == 1) {
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
-                /* Just in case */
-
-                if (ide_do_test_unit_ready(drive, disk))
-                        ide_do_start_stop(drive, disk, 1);
-
-                if (ide_floppy_get_capacity(drive)
-                   && (filp->f_flags & O_NDELAY) == 0
-                    /*
-                     * Allow O_NDELAY to open a drive without a disk, or with an
-                     * unreadable disk, so that we can get the format capacity
-                     * of the drive or begin the format - Sam
-                     */
-                    ) {
-                        ret = -EIO;
-                        goto out_put_floppy;
-                }
-
-                if ((drive->atapi_flags & IDE_AFLAG_WP) && (filp->f_mode & 2)) {
-                        ret = -EROFS;
-                        goto out_put_floppy;
-                }
-
-                drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
-                ide_set_media_lock(drive, disk, 1);
-                check_disk_change(inode->i_bdev);
-        } else if (drive->atapi_flags & IDE_AFLAG_FORMAT_IN_PROGRESS) {
-                ret = -EBUSY;
-                goto out_put_floppy;
-        }
-        return 0;
-
-out_put_floppy:
-        floppy->openers--;
-        ide_floppy_put(floppy);
-        return ret;
-}
-
-static int idefloppy_release(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        if (floppy->openers == 1) {
-                ide_set_media_lock(drive, disk, 0);
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
-        }
-
-        floppy->openers--;
-
-        ide_floppy_put(floppy);
-
-        return 0;
-}
-
-static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(bdev->bd_disk,
-                                                     ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
+        if (ide_do_test_unit_ready(drive, disk))
+                ide_do_start_stop(drive, disk, 1);
 
-        geo->heads = drive->bios_head;
-        geo->sectors = drive->bios_sect;
-        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
-        return 0;
-}
+        ret = ide_floppy_get_capacity(drive);
 
-static int idefloppy_media_changed(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-        int ret;
+        set_capacity(disk, ide_gd_capacity(drive));
 
-        /* do not scan partitions twice if this is a removable device */
-        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-                return 0;
-        }
-        ret = !!(drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED);
-        drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
         return ret;
 }
 
-static int idefloppy_revalidate_disk(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        set_capacity(disk, ide_floppy_capacity(floppy->drive));
-        return 0;
-}
-
-static struct block_device_operations idefloppy_ops = {
-        .owner                  = THIS_MODULE,
-        .open                   = idefloppy_open,
-        .release                = idefloppy_release,
-        .ioctl                  = ide_floppy_ioctl,
-        .getgeo                 = idefloppy_getgeo,
-        .media_changed          = idefloppy_media_changed,
-        .revalidate_disk        = idefloppy_revalidate_disk
+const struct ide_disk_ops ide_atapi_disk_ops = {
+        .check          = ide_check_atapi_device,
+        .get_capacity   = ide_floppy_get_capacity,
+        .setup          = ide_floppy_setup,
+        .flush          = ide_floppy_flush,
+        .init_media     = ide_floppy_init_media,
+        .set_doorlock   = ide_set_media_lock,
+        .do_request     = ide_floppy_do_request,
+        .end_request    = ide_floppy_end_request,
+        .ioctl          = ide_floppy_ioctl,
 };
-
-static int ide_floppy_probe(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy;
-        struct gendisk *g;
-
-        if (!strstr("ide-floppy", drive->driver_req))
-                goto failed;
-
-        if (drive->media != ide_floppy)
-                goto failed;
-
-        if (!ide_check_atapi_device(drive, DRV_NAME)) {
-                printk(KERN_ERR PFX "%s: not supported by this version of "
-                       DRV_NAME "\n", drive->name);
-                goto failed;
-        }
-        floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
-        if (!floppy) {
-                printk(KERN_ERR PFX "%s: Can't allocate a floppy structure\n",
-                       drive->name);
-                goto failed;
-        }
-
-        g = alloc_disk(1 << PARTN_BITS);
-        if (!g)
-                goto out_free_floppy;
-
-        ide_init_disk(g, drive);
-
-        kref_init(&floppy->kref);
-
-        floppy->drive = drive;
-        floppy->driver = &idefloppy_driver;
-        floppy->disk = g;
-
-        g->private_data = &floppy->driver;
-
-        drive->driver_data = floppy;
-
-        drive->debug_mask = debug_mask;
-
-        idefloppy_setup(drive, floppy);
-        drive->dev_flags |= IDE_DFLAG_ATTACH;
-
-        g->minors = 1 << PARTN_BITS;
-        g->driverfs_dev = &drive->gendev;
-        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
-                g->flags = GENHD_FL_REMOVABLE;
-        g->fops = &idefloppy_ops;
-        add_disk(g);
-        return 0;
-
-out_free_floppy:
-        kfree(floppy);
-failed:
-        return -ENODEV;
-}
-
-static void __exit idefloppy_exit(void)
-{
-        driver_unregister(&idefloppy_driver.gen_driver);
-}
-
-static int __init idefloppy_init(void)
-{
-        printk(KERN_INFO DRV_NAME " driver " IDEFLOPPY_VERSION "\n");
-        return driver_register(&idefloppy_driver.gen_driver);
-}
-
-MODULE_ALIAS("ide:*m-floppy*");
-MODULE_ALIAS("ide-floppy");
-module_init(idefloppy_init);
-module_exit(idefloppy_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
-
diff --git a/drivers/ide/ide-floppy.h b/drivers/ide/ide-floppy.h
index 17cf865e583d..c17124dd6079 100644
--- a/drivers/ide/ide-floppy.h
+++ b/drivers/ide/ide-floppy.h
@@ -1,37 +1,9 @@
 #ifndef __IDE_FLOPPY_H
 #define __IDE_FLOPPY_H
 
-/*
- * 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 a variable of type
- * idefloppy_floppy_t, defined below.
- */
-typedef struct ide_floppy_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
-        unsigned int    openers;        /* protected by BKL for now */
-
-        /* Last failed packet command */
-        struct ide_atapi_pc *failed_pc;
-        /* used for blk_{fs,pc}_request() requests */
-        struct ide_atapi_pc queued_pc;
-
-        /* Last error information */
-        u8 sense_key, asc, ascq;
-
-        int progress_indication;
-
-        /* Device information */
-        /* Current format */
-        int blocks, block_size, bs_factor;
-        /* Last format capacity descriptor */
-        u8 cap_desc[8];
-        /* Copy of the flexible disk page */
-        u8 flexible_disk_page[32];
-} idefloppy_floppy_t;
+#include "ide-gd.h"
 
+#ifdef CONFIG_IDE_GD_ATAPI
 /*
  * Pages of the SELECT SENSE / MODE SENSE packet commands.
  * See SFF-8070i spec.
@@ -46,17 +18,22 @@ typedef struct ide_floppy_obj {
 #define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS     0x4603
 
 /* ide-floppy.c */
+extern const struct ide_disk_ops ide_atapi_disk_ops;
 void ide_floppy_create_mode_sense_cmd(struct ide_atapi_pc *, u8);
 void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *);
-sector_t ide_floppy_capacity(ide_drive_t *);
 
 /* ide-floppy_ioctl.c */
-int ide_floppy_ioctl(struct inode *, struct file *, unsigned, unsigned long);
+int ide_floppy_ioctl(ide_drive_t *, struct inode *, struct file *, unsigned int,
+                     unsigned long);
 
 #ifdef CONFIG_IDE_PROC_FS
 /* ide-floppy_proc.c */
 extern ide_proc_entry_t ide_floppy_proc[];
 extern const struct ide_proc_devset ide_floppy_settings[];
 #endif
+#else
+#define ide_floppy_proc         NULL
+#define ide_floppy_settings     NULL
+#endif
 
 #endif /*__IDE_FLOPPY_H */
diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.c
index a3a7a0809e2b..409e4c15f9b7 100644
--- a/drivers/ide/ide-floppy_ioctl.c
+++ b/drivers/ide/ide-floppy_ioctl.c
@@ -33,7 +33,7 @@
 
 static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
 {
-        struct ide_floppy_obj *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         u8 header_len, desc_cnt;
         int i, blocks, length, u_array_size, u_index;
@@ -113,7 +113,7 @@ static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
 
 static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
 
         drive->atapi_flags &= ~IDE_AFLAG_SRFP;
@@ -132,17 +132,17 @@ static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)
 
 static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         int blocks, length, flags, err = 0;
 
         if (floppy->openers > 1) {
                 /* Don't format if someone is using the disk */
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
                 return -EBUSY;
         }
 
-        drive->atapi_flags |= IDE_AFLAG_FORMAT_IN_PROGRESS;
+        drive->dev_flags |= IDE_DFLAG_FORMAT_IN_PROGRESS;
 
         /*
          * Send ATAPI_FORMAT_UNIT to the drive.
@@ -174,7 +174,7 @@ static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
 
 out:
         if (err)
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
         return err;
 }
 
@@ -190,7 +190,7 @@ out:
 
 static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         int progress_indication = 0x10000;
 
@@ -226,7 +226,7 @@ static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
 static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
                                unsigned long arg, unsigned int cmd)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         int prevent = (arg && cmd != CDROMEJECT) ? 1 : 0;
 
@@ -260,13 +260,10 @@ static int ide_floppy_format_ioctl(ide_drive_t *drive, struct file *file,
         }
 }
 
-int ide_floppy_ioctl(struct inode *inode, struct file *file,
-                    unsigned int cmd, unsigned long arg)
+int ide_floppy_ioctl(ide_drive_t *drive, struct inode *inode,
+                     struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
-        struct ide_floppy_obj *floppy = ide_drv_g(bdev->bd_disk,
-                                                     ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
         struct ide_atapi_pc pc;
         void __user *argp = (void __user *)arg;
         int err;
diff --git a/drivers/ide/ide-floppy_proc.c b/drivers/ide/ide-floppy_proc.c
index 76f0c6c4eca3..3ec762cb60ab 100644
--- a/drivers/ide/ide-floppy_proc.c
+++ b/drivers/ide/ide-floppy_proc.c
@@ -9,7 +9,7 @@ static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
         ide_drive_t*drive = (ide_drive_t *)data;
         int len;
 
-        len = sprintf(page, "%llu\n", (long long)ide_floppy_capacity(drive));
+        len = sprintf(page, "%llu\n", (long long)ide_gd_capacity(drive));
         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
new file mode 100644
index 000000000000..d44898f46c33
--- /dev/null
+++ b/drivers/ide/ide-gd.c
@@ -0,0 +1,398 @@
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/genhd.h>
+#include <linux/mutex.h>
+#include <linux/ide.h>
+#include <linux/hdreg.h>
+
+#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
+#define IDE_DISK_MINORS         (1 << PARTN_BITS)
+#else
+#define IDE_DISK_MINORS         0
+#endif
+
+#include "ide-disk.h"
+#include "ide-floppy.h"
+
+#define IDE_GD_VERSION  "1.18"
+
+/* module parameters */
+static unsigned long debug_mask;
+module_param(debug_mask, ulong, 0644);
+
+static DEFINE_MUTEX(ide_disk_ref_mutex);
+
+static void ide_disk_release(struct kref *);
+
+static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = NULL;
+
+        mutex_lock(&ide_disk_ref_mutex);
+        idkp = ide_drv_g(disk, ide_disk_obj);
+        if (idkp) {
+                if (ide_device_get(idkp->drive))
+                        idkp = NULL;
+                else
+                        kref_get(&idkp->kref);
+        }
+        mutex_unlock(&ide_disk_ref_mutex);
+        return idkp;
+}
+
+static void ide_disk_put(struct ide_disk_obj *idkp)
+{
+        ide_drive_t *drive = idkp->drive;
+
+        mutex_lock(&ide_disk_ref_mutex);
+        kref_put(&idkp->kref, ide_disk_release);
+        ide_device_put(drive);
+        mutex_unlock(&ide_disk_ref_mutex);
+}
+
+sector_t ide_gd_capacity(ide_drive_t *drive)
+{
+        return drive->capacity64;
+}
+
+static int ide_gd_probe(ide_drive_t *);
+
+static void ide_gd_remove(ide_drive_t *drive)
+{
+        struct ide_disk_obj *idkp = drive->driver_data;
+        struct gendisk *g = idkp->disk;
+
+        ide_proc_unregister_driver(drive, idkp->driver);
+
+        del_gendisk(g);
+
+        drive->disk_ops->flush(drive);
+
+        ide_disk_put(idkp);
+}
+
+static void ide_disk_release(struct kref *kref)
+{
+        struct ide_disk_obj *idkp = to_ide_drv(kref, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+        struct gendisk *g = idkp->disk;
+
+        drive->disk_ops = NULL;
+        drive->driver_data = NULL;
+        g->private_data = NULL;
+        put_disk(g);
+        kfree(idkp);
+}
+
+/*
+ * On HPA drives the capacity needs to be
+ * reinitilized on resume otherwise the disk
+ * can not be used and a hard reset is required
+ */
+static void ide_gd_resume(ide_drive_t *drive)
+{
+        if (ata_id_hpa_enabled(drive->id))
+                (void)drive->disk_ops->get_capacity(drive);
+}
+
+static void ide_gd_shutdown(ide_drive_t *drive)
+{
+#ifdef  CONFIG_ALPHA
+        /* On Alpha, halt(8) doesn't actually turn the machine off,
+           it puts you into the sort of firmware monitor. Typically,
+           it's used to boot another kernel image, so it's not much
+           different from reboot(8). Therefore, we don't need to
+           spin down the disk in this case, especially since Alpha
+           firmware doesn't handle disks in standby mode properly.
+           On the other hand, it's reasonably safe to turn the power
+           off when the shutdown process reaches the firmware prompt,
+           as the firmware initialization takes rather long time -
+           at least 10 seconds, which should be sufficient for
+           the disk to expire its write cache. */
+        if (system_state != SYSTEM_POWER_OFF) {
+#else
+        if (system_state == SYSTEM_RESTART) {
+#endif
+                drive->disk_ops->flush(drive);
+                return;
+        }
+
+        printk(KERN_INFO "Shutdown: %s\n", drive->name);
+
+        drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
+}
+
+#ifdef CONFIG_IDE_PROC_FS
+static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
+{
+        return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
+}
+
+static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
+{
+        return (drive->media == ide_disk) ? ide_disk_settings
+                                          : ide_floppy_settings;
+}
+#endif
+
+static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
+                                         struct request *rq, sector_t sector)
+{
+        return drive->disk_ops->do_request(drive, rq, sector);
+}
+
+static int ide_gd_end_request(ide_drive_t *drive, int uptodate, int nrsecs)
+{
+        return drive->disk_ops->end_request(drive, uptodate, nrsecs);
+}
+
+static ide_driver_t ide_gd_driver = {
+        .gen_driver = {
+                .owner          = THIS_MODULE,
+                .name           = "ide-gd",
+                .bus            = &ide_bus_type,
+        },
+        .probe                  = ide_gd_probe,
+        .remove                 = ide_gd_remove,
+        .resume                 = ide_gd_resume,
+        .shutdown               = ide_gd_shutdown,
+        .version                = IDE_GD_VERSION,
+        .do_request             = ide_gd_do_request,
+        .end_request            = ide_gd_end_request,
+        .error                  = __ide_error,
+#ifdef CONFIG_IDE_PROC_FS
+        .proc_entries           = ide_disk_proc_entries,
+        .proc_devsets           = ide_disk_proc_devsets,
+#endif
+};
+
+static int ide_gd_open(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ide_disk_obj *idkp;
+        ide_drive_t *drive;
+        int ret = 0;
+
+        idkp = ide_disk_get(disk);
+        if (idkp == NULL)
+                return -ENXIO;
+
+        drive = idkp->drive;
+
+        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+
+        idkp->openers++;
+
+        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
+                /* Just in case */
+
+                ret = drive->disk_ops->init_media(drive, disk);
+
+                /*
+                 * Allow O_NDELAY to open a drive without a disk, or with an
+                 * unreadable disk, so that we can get the format capacity
+                 * of the drive or begin the format - Sam
+                 */
+                if (ret && (filp->f_flags & O_NDELAY) == 0) {
+                        ret = -EIO;
+                        goto out_put_idkp;
+                }
+
+                if ((drive->dev_flags & IDE_DFLAG_WP) && (filp->f_mode & 2)) {
+                        ret = -EROFS;
+                        goto out_put_idkp;
+                }
+
+                /*
+                 * Ignore the return code from door_lock,
+                 * since the open() has already succeeded,
+                 * and the door_lock is irrelevant at this point.
+                 */
+                drive->disk_ops->set_doorlock(drive, disk, 1);
+                drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
+                check_disk_change(inode->i_bdev);
+        } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
+                ret = -EBUSY;
+                goto out_put_idkp;
+        }
+        return 0;
+
+out_put_idkp:
+        idkp->openers--;
+        ide_disk_put(idkp);
+        return ret;
+}
+
+static int ide_gd_release(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+
+        if (idkp->openers == 1)
+                drive->disk_ops->flush(drive);
+
+        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
+                drive->disk_ops->set_doorlock(drive, disk, 0);
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
+        }
+
+        idkp->openers--;
+
+        ide_disk_put(idkp);
+
+        return 0;
+}
+
+static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        geo->heads = drive->bios_head;
+        geo->sectors = drive->bios_sect;
+        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
+        return 0;
+}
+
+static int ide_gd_media_changed(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+        int ret;
+
+        /* do not scan partitions twice if this is a removable device */
+        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
+                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
+                return 0;
+        }
+
+        ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
+        drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
+
+        return ret;
+}
+
+static int ide_gd_revalidate_disk(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        set_capacity(disk, ide_gd_capacity(idkp->drive));
+        return 0;
+}
+
+static int ide_gd_ioctl(struct inode *inode, struct file *file,
+                             unsigned int cmd, unsigned long arg)
+{
+        struct block_device *bdev = inode->i_bdev;
+        struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        return drive->disk_ops->ioctl(drive, inode, file, cmd, arg);
+}
+
+static struct block_device_operations ide_gd_ops = {
+        .owner                  = THIS_MODULE,
+        .open                   = ide_gd_open,
+        .release                = ide_gd_release,
+        .ioctl                  = ide_gd_ioctl,
+        .getgeo                 = ide_gd_getgeo,
+        .media_changed          = ide_gd_media_changed,
+        .revalidate_disk        = ide_gd_revalidate_disk
+};
+
+static int ide_gd_probe(ide_drive_t *drive)
+{
+        const struct ide_disk_ops *disk_ops = NULL;
+        struct ide_disk_obj *idkp;
+        struct gendisk *g;
+
+        /* strstr("foo", "") is non-NULL */
+        if (!strstr("ide-gd", drive->driver_req))
+                goto failed;
+
+#ifdef CONFIG_IDE_GD_ATA
+        if (drive->media == ide_disk)
+                disk_ops = &ide_ata_disk_ops;
+#endif
+#ifdef CONFIG_IDE_GD_ATAPI
+        if (drive->media == ide_floppy)
+                disk_ops = &ide_atapi_disk_ops;
+#endif
+        if (disk_ops == NULL)
+                goto failed;
+
+        if (disk_ops->check(drive, DRV_NAME) == 0) {
+                printk(KERN_ERR PFX "%s: not supported by this driver\n",
+                        drive->name);
+                goto failed;
+        }
+
+        idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
+        if (!idkp) {
+                printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
+                        drive->name);
+                goto failed;
+        }
+
+        g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
+        if (!g)
+                goto out_free_idkp;
+
+        ide_init_disk(g, drive);
+
+        kref_init(&idkp->kref);
+
+        idkp->drive = drive;
+        idkp->driver = &ide_gd_driver;
+        idkp->disk = g;
+
+        g->private_data = &idkp->driver;
+
+        drive->driver_data = idkp;
+        drive->debug_mask = debug_mask;
+        drive->disk_ops = disk_ops;
+
+        disk_ops->setup(drive);
+
+        set_capacity(g, ide_gd_capacity(drive));
+
+        g->minors = IDE_DISK_MINORS;
+        g->driverfs_dev = &drive->gendev;
+        g->flags |= GENHD_FL_EXT_DEVT;
+        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
+                g->flags = GENHD_FL_REMOVABLE;
+        g->fops = &ide_gd_ops;
+        add_disk(g);
+        return 0;
+
+out_free_idkp:
+        kfree(idkp);
+failed:
+        return -ENODEV;
+}
+
+static int __init ide_gd_init(void)
+{
+        printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
+        return driver_register(&ide_gd_driver.gen_driver);
+}
+
+static void __exit ide_gd_exit(void)
+{
+        driver_unregister(&ide_gd_driver.gen_driver);
+}
+
+MODULE_ALIAS("ide:*m-disk*");
+MODULE_ALIAS("ide-disk");
+MODULE_ALIAS("ide:*m-floppy*");
+MODULE_ALIAS("ide-floppy");
+module_init(ide_gd_init);
+module_exit(ide_gd_exit);
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");
diff --git a/drivers/ide/ide-gd.h b/drivers/ide/ide-gd.h
new file mode 100644
index 000000000000..7d3d101713e0
--- /dev/null
+++ b/drivers/ide/ide-gd.h
@@ -0,0 +1,44 @@
+#ifndef __IDE_GD_H
+#define __IDE_GD_H
+
+#define DRV_NAME "ide-gd"
+#define PFX DRV_NAME ": "
+
+/* define to see debug info */
+#define IDE_GD_DEBUG_LOG        0
+
+#if IDE_GD_DEBUG_LOG
+#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
+#else
+#define ide_debug_log(lvl, fmt, args...) do {} while (0)
+#endif
+
+struct ide_disk_obj {
+        ide_drive_t     *drive;
+        ide_driver_t    *driver;
+        struct gendisk  *disk;
+        struct kref     kref;
+        unsigned int    openers;        /* protected by BKL for now */
+
+        /* Last failed packet command */
+        struct ide_atapi_pc *failed_pc;
+        /* used for blk_{fs,pc}_request() requests */
+        struct ide_atapi_pc queued_pc;
+
+        /* Last error information */
+        u8 sense_key, asc, ascq;
+
+        int progress_indication;
+
+        /* Device information */
+        /* Current format */
+        int blocks, block_size, bs_factor;
+        /* Last format capacity descriptor */
+        u8 cap_desc[8];
+        /* Copy of the flexible disk page */
+        u8 flexible_disk_page[32];
+};
+
+sector_t ide_gd_capacity(ide_drive_t *);
+
+#endif /* __IDE_GD_H */
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index b762deb2dacb..bb7a1ed8094e 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -755,7 +755,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
          
         udelay(1);
         SELECT_DRIVE(drive);
-        SELECT_MASK(drive, 0);
+        SELECT_MASK(drive, 1);
         udelay(1);
         tp_ops->set_irq(hwif, 0);
 
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 19f8c7770a25..1649ea54f76c 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -208,6 +208,7 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
                 drive->ready_stat = 0;
                 if (ata_id_cdb_intr(id))
                         drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
+                drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
                 /* we don't do head unloading on ATAPI devices */
                 drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
                 return;
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index b26926487cc0..c31d0dd7a532 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -567,10 +567,10 @@ static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t
 void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
         mutex_lock(&ide_setting_mtx);
-        drive->settings = driver->settings;
+        drive->settings = driver->proc_devsets(drive);
         mutex_unlock(&ide_setting_mtx);
 
-        ide_add_proc_entries(drive->proc, driver->proc, drive);
+        ide_add_proc_entries(drive->proc, driver->proc_entries(drive), drive);
 }
 
 EXPORT_SYMBOL(ide_proc_register_driver);
@@ -591,7 +591,7 @@ void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
         unsigned long flags;
 
-        ide_remove_proc_entries(drive->proc, driver->proc);
+        ide_remove_proc_entries(drive->proc, driver->proc_entries(drive));
 
         mutex_lock(&ide_setting_mtx);
         spin_lock_irqsave(&ide_lock, flags);
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index d879c7797cde..b2b2e5e8d38e 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -2108,7 +2108,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive)
 
         /* device lacks locking support according to capabilities page */
         if ((caps[6] & 1) == 0)
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
 
         if (caps[7] & 0x02)
                 tape->blk_size = 512;
@@ -2298,6 +2298,16 @@ static ide_proc_entry_t idetape_proc[] = {
         { "name",       S_IFREG|S_IRUGO,        proc_idetape_read_name, NULL },
         { NULL, 0, NULL, NULL }
 };
+
+static ide_proc_entry_t *ide_tape_proc_entries(ide_drive_t *drive)
+{
+        return idetape_proc;
+}
+
+static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
+{
+        return idetape_settings;
+}
 #endif
 
 static int ide_tape_probe(ide_drive_t *);
@@ -2315,8 +2325,8 @@ static ide_driver_t idetape_driver = {
         .end_request            = idetape_end_request,
         .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idetape_proc,
-        .settings               = idetape_settings,
+        .proc_entries           = ide_tape_proc_entries,
+        .proc_devsets           = ide_tape_proc_devsets,
 #endif
 };
 
diff --git a/drivers/ide/pci/Makefile b/drivers/ide/pci/Makefile
index 02e6ee7d751d..ab44a1f5f5a9 100644
--- a/drivers/ide/pci/Makefile
+++ b/drivers/ide/pci/Makefile
@@ -11,7 +11,6 @@ obj-$(CONFIG_BLK_DEV_CS5535)		+= cs5535.o
 obj-$(CONFIG_BLK_DEV_SC1200)            += sc1200.o
 obj-$(CONFIG_BLK_DEV_CY82C693)          += cy82c693.o
 obj-$(CONFIG_BLK_DEV_DELKIN)            += delkin_cb.o
-obj-$(CONFIG_BLK_DEV_HPT34X)            += hpt34x.o
 obj-$(CONFIG_BLK_DEV_HPT366)            += hpt366.o
 obj-$(CONFIG_BLK_DEV_IT8213)            += it8213.o
 obj-$(CONFIG_BLK_DEV_IT821X)            += it821x.o
diff --git a/drivers/ide/pci/delkin_cb.c b/drivers/ide/pci/delkin_cb.c
index 8689a706f537..8f1b2d9f0513 100644
--- a/drivers/ide/pci/delkin_cb.c
+++ b/drivers/ide/pci/delkin_cb.c
@@ -46,10 +46,27 @@ static const struct ide_port_ops delkin_cb_port_ops = {
         .quirkproc              = ide_undecoded_slave,
 };
 
+static unsigned int delkin_cb_init_chipset(struct pci_dev *dev)
+{
+        unsigned long base = pci_resource_start(dev, 0);
+        int i;
+
+        outb(0x02, base + 0x1e);        /* set nIEN to block interrupts */
+        inb(base + 0x17);               /* read status to clear interrupts */
+
+        for (i = 0; i < sizeof(setup); ++i) {
+                if (setup[i])
+                        outb(setup[i], base + i);
+        }
+
+        return 0;
+}
+
 static const struct ide_port_info delkin_cb_port_info = {
         .port_ops               = &delkin_cb_port_ops,
         .host_flags             = IDE_HFLAG_IO_32BIT | IDE_HFLAG_UNMASK_IRQS |
                                   IDE_HFLAG_NO_DMA,
+        .init_chipset           = delkin_cb_init_chipset,
 };
 
 static int __devinit
@@ -57,7 +74,7 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
 {
         struct ide_host *host;
         unsigned long base;
-        int i, rc;
+        int rc;
         hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
 
         rc = pci_enable_device(dev);
@@ -72,12 +89,8 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
                 return rc;
         }
         base = pci_resource_start(dev, 0);
-        outb(0x02, base + 0x1e);        /* set nIEN to block interrupts */
-        inb(base + 0x17);               /* read status to clear interrupts */
-        for (i = 0; i < sizeof(setup); ++i) {
-                if (setup[i])
-                        outb(setup[i], base + i);
-        }
+
+        delkin_cb_init_chipset(dev);
 
         memset(&hw, 0, sizeof(hw));
         ide_std_init_ports(&hw, base + 0x10, base + 0x1e);
@@ -110,6 +123,40 @@ delkin_cb_remove (struct pci_dev *dev)
         pci_disable_device(dev);
 }
 
+#ifdef CONFIG_PM
+static int delkin_cb_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        pci_save_state(dev);
+        pci_disable_device(dev);
+        pci_set_power_state(dev, pci_choose_state(dev, state));
+
+        return 0;
+}
+
+static int delkin_cb_resume(struct pci_dev *dev)
+{
+        struct ide_host *host = pci_get_drvdata(dev);
+        int rc;
+
+        pci_set_power_state(dev, PCI_D0);
+
+        rc = pci_enable_device(dev);
+        if (rc)
+                return rc;
+
+        pci_restore_state(dev);
+        pci_set_master(dev);
+
+        if (host->init_chipset)
+                host->init_chipset(dev);
+
+        return 0;
+}
+#else
+#define delkin_cb_suspend NULL
+#define delkin_cb_resume NULL
+#endif
+
 static struct pci_device_id delkin_cb_pci_tbl[] __devinitdata = {
         { 0x1145, 0xf021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { 0x1145, 0xf024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
@@ -122,6 +169,8 @@ static struct pci_driver delkin_cb_pci_driver = {
         .id_table       = delkin_cb_pci_tbl,
         .probe          = delkin_cb_probe,
         .remove         = delkin_cb_remove,
+        .suspend        = delkin_cb_suspend,
+        .resume         = delkin_cb_resume,
 };
 
 static int __init delkin_cb_init(void)
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
deleted file mode 100644
index fb1a3aa57f07..000000000000
--- a/drivers/ide/pci/hpt34x.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (C) 1998-2000      Andre Hedrick <andre@linux-ide.org>
- *
- * May be copied or modified under the terms of the GNU General Public License
- *
- *
- * 00:12.0 Unknown mass storage controller:
- * Triones Technologies, Inc.
- * Unknown device 0003 (rev 01)
- *
- * hde: UDMA 2 (0x0000 0x0002) (0x0000 0x0010)
- * hdf: UDMA 2 (0x0002 0x0012) (0x0010 0x0030)
- * hde: DMA 2  (0x0000 0x0002) (0x0000 0x0010)
- * hdf: DMA 2  (0x0002 0x0012) (0x0010 0x0030)
- * hdg: DMA 1  (0x0012 0x0052) (0x0030 0x0070)
- * hdh: DMA 1  (0x0052 0x0252) (0x0070 0x00f0)
- *
- * ide-pci.c reference
- *
- * Since there are two cards that report almost identically,
- * the only discernable difference is the values reported in pcicmd.
- * Booting-BIOS card or HPT363 :: pcicmd == 0x07
- * Non-bootable card or HPT343 :: pcicmd == 0x05
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/ioport.h>
-#include <linux/interrupt.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/ide.h>
-
-#define DRV_NAME "hpt34x"
-
-#define HPT343_DEBUG_DRIVE_INFO         0
-
-static void hpt34x_set_mode(ide_drive_t *drive, const u8 speed)
-{
-        struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
-        u32 reg1= 0, tmp1 = 0, reg2 = 0, tmp2 = 0;
-        u8                      hi_speed, lo_speed;
-
-        hi_speed = speed >> 4;
-        lo_speed = speed & 0x0f;
-
-        if (hi_speed & 7) {
-                hi_speed = (hi_speed & 4) ? 0x01 : 0x10;
-        } else {
-                lo_speed <<= 5;
-                lo_speed >>= 5;
-        }
-
-        pci_read_config_dword(dev, 0x44, &reg1);
-        pci_read_config_dword(dev, 0x48, &reg2);
-        tmp1 = ((lo_speed << (3*drive->dn)) | (reg1 & ~(7 << (3*drive->dn))));
-        tmp2 = ((hi_speed << drive->dn) | (reg2 & ~(0x11 << drive->dn)));
-        pci_write_config_dword(dev, 0x44, tmp1);
-        pci_write_config_dword(dev, 0x48, tmp2);
-
-#if HPT343_DEBUG_DRIVE_INFO
-        printk("%s: %s drive%d (0x%04x 0x%04x) (0x%04x 0x%04x)" \
-                " (0x%02x 0x%02x)\n",
-                drive->name, ide_xfer_verbose(speed),
-                drive->dn, reg1, tmp1, reg2, tmp2,
-                hi_speed, lo_speed);
-#endif /* HPT343_DEBUG_DRIVE_INFO */
-}
-
-static void hpt34x_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        hpt34x_set_mode(drive, XFER_PIO_0 + pio);
-}
-
-/*
- * If the BIOS does not set the IO base addaress to XX00, 343 will fail.
- */
-#define HPT34X_PCI_INIT_REG             0x80
-
-static unsigned int init_chipset_hpt34x(struct pci_dev *dev)
-{
-        int i = 0;
-        unsigned long hpt34xIoBase = pci_resource_start(dev, 4);
-        unsigned long hpt_addr[4] = { 0x20, 0x34, 0x28, 0x3c };
-        unsigned long hpt_addr_len[4] = { 7, 3, 7, 3 };
-        u16 cmd;
-        unsigned long flags;
-
-        local_irq_save(flags);
-
-        pci_write_config_byte(dev, HPT34X_PCI_INIT_REG, 0x00);
-        pci_read_config_word(dev, PCI_COMMAND, &cmd);
-
-        if (cmd & PCI_COMMAND_MEMORY)
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF0);
-        else
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
-
-        /*
-         * Since 20-23 can be assigned and are R/W, we correct them.
-         */
-        pci_write_config_word(dev, PCI_COMMAND, cmd & ~PCI_COMMAND_IO);
-        for(i=0; i<4; i++) {
-                dev->resource[i].start = (hpt34xIoBase + hpt_addr[i]);
-                dev->resource[i].end = dev->resource[i].start + hpt_addr_len[i];
-                dev->resource[i].flags = IORESOURCE_IO;
-                pci_write_config_dword(dev,
-                                (PCI_BASE_ADDRESS_0 + (i * 4)),
-                                dev->resource[i].start);
-        }
-        pci_write_config_word(dev, PCI_COMMAND, cmd);
-
-        local_irq_restore(flags);
-
-        return dev->irq;
-}
-
-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 | \
-         IDE_HFLAG_NO_DSC | \
-         IDE_HFLAG_NO_AUTODMA)
-
-static const struct ide_port_info hpt34x_chipsets[] __devinitdata = {
-        { /* 0: HPT343 */
-                .name           = DRV_NAME,
-                .init_chipset   = init_chipset_hpt34x,
-                .port_ops       = &hpt34x_port_ops,
-                .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_NON_BOOTABLE,
-                .pio_mask       = ATA_PIO5,
-        },
-        { /* 1: HPT345 */
-                .name           = DRV_NAME,
-                .init_chipset   = init_chipset_hpt34x,
-                .port_ops       = &hpt34x_port_ops,
-                .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_OFF_BOARD,
-                .pio_mask       = ATA_PIO5,
-#ifdef CONFIG_HPT34X_AUTODMA
-                .swdma_mask     = ATA_SWDMA2,
-                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA2,
-#endif
-        }
-};
-
-static int __devinit hpt34x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
-{
-        const struct ide_port_info *d;
-        u16 pcicmd = 0;
-
-        pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
-
-        d = &hpt34x_chipsets[(pcicmd & PCI_COMMAND_MEMORY) ? 1 : 0];
-
-        return ide_pci_init_one(dev, d, NULL);
-}
-
-static const struct pci_device_id hpt34x_pci_tbl[] = {
-        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT343), 0 },
-        { 0, },
-};
-MODULE_DEVICE_TABLE(pci, hpt34x_pci_tbl);
-
-static struct pci_driver hpt34x_pci_driver = {
-        .name           = "HPT34x_IDE",
-        .id_table       = hpt34x_pci_tbl,
-        .probe          = hpt34x_init_one,
-        .remove         = ide_pci_remove,
-        .suspend        = ide_pci_suspend,
-        .resume         = ide_pci_resume,
-};
-
-static int __init hpt34x_ide_init(void)
-{
-        return ide_pci_register_driver(&hpt34x_pci_driver);
-}
-
-static void __exit hpt34x_ide_exit(void)
-{
-        pci_unregister_driver(&hpt34x_pci_driver);
-}
-
-module_init(hpt34x_ide_init);
-module_exit(hpt34x_ide_exit);
-
-MODULE_AUTHOR("Andre Hedrick");
-MODULE_DESCRIPTION("PCI driver module for Highpoint 34x IDE");
-MODULE_LICENSE("GPL");
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 9cf171cb9376..a7909e9c720e 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -3,7 +3,7 @@
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
  * Portions Copyright (C) 2003          Red Hat Inc
  * Portions Copyright (C) 2007          Bartlomiej Zolnierkiewicz
- * Portions Copyright (C) 2005-2007     MontaVista Software, Inc.
+ * Portions Copyright (C) 2005-2008     MontaVista Software, Inc.
  *
  * Thanks to HighPoint Technologies for their assistance, and hardware.
  * Special Thanks to Jon Burchmore in SanDiego for the deep pockets, his
@@ -748,26 +748,24 @@ static void hpt3xx_maskproc(ide_drive_t *drive, int mask)
         struct pci_dev  *dev    = to_pci_dev(hwif->dev);
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
 
-        if (drive->quirk_list) {
-                if (info->chip_type >= HPT370) {
-                        u8 scr1 = 0;
-
-                        pci_read_config_byte(dev, 0x5a, &scr1);
-                        if (((scr1 & 0x10) >> 4) != mask) {
-                                if (mask)
-                                        scr1 |=  0x10;
-                                else
-                                        scr1 &= ~0x10;
-                                pci_write_config_byte(dev, 0x5a, scr1);
-                        }
-                } else {
+        if (drive->quirk_list == 0)
+                return;
+
+        if (info->chip_type >= HPT370) {
+                u8 scr1 = 0;
+
+                pci_read_config_byte(dev, 0x5a, &scr1);
+                if (((scr1 & 0x10) >> 4) != mask) {
                         if (mask)
-                                disable_irq(hwif->irq);
+                                scr1 |=  0x10;
                         else
-                                enable_irq (hwif->irq);
+                                scr1 &= ~0x10;
+                        pci_write_config_byte(dev, 0x5a, scr1);
                 }
-        } else
-                outb(ATA_DEVCTL_OBS | (mask ? 2 : 0), hwif->io_ports.ctl_addr);
+        } else if (mask)
+                disable_irq(hwif->irq);
+        else
+                enable_irq(hwif->irq);
 }
 
 /*
@@ -1289,7 +1287,6 @@ static u8 hpt3xx_cable_detect(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
 {
-        struct pci_dev *dev     = to_pci_dev(hwif->dev);
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
         int serialize           = HPT_SERIALIZE_IO;
         u8  chip_type           = info->chip_type;
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index 9ce1d8059921..49f163aa51e3 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -617,7 +617,6 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
         unsigned long intmask_port;
         unsigned long mode_port;
         unsigned long ecmode_port;
-        unsigned long dma_status_port;
         u32 reg = 0;
         struct scc_ports *ports;
         int rc;
@@ -637,7 +636,6 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
         intmask_port = dma_base + 0x010;
         mode_port = ctl_base + 0x024;
         ecmode_port = ctl_base + 0xf00;
-        dma_status_port = dma_base + 0x004;
 
         /* controller initialization */
         reg = 0;
@@ -843,8 +841,6 @@ static u8 scc_cable_detect(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_scc(ide_hwif_t *hwif)
 {
-        struct scc_ports *ports = ide_get_hwifdata(hwif);
-
         /* PTERADD */
         out_be32((void __iomem *)(hwif->dma_base + 0x018), hwif->dmatable_dma);
 
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index dd634541ce36..8af9b23499fd 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -101,18 +101,8 @@ sgiioc4_init_hwif_ports(hw_regs_t * hw, unsigned long data_port,
         for (i = 0; i <= 7; i++)
                 hw->io_ports_array[i] = reg + i * 4;
 
-        if (ctrl_port)
-                hw->io_ports.ctl_addr = ctrl_port;
-
-        if (irq_port)
-                hw->io_ports.irq_addr = irq_port;
-}
-
-static void
-sgiioc4_maskproc(ide_drive_t * drive, int mask)
-{
-        writeb(ATA_DEVCTL_OBS | (mask ? 2 : 0),
-               (void __iomem *)drive->hwif->io_ports.ctl_addr);
+        hw->io_ports.ctl_addr = ctrl_port;
+        hw->io_ports.irq_addr = irq_port;
 }
 
 static int
@@ -310,16 +300,14 @@ static u8 sgiioc4_read_status(ide_hwif_t *hwif)
         unsigned long port = hwif->io_ports.status_addr;
         u8 reg = (u8) readb((void __iomem *) port);
 
-        if ((port & 0xFFF) == 0x11C) {  /* Status register of IOC4 */
-                if (!(reg & ATA_BUSY)) { /* Not busy... check for interrupt */
-                        unsigned long other_ir = port - 0x110;
-                        unsigned int intr_reg = (u32) readl((void __iomem *) other_ir);
+        if (!(reg & ATA_BUSY)) {        /* Not busy... check for interrupt */
+                unsigned long other_ir = port - 0x110;
+                unsigned int intr_reg = (u32) readl((void __iomem *) other_ir);
 
-                        /* Clear the Interrupt, Error bits on the IOC4 */
-                        if (intr_reg & 0x03) {
-                                writel(0x03, (void __iomem *) other_ir);
-                                intr_reg = (u32) readl((void __iomem *) other_ir);
-                        }
+                /* Clear the Interrupt, Error bits on the IOC4 */
+                if (intr_reg & 0x03) {
+                        writel(0x03, (void __iomem *) other_ir);
+                        intr_reg = (u32) readl((void __iomem *) other_ir);
                 }
         }
 
@@ -332,13 +320,9 @@ 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: MMIO-DMA\n", hwif->name);
 
         if (request_mem_region(dma_base, num_ports, hwif->name) == NULL) {
@@ -348,14 +332,8 @@ ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
                 return -1;
         }
 
-        virt_dma_base = ioremap(dma_base, num_ports);
-        if (virt_dma_base == NULL) {
-                printk(KERN_ERR "%s(%s) -- ERROR: unable to map addresses "
-                       "0x%lx to 0x%lx\n", __func__, hwif->name,
-                       dma_base, dma_base + num_ports - 1);
-                goto dma_remap_failure;
-        }
-        hwif->dma_base = (unsigned long) virt_dma_base;
+        hwif->dma_base = (unsigned long)hwif->io_ports.irq_addr +
+                         IOC4_DMA_OFFSET;
 
         hwif->sg_max_nents = IOC4_PRD_ENTRIES;
 
@@ -379,9 +357,6 @@ ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
         printk(KERN_INFO "%s: changing from DMA to PIO mode", hwif->name);
 
 dma_pci_alloc_failure:
-        iounmap(virt_dma_base);
-
-dma_remap_failure:
         release_mem_region(dma_base, num_ports);
 
         return -1;
@@ -563,8 +538,6 @@ 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,
 };
 
 static const struct ide_dma_ops sgiioc4_dma_ops = {
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index e3e40427e00e..c7ff1e11ea85 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -179,7 +179,7 @@ config LEDS_TRIGGER_TIMER
 
 config LEDS_TRIGGER_IDE_DISK
         bool "LED IDE Disk Trigger"
-        depends on LEDS_TRIGGERS && BLK_DEV_IDEDISK
+        depends on LEDS_TRIGGERS && IDE_GD_ATA
         help
           This allows LEDs to be controlled by IDE disk activity.
           If unsure, say Y.
diff --git a/drivers/mfd/asic3.c b/drivers/mfd/asic3.c
index ba5aa2008273..e4c0db4dc7b1 100644
--- a/drivers/mfd/asic3.c
+++ b/drivers/mfd/asic3.c
@@ -123,7 +123,7 @@ static void asic3_irq_demux(unsigned int irq, struct irq_desc *desc)
                                         irqnr = asic->irq_base +
                                                 (ASIC3_GPIOS_PER_BANK * bank)
                                                 + i;
-                                        desc = irq_desc + irqnr;
+                                        desc = irq_to_desc(irqnr);
                                         desc->handle_irq(irqnr, desc);
                                         if (asic->irq_bothedge[bank] & bit)
                                                 asic3_irq_flip_edge(asic, base,
@@ -136,7 +136,7 @@ static void asic3_irq_demux(unsigned int irq, struct irq_desc *desc)
                 for (i = ASIC3_NUM_GPIOS; i < ASIC3_NR_IRQS; i++) {
                         /* They start at bit 4 and go up */
                         if (status & (1 << (i - ASIC3_NUM_GPIOS + 4))) {
-                                desc = irq_desc + asic->irq_base + i;
+                                desc = irq_to_desc(asic->irq_base + i);
                                 desc->handle_irq(asic->irq_base + i,
                                                  desc);
                         }
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
index 50dff6e0088d..1a4d04664d6d 100644
--- a/drivers/mfd/htc-egpio.c
+++ b/drivers/mfd/htc-egpio.c
@@ -112,7 +112,7 @@ static void egpio_handler(unsigned int irq, struct irq_desc *desc)
                 /* Run irq handler */
                 pr_debug("got IRQ %d\n", irqpin);
                 irq = ei->irq_start + irqpin;
-                desc = &irq_desc[irq];
+                desc = irq_to_desc(irq);
                 desc->handle_irq(irq, desc);
         }
 }
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 406989e992ba..7a72e75d5c67 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -132,6 +132,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         blk_queue_ordered(mq->queue, QUEUE_ORDERED_DRAIN, NULL);
+        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
 
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
         if (host->max_hw_segs == 1) {
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index ae16d845d746..3b2085b57769 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -3,6 +3,9 @@
  *
  *  Copyright (C) 2004-2006 maintech GmbH, Thomas Kleffel <tk@maintech.de>
  *
+ * Current driver maintained by Ben Dooks and Simtec Electronics
+ *  Copyright (C) 2008 Simtec Electronics <ben-linux@fluff.org>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
@@ -13,6 +16,7 @@
 #include <linux/clk.h>
 #include <linux/mmc/host.h>
 #include <linux/platform_device.h>
+#include <linux/cpufreq.h>
 #include <linux/irq.h>
 #include <linux/io.h>
 
@@ -39,9 +43,9 @@ enum dbg_channels {
         dbg_conf  = (1 << 8),
 };
 
-static const int dbgmap_err   = dbg_err | dbg_fail;
+static const int dbgmap_err   = dbg_fail;
 static const int dbgmap_info  = dbg_info | dbg_conf;
-static const int dbgmap_debug = dbg_debug;
+static const int dbgmap_debug = dbg_err | dbg_debug;
 
 #define dbg(host, channels, args...)              \
         do {                                      \
@@ -189,7 +193,7 @@ static inline void clear_imask(struct s3cmci_host *host)
 }
 
 static inline int get_data_buffer(struct s3cmci_host *host,
-                                  u32 *words, u32 **pointer)
+                                  u32 *bytes, u32 **pointer)
 {
         struct scatterlist *sg;
 
@@ -206,7 +210,7 @@ static inline int get_data_buffer(struct s3cmci_host *host,
         }
         sg = &host->mrq->data->sg[host->pio_sgptr];
 
-        *words = sg->length >> 2;
+        *bytes = sg->length;
         *pointer = sg_virt(sg);
 
         host->pio_sgptr++;
@@ -222,7 +226,7 @@ static inline u32 fifo_count(struct s3cmci_host *host)
         u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
 
         fifostat &= S3C2410_SDIFSTA_COUNTMASK;
-        return fifostat >> 2;
+        return fifostat;
 }
 
 static inline u32 fifo_free(struct s3cmci_host *host)
@@ -230,13 +234,15 @@ static inline u32 fifo_free(struct s3cmci_host *host)
         u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
 
         fifostat &= S3C2410_SDIFSTA_COUNTMASK;
-        return (63 - fifostat) >> 2;
+        return 63 - fifostat;
 }
 
 static void do_pio_read(struct s3cmci_host *host)
 {
         int res;
         u32 fifo;
+        u32 *ptr;
+        u32 fifo_words;
         void __iomem *from_ptr;
 
         /* write real prescaler to host, it might be set slow to fix */
@@ -245,8 +251,8 @@ static void do_pio_read(struct s3cmci_host *host)
         from_ptr = host->base + host->sdidata;
 
         while ((fifo = fifo_count(host))) {
-                if (!host->pio_words) {
-                        res = get_data_buffer(host, &host->pio_words,
+                if (!host->pio_bytes) {
+                        res = get_data_buffer(host, &host->pio_bytes,
                                               &host->pio_ptr);
                         if (res) {
                                 host->pio_active = XFER_NONE;
@@ -259,26 +265,47 @@ static void do_pio_read(struct s3cmci_host *host)
 
                         dbg(host, dbg_pio,
                             "pio_read(): new target: [%i]@[%p]\n",
-                            host->pio_words, host->pio_ptr);
+                            host->pio_bytes, host->pio_ptr);
                 }
 
                 dbg(host, dbg_pio,
                     "pio_read(): fifo:[%02i] buffer:[%03i] dcnt:[%08X]\n",
-                    fifo, host->pio_words,
+                    fifo, host->pio_bytes,
                     readl(host->base + S3C2410_SDIDCNT));
 
-                if (fifo > host->pio_words)
-                        fifo = host->pio_words;
+                /* If we have reached the end of the block, we can
+                 * read a word and get 1 to 3 bytes.  If we in the
+                 * middle of the block, we have to read full words,
+                 * otherwise we will write garbage, so round down to
+                 * an even multiple of 4. */
+                if (fifo >= host->pio_bytes)
+                        fifo = host->pio_bytes;
+                else
+                        fifo -= fifo & 3;
 
-                host->pio_words -= fifo;
+                host->pio_bytes -= fifo;
                 host->pio_count += fifo;
 
-                while (fifo--)
-                        *(host->pio_ptr++) = readl(from_ptr);
+                fifo_words = fifo >> 2;
+                ptr = host->pio_ptr;
+                while (fifo_words--)
+                        *ptr++ = readl(from_ptr);
+                host->pio_ptr = ptr;
+
+                if (fifo & 3) {
+                        u32 n = fifo & 3;
+                        u32 data = readl(from_ptr);
+                        u8 *p = (u8 *)host->pio_ptr;
+
+                        while (n--) {
+                                *p++ = data;
+                                data >>= 8;
+                        }
+                }
         }
 
-        if (!host->pio_words) {
-                res = get_data_buffer(host, &host->pio_words, &host->pio_ptr);
+        if (!host->pio_bytes) {
+                res = get_data_buffer(host, &host->pio_bytes, &host->pio_ptr);
                 if (res) {
                         dbg(host, dbg_pio,
                             "pio_read(): complete (no more buffers).\n");
@@ -298,12 +325,13 @@ static void do_pio_write(struct s3cmci_host *host)
         void __iomem *to_ptr;
         int res;
         u32 fifo;
+        u32 *ptr;
 
         to_ptr = host->base + host->sdidata;
 
         while ((fifo = fifo_free(host))) {
-                if (!host->pio_words) {
-                        res = get_data_buffer(host, &host->pio_words,
+                if (!host->pio_bytes) {
+                        res = get_data_buffer(host, &host->pio_bytes,
                                                         &host->pio_ptr);
                         if (res) {
                                 dbg(host, dbg_pio,
@@ -315,18 +343,27 @@ static void do_pio_write(struct s3cmci_host *host)
 
                         dbg(host, dbg_pio,
                             "pio_write(): new source: [%i]@[%p]\n",
-                            host->pio_words, host->pio_ptr);
+                            host->pio_bytes, host->pio_ptr);
 
                 }
 
-                if (fifo > host->pio_words)
-                        fifo = host->pio_words;
+                /* If we have reached the end of the block, we have to
+                 * write exactly the remaining number of bytes.  If we
+                 * in the middle of the block, we have to write full
+                 * words, so round down to an even multiple of 4. */
+                if (fifo >= host->pio_bytes)
+                        fifo = host->pio_bytes;
+                else
+                        fifo -= fifo & 3;
 
-                host->pio_words -= fifo;
+                host->pio_bytes -= fifo;
                 host->pio_count += fifo;
 
+                fifo = (fifo + 3) >> 2;
+                ptr = host->pio_ptr;
                 while (fifo--)
-                        writel(*(host->pio_ptr++), to_ptr);
+                        writel(*ptr++, to_ptr);
+                host->pio_ptr = ptr;
         }
 
         enable_imask(host, S3C2410_SDIIMSK_TXFIFOHALF);
@@ -349,9 +386,9 @@ static void pio_tasklet(unsigned long data)
                 clear_imask(host);
                 if (host->pio_active != XFER_NONE) {
                         dbg(host, dbg_err, "unfinished %s "
-                            "- pio_count:[%u] pio_words:[%u]\n",
+                            "- pio_count:[%u] pio_bytes:[%u]\n",
                             (host->pio_active == XFER_READ) ? "read" : "write",
-                            host->pio_count, host->pio_words);
+                            host->pio_count, host->pio_bytes);
 
                         if (host->mrq->data)
                                 host->mrq->data->error = -EINVAL;
@@ -812,11 +849,10 @@ static int s3cmci_setup_data(struct s3cmci_host *host, struct mmc_data *data)
                 /* We cannot deal with unaligned blocks with more than
                  * one block being transfered. */
 
-                if (data->blocks > 1)
+                if (data->blocks > 1) {
+                        pr_warning("%s: can't do non-word sized block transfers (blksz %d)\n", __func__, data->blksz);
                         return -EINVAL;
-
-                /* No support yet for non-word block transfers. */
-                return -EINVAL;
+                }
         }
 
         while (readl(host->base + S3C2410_SDIDSTA) &
@@ -896,7 +932,7 @@ static int s3cmci_prepare_pio(struct s3cmci_host *host, struct mmc_data *data)
         BUG_ON((data->flags & BOTH_DIR) == BOTH_DIR);
 
         host->pio_sgptr = 0;
-        host->pio_words = 0;
+        host->pio_bytes = 0;
         host->pio_count = 0;
         host->pio_active = rw ? XFER_WRITE : XFER_READ;
 
@@ -1033,10 +1069,33 @@ static void s3cmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 s3cmci_send_request(mmc);
 }
 
+static void s3cmci_set_clk(struct s3cmci_host *host, struct mmc_ios *ios)
+{
+        u32 mci_psc;
+
+        /* Set clock */
+        for (mci_psc = 0; mci_psc < 255; mci_psc++) {
+                host->real_rate = host->clk_rate / (host->clk_div*(mci_psc+1));
+
+                if (host->real_rate <= ios->clock)
+                        break;
+        }
+
+        if (mci_psc > 255)
+                mci_psc = 255;
+
+        host->prescaler = mci_psc;
+        writel(host->prescaler, host->base + S3C2410_SDIPRE);
+
+        /* If requested clock is 0, real_rate will be 0, too */
+        if (ios->clock == 0)
+                host->real_rate = 0;
+}
+
 static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct s3cmci_host *host = mmc_priv(mmc);
-        u32 mci_psc, mci_con;
+        u32 mci_con;
 
         /* Set the power state */
 
@@ -1074,23 +1133,7 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 break;
         }
 
-        /* Set clock */
-        for (mci_psc = 0; mci_psc < 255; mci_psc++) {
-                host->real_rate = host->clk_rate / (host->clk_div*(mci_psc+1));
-
-                if (host->real_rate <= ios->clock)
-                        break;
-        }
-
-        if (mci_psc > 255)
-                mci_psc = 255;
-
-        host->prescaler = mci_psc;
-        writel(host->prescaler, host->base + S3C2410_SDIPRE);
-
-        /* If requested clock is 0, real_rate will be 0, too */
-        if (ios->clock == 0)
-                host->real_rate = 0;
+        s3cmci_set_clk(host, ios);
 
         /* Set CLOCK_ENABLE */
         if (ios->clock)
@@ -1148,6 +1191,61 @@ static struct s3c24xx_mci_pdata s3cmci_def_pdata = {
          * checks. Any zero fields to ensure reaonable defaults are picked. */
 };
 
+#ifdef CONFIG_CPU_FREQ
+
+static int s3cmci_cpufreq_transition(struct notifier_block *nb,
+                                     unsigned long val, void *data)
+{
+        struct s3cmci_host *host;
+        struct mmc_host *mmc;
+        unsigned long newclk;
+        unsigned long flags;
+
+        host = container_of(nb, struct s3cmci_host, freq_transition);
+        newclk = clk_get_rate(host->clk);
+        mmc = host->mmc;
+
+        if ((val == CPUFREQ_PRECHANGE && newclk > host->clk_rate) ||
+            (val == CPUFREQ_POSTCHANGE && newclk < host->clk_rate)) {
+                spin_lock_irqsave(&mmc->lock, flags);
+
+                host->clk_rate = newclk;
+
+                if (mmc->ios.power_mode != MMC_POWER_OFF &&
+                    mmc->ios.clock != 0)
+                        s3cmci_set_clk(host, &mmc->ios);
+
+                spin_unlock_irqrestore(&mmc->lock, flags);
+        }
+
+        return 0;
+}
+
+static inline int s3cmci_cpufreq_register(struct s3cmci_host *host)
+{
+        host->freq_transition.notifier_call = s3cmci_cpufreq_transition;
+
+        return cpufreq_register_notifier(&host->freq_transition,
+                                         CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+static inline void s3cmci_cpufreq_deregister(struct s3cmci_host *host)
+{
+        cpufreq_unregister_notifier(&host->freq_transition,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+#else
+static inline int s3cmci_cpufreq_register(struct s3cmci_host *host)
+{
+        return 0;
+}
+
+static inline void s3cmci_cpufreq_deregister(struct s3cmci_host *host)
+{
+}
+#endif
+
 static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
 {
         struct s3cmci_host *host;
@@ -1298,10 +1396,16 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
             (host->is2440?"2440":""),
             host->base, host->irq, host->irq_cd, host->dma);
 
+        ret = s3cmci_cpufreq_register(host);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register cpufreq\n");
+                goto free_dmabuf;
+        }
+
         ret = mmc_add_host(mmc);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add mmc host.\n");
-                goto free_dmabuf;
+                goto free_cpufreq;
         }
 
         platform_set_drvdata(pdev, mmc);
@@ -1309,6 +1413,9 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
 
         return 0;
 
+ free_cpufreq:
+        s3cmci_cpufreq_deregister(host);
+
  free_dmabuf:
         clk_disable(host->clk);
 
@@ -1342,6 +1449,7 @@ static void s3cmci_shutdown(struct platform_device *pdev)
         if (host->irq_cd >= 0)
                 free_irq(host->irq_cd, host);
 
+        s3cmci_cpufreq_deregister(host);
         mmc_remove_host(mmc);
         clk_disable(host->clk);
 }
@@ -1455,7 +1563,7 @@ module_exit(s3cmci_exit);
 
 MODULE_DESCRIPTION("Samsung S3C MMC/SD Card Interface driver");
 MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>");
+MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>, Ben Dooks <ben-linux@fluff.org>");
 MODULE_ALIAS("platform:s3c2410-sdi");
 MODULE_ALIAS("platform:s3c2412-sdi");
 MODULE_ALIAS("platform:s3c2440-sdi");
diff --git a/drivers/mmc/host/s3cmci.h b/drivers/mmc/host/s3cmci.h
index 37d9c60010c9..ca1ba3d58cfd 100644
--- a/drivers/mmc/host/s3cmci.h
+++ b/drivers/mmc/host/s3cmci.h
@@ -51,7 +51,7 @@ struct s3cmci_host {
         int                     dma_complete;
 
         u32                     pio_sgptr;
-        u32                     pio_words;
+        u32                     pio_bytes;
         u32                     pio_count;
         u32                     *pio_ptr;
 #define XFER_NONE 0
@@ -67,4 +67,8 @@ struct s3cmci_host {
 
         unsigned int            ccnt, dcnt;
         struct tasklet_struct   pio_tasklet;
+
+#ifdef CONFIG_CPU_FREQ
+        struct notifier_block   freq_transition;
+#endif
 };
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 491ee16da5c1..9ba295d9dd97 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -90,7 +90,7 @@ static int vortex_debug = 1;
 #include <linux/eisa.h>
 #include <linux/bitops.h>
 #include <linux/jiffies.h>
-#include <asm/irq.h>                    /* For NR_IRQS only. */
+#include <asm/irq.h>                    /* For nr_irqs only. */
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
@@ -1221,7 +1221,7 @@ static int __devinit vortex_probe1(struct device *gendev,
         if (print_info)
                 printk(", IRQ %d\n", dev->irq);
         /* Tell them about an invalid IRQ. */
-        if (dev->irq <= 0 || dev->irq >= NR_IRQS)
+        if (dev->irq <= 0 || dev->irq >= nr_irqs)
                 printk(KERN_WARNING " *** Warning: IRQ %d is unlikely to work! ***\n",
                            dev->irq);
 
diff --git a/drivers/net/hamradio/baycom_ser_fdx.c b/drivers/net/hamradio/baycom_ser_fdx.c
index 17ac6975d70d..b6a816e60c0f 100644
--- a/drivers/net/hamradio/baycom_ser_fdx.c
+++ b/drivers/net/hamradio/baycom_ser_fdx.c
@@ -416,10 +416,10 @@ static int ser12_open(struct net_device *dev)
         if (!dev || !bc)
                 return -ENXIO;
         if (!dev->base_addr || dev->base_addr > 0xffff-SER12_EXTENT ||
-            dev->irq < 2 || dev->irq > NR_IRQS) {
+            dev->irq < 2 || dev->irq > nr_irqs) {
                 printk(KERN_INFO "baycom_ser_fdx: invalid portnumber (max %u) "
                                 "or irq (2 <= irq <= %d)\n",
-                                0xffff-SER12_EXTENT, NR_IRQS);
+                                0xffff-SER12_EXTENT, nr_irqs);
                 return -ENXIO;
         }
         if (bc->baud < 300 || bc->baud > 4800) {
diff --git a/drivers/net/hamradio/scc.c b/drivers/net/hamradio/scc.c
index 45ae9d1191d7..c17e39bc5460 100644
--- a/drivers/net/hamradio/scc.c
+++ b/drivers/net/hamradio/scc.c
@@ -1465,7 +1465,7 @@ static void z8530_init(void)
         printk(KERN_INFO "Init Z8530 driver: %u channels, IRQ", Nchips*2);
         
         flag=" ";
-        for (k = 0; k < NR_IRQS; k++)
+        for (k = 0; k < nr_irqs; k++)
                 if (Ivec[k].used) 
                 {
                         printk("%s%d", flag, k);
@@ -1728,7 +1728,7 @@ static int scc_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 
                         if (hwcfg.irq == 2) hwcfg.irq = 9;
 
-                        if (hwcfg.irq < 0 || hwcfg.irq >= NR_IRQS)
+                        if (hwcfg.irq < 0 || hwcfg.irq >= nr_irqs)
                                 return -EINVAL;
                                 
                         if (!Ivec[hwcfg.irq].used && hwcfg.irq)
@@ -2148,7 +2148,7 @@ static void __exit scc_cleanup_driver(void)
                 }
                 
         /* To unload the port must be closed so no real IRQ pending */
-        for (k=0; k < NR_IRQS ; k++)
+        for (k = 0; k < nr_irqs ; k++)
                 if (Ivec[k].used) free_irq(k, NULL);
                 
         local_irq_enable();
diff --git a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c
index f972fef87c98..ee51b6a5e605 100644
--- a/drivers/net/wan/sbni.c
+++ b/drivers/net/wan/sbni.c
@@ -318,7 +318,7 @@ sbni_pci_probe( struct net_device  *dev )
                                 continue;
                 }
 
-                if( pci_irq_line <= 0  ||  pci_irq_line >= NR_IRQS )
+                if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
                         printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
                                 "this PCI card to IRQ %d, which is unlikely "
                                 "to work!.\n"
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index fd56128525d1..3bc54b30c3a1 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -298,7 +298,8 @@ struct pci_port_ops dino_port_ops = {
 
 static void dino_disable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct dino_device *dino_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
 
         DBG(KERN_WARNING "%s(0x%p, %d)\n", __func__, dino_dev, irq);
@@ -310,7 +311,8 @@ static void dino_disable_irq(unsigned int irq)
 
 static void dino_enable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct dino_device *dino_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
         u32 tmp;
 
diff --git a/drivers/parisc/eisa.c b/drivers/parisc/eisa.c
index 771cef592542..7891db50c483 100644
--- a/drivers/parisc/eisa.c
+++ b/drivers/parisc/eisa.c
@@ -346,10 +346,10 @@ static int __init eisa_probe(struct parisc_device *dev)
         }
         
         /* Reserve IRQ2 */
-        irq_desc[2].action = &irq2_action;
+        irq_to_desc(2)->action = &irq2_action;
         
         for (i = 0; i < 16; i++) {
-                irq_desc[i].chip = &eisa_interrupt_type;
+                irq_to_desc(i)->chip = &eisa_interrupt_type;
         }
         
         EISA_bus = 1;
diff --git a/drivers/parisc/gsc.c b/drivers/parisc/gsc.c
index f7d088b897ee..e76db9e4d504 100644
--- a/drivers/parisc/gsc.c
+++ b/drivers/parisc/gsc.c
@@ -108,7 +108,8 @@ int gsc_find_local_irq(unsigned int irq, int *global_irqs, int limit)
 
 static void gsc_asic_disable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct gsc_asic *irq_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
         u32 imr;
 
@@ -123,7 +124,8 @@ static void gsc_asic_disable_irq(unsigned int irq)
 
 static void gsc_asic_enable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct gsc_asic *irq_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
         u32 imr;
 
@@ -159,12 +161,14 @@ static struct hw_interrupt_type gsc_asic_interrupt_type = {
 int gsc_assign_irq(struct hw_interrupt_type *type, void *data)
 {
         static int irq = GSC_IRQ_BASE;
+        struct irq_desc *desc;
 
         if (irq > GSC_IRQ_MAX)
                 return NO_IRQ;
 
-        irq_desc[irq].chip = type;
-        irq_desc[irq].chip_data = data;
+        desc = irq_to_desc(irq);
+        desc->chip = type;
+        desc->chip_data = data;
         return irq++;
 }
 
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 6fb3f7979f21..7beffcab2745 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -619,7 +619,9 @@ iosapic_set_irt_data( struct vector_info *vi, u32 *dp0, u32 *dp1)
 
 static struct vector_info *iosapic_get_vector(unsigned int irq)
 {
-        return irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        return desc->chip_data;
 }
 
 static void iosapic_disable_irq(unsigned int irq)
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index 1e8d2d17f04c..1e93c837514f 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -363,7 +363,9 @@ int superio_fixup_irq(struct pci_dev *pcidev)
 #endif
 
         for (i = 0; i < 16; i++) {
-                irq_desc[i].chip = &superio_interrupt_type;
+                struct irq_desc *desc = irq_to_desc(i);
+
+                desc->chip = &superio_interrupt_type;
         }
 
         /*
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index e842e756308a..8b29c307f1a1 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -193,7 +193,7 @@ dmar_parse_dev(struct dmar_drhd_unit *dmaru)
 {
         struct acpi_dmar_hardware_unit *drhd;
         static int include_all;
-        int ret;
+        int ret = 0;
 
         drhd = (struct acpi_dmar_hardware_unit *) dmaru->hdr;
 
@@ -212,7 +212,7 @@ dmar_parse_dev(struct dmar_drhd_unit *dmaru)
                 include_all = 1;
         }
 
-        if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all)) {
+        if (ret) {
                 list_del(&dmaru->list);
                 kfree(dmaru);
         }
@@ -289,6 +289,24 @@ dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
         }
 }
 
+/**
+ * dmar_table_detect - checks to see if the platform supports DMAR devices
+ */
+static int __init dmar_table_detect(void)
+{
+        acpi_status status = AE_OK;
+
+        /* if we could find DMAR table, then there are DMAR devices */
+        status = acpi_get_table(ACPI_SIG_DMAR, 0,
+                                (struct acpi_table_header **)&dmar_tbl);
+
+        if (ACPI_SUCCESS(status) && !dmar_tbl) {
+                printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
+                status = AE_NOT_FOUND;
+        }
+
+        return (ACPI_SUCCESS(status) ? 1 : 0);
+}
 
 /**
  * parse_dmar_table - parses the DMA reporting table
@@ -300,6 +318,12 @@ parse_dmar_table(void)
         struct acpi_dmar_header *entry_header;
         int ret = 0;
 
+        /*
+         * Do it again, earlier dmar_tbl mapping could be mapped with
+         * fixed map.
+         */
+        dmar_table_detect();
+
         dmar = (struct acpi_table_dmar *)dmar_tbl;
         if (!dmar)
                 return -ENODEV;
@@ -373,10 +397,10 @@ dmar_find_matched_drhd_unit(struct pci_dev *dev)
 
 int __init dmar_dev_scope_init(void)
 {
-        struct dmar_drhd_unit *drhd;
+        struct dmar_drhd_unit *drhd, *drhd_n;
         int ret = -ENODEV;
 
-        for_each_drhd_unit(drhd) {
+        list_for_each_entry_safe(drhd, drhd_n, &dmar_drhd_units, list) {
                 ret = dmar_parse_dev(drhd);
                 if (ret)
                         return ret;
@@ -384,8 +408,8 @@ int __init dmar_dev_scope_init(void)
 
 #ifdef CONFIG_DMAR
         {
-                struct dmar_rmrr_unit *rmrr;
-                for_each_rmrr_units(rmrr) {
+                struct dmar_rmrr_unit *rmrr, *rmrr_n;
+                list_for_each_entry_safe(rmrr, rmrr_n, &dmar_rmrr_units, list) {
                         ret = rmrr_parse_dev(rmrr);
                         if (ret)
                                 return ret;
@@ -430,30 +454,11 @@ int __init dmar_table_init(void)
         return 0;
 }
 
-/**
- * early_dmar_detect - checks to see if the platform supports DMAR devices
- */
-int __init early_dmar_detect(void)
-{
-        acpi_status status = AE_OK;
-
-        /* if we could find DMAR table, then there are DMAR devices */
-        status = acpi_get_table(ACPI_SIG_DMAR, 0,
-                                (struct acpi_table_header **)&dmar_tbl);
-
-        if (ACPI_SUCCESS(status) && !dmar_tbl) {
-                printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
-                status = AE_NOT_FOUND;
-        }
-
-        return (ACPI_SUCCESS(status) ? 1 : 0);
-}
-
 void __init detect_intel_iommu(void)
 {
         int ret;
 
-        ret = early_dmar_detect();
+        ret = dmar_table_detect();
 
 #ifdef CONFIG_DMAR
         {
@@ -479,14 +484,16 @@ void __init detect_intel_iommu(void)
                                " x2apic support\n");
 
                         dmar_disabled = 1;
-                        return;
+                        goto end;
                 }
 
                 if (ret && !no_iommu && !iommu_detected && !swiotlb &&
                     !dmar_disabled)
                         iommu_detected = 1;
         }
+end:
 #endif
+        dmar_tbl = NULL;
 }
 
 
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
index 279c940a0039..bf7d6ce9bbb3 100644
--- a/drivers/pci/htirq.c
+++ b/drivers/pci/htirq.c
@@ -126,7 +126,8 @@ int __ht_create_irq(struct pci_dev *dev, int idx, ht_irq_update_t *update)
         cfg->msg.address_hi = 0xffffffff;
 
         irq = create_irq();
-        if (irq < 0) {
+
+        if (irq <= 0) {
                 kfree(cfg);
                 return -EBUSY;
         }
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 738d4c89581c..2de5a3238c94 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -1,3 +1,4 @@
+#include <linux/interrupt.h>
 #include <linux/dmar.h>
 #include <linux/spinlock.h>
 #include <linux/jiffies.h>
@@ -11,41 +12,64 @@ static struct ioapic_scope ir_ioapic[MAX_IO_APICS];
 static int ir_ioapic_num;
 int intr_remapping_enabled;
 
-static struct {
+struct irq_2_iommu {
         struct intel_iommu *iommu;
         u16 irte_index;
         u16 sub_handle;
         u8  irte_mask;
-} irq_2_iommu[NR_IRQS];
+};
+
+static struct irq_2_iommu irq_2_iommuX[NR_IRQS];
+
+static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
+{
+        return (irq < nr_irqs) ? irq_2_iommuX + irq : NULL;
+}
+
+static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
+{
+        return irq_2_iommu(irq);
+}
 
 static DEFINE_SPINLOCK(irq_2_ir_lock);
 
-int irq_remapped(int irq)
+static struct irq_2_iommu *valid_irq_2_iommu(unsigned int irq)
 {
-        if (irq > NR_IRQS)
-                return 0;
+        struct irq_2_iommu *irq_iommu;
+
+        irq_iommu = irq_2_iommu(irq);
+
+        if (!irq_iommu)
+                return NULL;
+
+        if (!irq_iommu->iommu)
+                return NULL;
 
-        if (!irq_2_iommu[irq].iommu)
-                return 0;
+        return irq_iommu;
+}
 
-        return 1;
+int irq_remapped(int irq)
+{
+        return valid_irq_2_iommu(irq) != NULL;
 }
 
 int get_irte(int irq, struct irte *entry)
 {
         int index;
+        struct irq_2_iommu *irq_iommu;
 
-        if (!entry || irq > NR_IRQS)
+        if (!entry)
                 return -1;
 
         spin_lock(&irq_2_ir_lock);
-        if (!irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
-        *entry = *(irq_2_iommu[irq].iommu->ir_table->base + index);
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
+        *entry = *(irq_iommu->iommu->ir_table->base + index);
 
         spin_unlock(&irq_2_ir_lock);
         return 0;
@@ -54,6 +78,7 @@ int get_irte(int irq, struct irte *entry)
 int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
 {
         struct ir_table *table = iommu->ir_table;
+        struct irq_2_iommu *irq_iommu;
         u16 index, start_index;
         unsigned int mask = 0;
         int i;
@@ -61,6 +86,10 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         if (!count)
                 return -1;
 
+        /* protect irq_2_iommu_alloc later */
+        if (irq >= nr_irqs)
+                return -1;
+
         /*
          * start the IRTE search from index 0.
          */
@@ -100,10 +129,11 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         for (i = index; i < index + count; i++)
                 table->base[i].present = 1;
 
-        irq_2_iommu[irq].iommu = iommu;
-        irq_2_iommu[irq].irte_index =  index;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = mask;
+        irq_iommu = irq_2_iommu_alloc(irq);
+        irq_iommu->iommu = iommu;
+        irq_iommu->irte_index =  index;
+        irq_iommu->sub_handle = 0;
+        irq_iommu->irte_mask = mask;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -124,31 +154,33 @@ static void qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
 int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 {
         int index;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        *sub_handle = irq_2_iommu[irq].sub_handle;
-        index = irq_2_iommu[irq].irte_index;
+        *sub_handle = irq_iommu->sub_handle;
+        index = irq_iommu->irte_index;
         spin_unlock(&irq_2_ir_lock);
         return index;
 }
 
 int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 {
+        struct irq_2_iommu *irq_iommu;
+
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || irq_2_iommu[irq].iommu) {
-                spin_unlock(&irq_2_ir_lock);
-                return -1;
-        }
 
-        irq_2_iommu[irq].iommu = iommu;
-        irq_2_iommu[irq].irte_index = index;
-        irq_2_iommu[irq].sub_handle = subhandle;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu = irq_2_iommu_alloc(irq);
+
+        irq_iommu->iommu = iommu;
+        irq_iommu->irte_index = index;
+        irq_iommu->sub_handle = subhandle;
+        irq_iommu->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -157,16 +189,19 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 
 int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index)
 {
+        struct irq_2_iommu *irq_iommu;
+
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        irq_2_iommu[irq].iommu = NULL;
-        irq_2_iommu[irq].irte_index = 0;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu->iommu = NULL;
+        irq_iommu->irte_index = 0;
+        irq_iommu->sub_handle = 0;
+        irq_2_iommu(irq)->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -178,16 +213,18 @@ int modify_irte(int irq, struct irte *irte_modified)
         int index;
         struct irte *irte;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
         irte = &iommu->ir_table->base[index];
 
         set_64bit((unsigned long *)irte, irte_modified->low | (1 << 1));
@@ -203,18 +240,20 @@ int flush_irte(int irq)
 {
         int index;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
 
-        qi_flush_iec(iommu, index, irq_2_iommu[irq].irte_mask);
+        qi_flush_iec(iommu, index, irq_iommu->irte_mask);
         spin_unlock(&irq_2_ir_lock);
 
         return 0;
@@ -246,28 +285,30 @@ int free_irte(int irq)
         int index, i;
         struct irte *irte;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
         irte = &iommu->ir_table->base[index];
 
-        if (!irq_2_iommu[irq].sub_handle) {
-                for (i = 0; i < (1 << irq_2_iommu[irq].irte_mask); i++)
+        if (!irq_iommu->sub_handle) {
+                for (i = 0; i < (1 << irq_iommu->irte_mask); i++)
                         set_64bit((unsigned long *)irte, 0);
-                qi_flush_iec(iommu, index, irq_2_iommu[irq].irte_mask);
+                qi_flush_iec(iommu, index, irq_iommu->irte_mask);
         }
 
-        irq_2_iommu[irq].iommu = NULL;
-        irq_2_iommu[irq].irte_index = 0;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu->iommu = NULL;
+        irq_iommu->irte_index = 0;
+        irq_iommu->sub_handle = 0;
+        irq_iommu->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
diff --git a/drivers/pcmcia/at91_cf.c b/drivers/pcmcia/at91_cf.c
index a0ffb8ebfe00..9e1140f085fd 100644
--- a/drivers/pcmcia/at91_cf.c
+++ b/drivers/pcmcia/at91_cf.c
@@ -273,7 +273,7 @@ static int __init at91_cf_probe(struct platform_device *pdev)
                         goto fail0d;
                 cf->socket.pci_irq = board->irq_pin;
         } else
-                cf->socket.pci_irq = NR_IRQS + 1;
+                cf->socket.pci_irq = nr_irqs + 1;
 
         /* pcmcia layer only remaps "real" memory not iospace */
         cf->socket.io_offset = (unsigned long)
diff --git a/drivers/pcmcia/hd64465_ss.c b/drivers/pcmcia/hd64465_ss.c
index 117dc12ab438..9ef69cdb3183 100644
--- a/drivers/pcmcia/hd64465_ss.c
+++ b/drivers/pcmcia/hd64465_ss.c
@@ -233,15 +233,18 @@ static struct hw_interrupt_type hd64465_ss_irq_type = {
  */
 static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
 {
+        struct irq_desc *desc;
+
         DPRINTK("hs_map_irq(sock=%d irq=%d)\n", sp->number, irq);
         
         if (irq >= HS_NUM_MAPPED_IRQS)
             return;
 
+        desc = irq_to_desc(irq);
         hs_mapped_irq[irq].sock = sp;
         /* insert ourselves as the irq controller */
-        hs_mapped_irq[irq].old_handler = irq_desc[irq].chip;
-        irq_desc[irq].chip = &hd64465_ss_irq_type;
+        hs_mapped_irq[irq].old_handler = desc->chip;
+        desc->chip = &hd64465_ss_irq_type;
 }
 
 
@@ -250,13 +253,16 @@ static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
  */
 static void hs_unmap_irq(hs_socket_t *sp, unsigned int irq)
 {
+        struct irq_desc *desc;
+
         DPRINTK("hs_unmap_irq(sock=%d irq=%d)\n", sp->number, irq);
         
         if (irq >= HS_NUM_MAPPED_IRQS)
             return;
                 
+        desc = irq_to_desc(irq);
         /* restore the original irq controller */
-        irq_desc[irq].chip = hs_mapped_irq[irq].old_handler;
+        desc->chip = hs_mapped_irq[irq].old_handler;
 }
 
 /*============================================================*/
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index eee2f1cb213c..b2c412419059 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -639,7 +639,7 @@ static int __devinit vrc4171_card_setup(char *options)
                 int irq;
                 options += 4;
                 irq = simple_strtoul(options, &options, 0);
-                if (irq >= 0 && irq < NR_IRQS)
+                if (irq >= 0 && irq < nr_irqs)
                         vrc4171_irq = irq;
 
                 if (*options != ',')
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index 884b635f028b..834dcc6d785f 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -360,7 +360,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
         spin_unlock_irq(&rtc_lock);
 
         aie_irq = platform_get_irq(pdev, 0);
-        if (aie_irq < 0 || aie_irq >= NR_IRQS) {
+        if (aie_irq < 0 || aie_irq >= nr_irqs) {
                 retval = -EBUSY;
                 goto err_device_unregister;
         }
@@ -371,7 +371,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
                 goto err_device_unregister;
 
         pie_irq = platform_get_irq(pdev, 1);
-        if (pie_irq < 0 || pie_irq >= NR_IRQS)
+        if (pie_irq < 0 || pie_irq >= nr_irqs)
                 goto err_free_irq;
 
         retval = request_irq(pie_irq, rtclong1_interrupt, IRQF_DISABLED,
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index b5a868d85eb4..1e5478abd90e 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -337,7 +337,7 @@ CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 #else
 #define IRQ_MIN 9
 #if defined(__PPC)
-#define IRQ_MAX (NR_IRQS-1)
+#define IRQ_MAX (nr_irqs-1)
 #else
 #define IRQ_MAX 12
 #endif
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 740bad435995..afc96e844a25 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -343,6 +343,11 @@ static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *r
 }
 
 #ifdef CONFIG_IDE_PROC_FS
+static ide_proc_entry_t idescsi_proc[] = {
+        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
+        { NULL, 0, NULL, NULL }
+};
+
 #define ide_scsi_devset_get(name, field) \
 static int get_##name(ide_drive_t *drive) \
 { \
@@ -378,6 +383,16 @@ static const struct ide_proc_devset idescsi_settings[] = {
         IDE_PROC_DEVSET(transform, 0,    3),
         { 0 },
 };
+
+static ide_proc_entry_t *ide_scsi_proc_entries(ide_drive_t *drive)
+{
+        return idescsi_proc;
+}
+
+static const struct ide_proc_devset *ide_scsi_proc_devsets(ide_drive_t *drive)
+{
+        return idescsi_settings;
+}
 #endif
 
 /*
@@ -419,13 +434,6 @@ static void ide_scsi_remove(ide_drive_t *drive)
 
 static int ide_scsi_probe(ide_drive_t *);
 
-#ifdef CONFIG_IDE_PROC_FS
-static ide_proc_entry_t idescsi_proc[] = {
-        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
-        { NULL, 0, NULL, NULL }
-};
-#endif
-
 static ide_driver_t idescsi_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
@@ -439,8 +447,8 @@ static ide_driver_t idescsi_driver = {
         .end_request            = idescsi_end_request,
         .error                  = idescsi_atapi_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idescsi_proc,
-        .settings               = idescsi_settings,
+        .proc_entries           = ide_scsi_proc_entries,
+        .proc_devsets           = ide_scsi_proc_devsets,
 #endif
 };
 
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 381b12ac20e0..d935b2d04f93 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -66,7 +66,6 @@
 #endif
 
 static struct m68k_serial m68k_soft[NR_PORTS];
-struct m68k_serial *IRQ_ports[NR_IRQS];
 
 static unsigned int uart_irqs[NR_PORTS] = UART_IRQ_DEFNS;
 
@@ -375,15 +374,11 @@ clear_and_return:
  */
 irqreturn_t rs_interrupt(int irq, void *dev_id)
 {
-        struct m68k_serial * info;
+        struct m68k_serial *info = dev_id;
         m68328_uart *uart;
         unsigned short rx;
         unsigned short tx;
 
-        info = IRQ_ports[irq];
-        if(!info)
-            return IRQ_NONE;
-
         uart = &uart_addr[info->line];
         rx = uart->urx.w;
 
@@ -1383,8 +1378,6 @@ rs68328_init(void)
                    info->port, info->irq);
             printk(" is a builtin MC68328 UART\n");
             
-            IRQ_ports[info->irq] = info;        /* waste of space */
-
 #ifdef CONFIG_M68VZ328
                 if (i > 0 )
                         PJSEL &= 0xCF;  /* PSW enable second port output */
@@ -1393,7 +1386,7 @@ rs68328_init(void)
             if (request_irq(uart_irqs[i],
                             rs_interrupt,
                             IRQF_DISABLED,
-                            "M68328_UART", NULL))
+                            "M68328_UART", info))
                 panic("Unable to attach 68328 serial interrupt\n");
         }
         local_irq_restore(flags);
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 1528de23a650..303272af386e 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -156,11 +156,15 @@ struct uart_8250_port {
 };
 
 struct irq_info {
-        spinlock_t              lock;
+        struct                  hlist_node node;
+        int                     irq;
+        spinlock_t              lock;   /* Protects list not the hash */
         struct list_head        *head;
 };
 
-static struct irq_info irq_lists[NR_IRQS];
+#define NR_IRQ_HASH             32      /* Can be adjusted later */
+static struct hlist_head irq_lists[NR_IRQ_HASH];
+static DEFINE_MUTEX(hash_mutex);        /* Used to walk the hash */
 
 /*
  * Here we define the default xmit fifo size used for each type of UART.
@@ -1545,15 +1549,43 @@ static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
                 BUG_ON(i->head != &up->list);
                 i->head = NULL;
         }
-
         spin_unlock_irq(&i->lock);
+        /* List empty so throw away the hash node */
+        if (i->head == NULL) {
+                hlist_del(&i->node);
+                kfree(i);
+        }
 }
 
 static int serial_link_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct hlist_head *h;
+        struct hlist_node *n;
+        struct irq_info *i;
         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
 
+        mutex_lock(&hash_mutex);
+
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+
+        if (n == NULL) {
+                i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
+                if (i == NULL) {
+                        mutex_unlock(&hash_mutex);
+                        return -ENOMEM;
+                }
+                spin_lock_init(&i->lock);
+                i->irq = up->port.irq;
+                hlist_add_head(&i->node, h);
+        }
+        mutex_unlock(&hash_mutex);
+
         spin_lock_irq(&i->lock);
 
         if (i->head) {
@@ -1577,14 +1609,28 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
 
 static void serial_unlink_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct irq_info *i;
+        struct hlist_node *n;
+        struct hlist_head *h;
 
+        mutex_lock(&hash_mutex);
+
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+
+        BUG_ON(n == NULL);
         BUG_ON(i->head == NULL);
 
         if (list_empty(i->head))
                 free_irq(up->port.irq, i);
 
         serial_do_unlink(i, up);
+        mutex_unlock(&hash_mutex);
 }
 
 /* Base timer interval for polling */
@@ -2447,7 +2493,7 @@ static void serial8250_config_port(struct uart_port *port, int flags)
 static int
 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
             ser->type == PORT_STARTECH)
@@ -2967,7 +3013,7 @@ EXPORT_SYMBOL(serial8250_unregister_port);
 
 static int __init serial8250_init(void)
 {
-        int ret, i;
+        int ret;
 
         if (nr_uarts > UART_NR)
                 nr_uarts = UART_NR;
@@ -2976,9 +3022,6 @@ static int __init serial8250_init(void)
                 "%d ports, IRQ sharing %sabled\n", nr_uarts,
                 share_irqs ? "en" : "dis");
 
-        for (i = 0; i < NR_IRQS; i++)
-                spin_lock_init(&irq_lists[i].lock);
-
 #ifdef CONFIG_SPARC
         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
 #else
@@ -3006,15 +3049,15 @@ static int __init serial8250_init(void)
                 goto out;
 
         platform_device_del(serial8250_isa_devs);
- put_dev:
+put_dev:
         platform_device_put(serial8250_isa_devs);
- unreg_uart_drv:
+unreg_uart_drv:
 #ifdef CONFIG_SPARC
         sunserial_unregister_minors(&serial8250_reg, UART_NR);
 #else
         uart_unregister_driver(&serial8250_reg);
 #endif
- out:
+out:
         return ret;
 }
 
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 90b56c2c31e2..71562689116f 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -512,7 +512,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
         int ret = 0;
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 9d08f27208a1..b7180046f8db 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -572,7 +572,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
         int ret = 0;
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index a6c4d744495e..bde4b4b0b80f 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -623,7 +623,7 @@ static int cpm_uart_verify_port(struct uart_port *port,
 
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index 23d030511019..611c97a15654 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -922,7 +922,7 @@ static void m32r_sio_config_port(struct uart_port *port, int flags)
 static int
 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
             ser->type >= ARRAY_SIZE(uart_config))
                 return -EINVAL;
@@ -1162,7 +1162,7 @@ static int __init m32r_sio_init(void)
 
         printk(KERN_INFO "Serial: M32R SIO driver\n");
 
-        for (i = 0; i < NR_IRQS; i++)
+        for (i = 0; i < nr_irqs; i++)
                 spin_lock_init(&irq_lists[i].lock);
 
         ret = uart_register_driver(&m32r_sio_reg);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 6bdf3362e3b1..874786a11fe9 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -741,7 +741,7 @@ static int uart_set_info(struct uart_state *state,
         if (port->ops->verify_port)
                 retval = port->ops->verify_port(port, &new_serial);
 
-        if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
+        if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) ||
             (new_serial.baud_base < 9600))
                 retval = -EINVAL;
 
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index cb49a5ac022f..61dc8b3daa26 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -460,7 +460,7 @@ static int lh7a40xuart_verify_port (struct uart_port* port,
 
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_LH7A40X)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600) /* *** FIXME: is this true? */
                 ret = -EINVAL;
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 3b9d2d83b590..f0658d2c45b2 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -1149,7 +1149,7 @@ static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
         struct sci_port *s = &sci_ports[port->line];
 
-        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > NR_IRQS)
+        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > nr_irqs)
                 return -EINVAL;
         if (ser->baud_base < 2400)
                 /* No paper tape reader for Mitch.. */
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index 539c933b335f..315a9333ca3c 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -1066,7 +1066,7 @@ static int qe_uart_verify_port(struct uart_port *port,
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                 return -EINVAL;
 
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 return -EINVAL;
 
         if (ser->baud_base < 9600)
diff --git a/drivers/video/imacfb.c b/drivers/video/imacfb.c
deleted file mode 100644
index e69de29bb2d1..000000000000
--- a/drivers/video/imacfb.c
+++ /dev/null
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index 05a28106e8eb..8782ec1f5aa0 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -154,7 +154,7 @@ static int ibwdt_set_heartbeat(int t)
                 return -EINVAL;
 
         for (i = 0x0F; i > -1; i--)
-                if (wd_times[i] > t)
+                if (wd_times[i] >= t)
                         break;
         wd_margin = i;
         return 0;
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index c3290bc186a0..9ce1ab6c268d 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -125,7 +125,7 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 
         BUG_ON(irq == -1);
 #ifdef CONFIG_SMP
-        irq_desc[irq].affinity = cpumask_of_cpu(cpu);
+        irq_to_desc(irq)->affinity = cpumask_of_cpu(cpu);
 #endif
 
         __clear_bit(chn, cpu_evtchn_mask[cpu_evtchn[chn]]);
@@ -137,10 +137,12 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 static void init_evtchn_cpu_bindings(void)
 {
 #ifdef CONFIG_SMP
+        struct irq_desc *desc;
         int i;
+
         /* By default all event channels notify CPU#0. */
-        for (i = 0; i < NR_IRQS; i++)
-                irq_desc[i].affinity = cpumask_of_cpu(0);
+        for_each_irq_desc(i, desc)
+                desc->affinity = cpumask_of_cpu(0);
 #endif
 
         memset(cpu_evtchn, 0, sizeof(cpu_evtchn));
@@ -229,12 +231,12 @@ static int find_unbound_irq(void)
         int irq;
 
         /* Only allocate from dynirq range */
-        for (irq = 0; irq < NR_IRQS; irq++)
+        for_each_irq_nr(irq)
                 if (irq_bindcount[irq] == 0)
                         break;
 
-        if (irq == NR_IRQS)
-                panic("No available IRQ to bind to: increase NR_IRQS!\n");
+        if (irq == nr_irqs)
+                panic("No available IRQ to bind to: increase nr_irqs!\n");
 
         return irq;
 }
@@ -790,7 +792,7 @@ void xen_irq_resume(void)
                 mask_evtchn(evtchn);
 
         /* No IRQ <-> event-channel mappings. */
-        for (irq = 0; irq < NR_IRQS; irq++)
+        for_each_irq_nr(irq)
                 irq_info[irq].evtchn = 0; /* zap event-channel binding */
 
         for (evtchn = 0; evtchn < NR_EVENT_CHANNELS; evtchn++)
@@ -822,7 +824,7 @@ void __init xen_init_IRQ(void)
                 mask_evtchn(i);
 
         /* Dynamic IRQ space is currently unbound. Zero the refcnts. */
-        for (i = 0; i < NR_IRQS; i++)
+        for_each_irq_nr(i)
                 irq_bindcount[i] = 0;
 
         irq_ctx_init(smp_processor_id());