410 files changed, 13926 insertions, 7193 deletions
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 35094f230b1e..7af7db1ba8c4 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -977,7 +977,7 @@ static int dock_add(acpi_handle handle)
                sizeof(struct dock_station *));
        /* we want the dock device to send uevents */
-        dock_device->dev.uevent_suppress = 0;
+        dev_set_uevent_suppress(&dock_device->dev, 0);
        if (is_dock(handle))
                dock_station->flags |= DOCK_IS_DOCK;
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 00c46e0b40e4..3d763fdf99b7 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -210,7 +210,7 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
        dev->dev.release = amba_device_release;
        dev->dev.bus = &amba_bustype;
        dev->dev.dma_mask = &dev->dma_mask;
-        dev->res.name = dev->dev.bus_id;
+        dev->res.name = dev_name(&dev->dev);
        if (!dev->dev.coherent_dma_mask && dev->dma_mask)
                dev_warn(&dev->dev, "coherent dma mask is unset\n");
@@ -294,7 +294,7 @@ static int amba_find_match(struct device *dev, void *data)
        if (d->parent)
                r &= d->parent == dev->parent;
        if (d->busid)
-                r &= strcmp(dev->bus_id, d->busid) == 0;
+                r &= strcmp(dev_name(dev), d->busid) == 0;
        if (r) {
                get_device(dev);
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 66e012cd3271..788bba2b1e17 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -404,7 +404,7 @@ static const struct ata_port_info ahci_port_info[] = {
        /* board_ahci */
        {
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_ops,
        },
@@ -412,7 +412,7 @@ static const struct ata_port_info ahci_port_info[] = {
        {
                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_vt8251_ops,
        },
@@ -420,7 +420,7 @@ static const struct ata_port_info ahci_port_info[] = {
        {
                AHCI_HFLAGS     (AHCI_HFLAG_IGN_IRQ_IF_ERR),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_ops,
        },
@@ -430,7 +430,7 @@ static const struct ata_port_info ahci_port_info[] = {
                                 AHCI_HFLAG_32BIT_ONLY | AHCI_HFLAG_NO_MSI |
                                 AHCI_HFLAG_SECT255),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_sb600_ops,
        },
@@ -440,7 +440,7 @@ static const struct ata_port_info ahci_port_info[] = {
                                 AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP),
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_ops,
        },
@@ -448,7 +448,7 @@ static const struct ata_port_info ahci_port_info[] = {
        {
                AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_sb600_ops,
        },
@@ -456,7 +456,7 @@ static const struct ata_port_info ahci_port_info[] = {
        {
                AHCI_HFLAGS     (AHCI_HFLAG_YES_NCQ),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_ops,
        },
@@ -464,7 +464,7 @@ static const struct ata_port_info ahci_port_info[] = {
        {
                AHCI_HFLAGS     (AHCI_HFLAG_NO_PMP),
                .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &ahci_ops,
        },
@@ -1348,7 +1348,7 @@ static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
        writel(message[1], mmio + hpriv->em_loc+4);
        /* save off new led state for port/slot */
-        emp->led_state = message[1];
+        emp->led_state = state;
        /*
         * tell hardware to transmit the message
@@ -2565,6 +2565,15 @@ static bool ahci_broken_system_poweroff(struct pci_dev *pdev)
                        /* PCI slot number of the controller */
                        .driver_data = (void *)0x1FUL,
                },
+                {
+                        .ident = "HP Compaq 6720s",
+                        .matches = {
+                                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                                DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6720s"),
+                        },
+                        /* PCI slot number of the controller */
+                        .driver_data = (void *)0x1FUL,
+                },
                { }     /* terminate list */
        };
@@ -2647,8 +2656,8 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
                hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;
-        if ((hpriv->flags & AHCI_HFLAG_NO_MSI) || pci_enable_msi(pdev))
+        if (!(hpriv->flags & AHCI_HFLAG_NO_MSI))
-                pci_intx(pdev, 1);
+                pci_enable_msi(pdev);
        /* save initial config */
        ahci_save_initial_config(pdev, hpriv);
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index dc48a6398abe..ecfd22b4f1ce 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -118,8 +118,8 @@ static int ata_generic_init_one(struct pci_dev *dev, const struct pci_device_id
        u16 command;
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &generic_port_ops
        };
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index ef8b30d577bd..e5cbe80ce172 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -446,34 +446,34 @@ static struct ata_port_info piix_port_info[] = {
        [piix_pata_mwdma] =     /* PIIX3 MWDMA only */
        {
                .flags          = PIIX_PATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+                .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
                .port_ops       = &piix_pata_ops,
        },
        [piix_pata_33] =        /* PIIX4 at 33MHz */
        {
                .flags          = PIIX_PATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+                .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
-                .udma_mask      = ATA_UDMA_MASK_40C,
+                .udma_mask      = ATA_UDMA2,
                .port_ops       = &piix_pata_ops,
        },
        [ich_pata_33] =         /* ICH0 - ICH at 33Mhz*/
        {
                .flags          = PIIX_PATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio 0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* Check: maybe 0x07  */
+                .mwdma_mask     = ATA_MWDMA12_ONLY, /* Check: maybe MWDMA0 is ok  */
-                .udma_mask      = ATA_UDMA2, /* UDMA33 */
+                .udma_mask      = ATA_UDMA2,
                .port_ops       = &ich_pata_ops,
        },
        [ich_pata_66] =         /* ICH controllers up to 66MHz */
        {
                .flags          = PIIX_PATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio 0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* MWDMA0 is broken on chip */
+                .mwdma_mask     = ATA_MWDMA12_ONLY, /* MWDMA0 is broken on chip */
                .udma_mask      = ATA_UDMA4,
                .port_ops       = &ich_pata_ops,
        },
@@ -481,17 +481,17 @@ static struct ata_port_info piix_port_info[] = {
        [ich_pata_100] =
        {
                .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* mwdma1-2 */
+                .mwdma_mask     = ATA_MWDMA12_ONLY,
-                .udma_mask      = ATA_UDMA5, /* udma0-5 */
+                .udma_mask      = ATA_UDMA5,
                .port_ops       = &ich_pata_ops,
        },
        [ich5_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -499,8 +499,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich6_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -508,8 +508,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich6m_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -517,8 +517,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8_sata] =
        {
                .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -526,8 +526,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8_2port_sata] =
        {
                .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -535,8 +535,8 @@ static struct ata_port_info piix_port_info[] = {
        [tolapai_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -544,8 +544,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8m_apple_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -553,9 +553,9 @@ static struct ata_port_info piix_port_info[] = {
        [piix_pata_vmw] =
        {
                .flags          = PIIX_PATA_FLAGS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+                .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
-                .udma_mask      = ATA_UDMA_MASK_40C,
+                .udma_mask      = ATA_UDMA2,
                .port_ops       = &piix_vmw_ops,
        },
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 060bcd601f57..e7ea77cf6069 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -57,6 +57,7 @@
 #include <linux/scatterlist.h>
 #include <linux/io.h>
 #include <linux/async.h>
+#include <linux/log2.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
@@ -2389,6 +2390,7 @@ int ata_dev_configure(struct ata_device *dev)
        dev->cylinders = 0;
        dev->heads = 0;
        dev->sectors = 0;
+        dev->multi_count = 0;
        /*
         * common ATA, ATAPI feature tests
@@ -2426,8 +2428,15 @@ int ata_dev_configure(struct ata_device *dev)
                dev->n_sectors = ata_id_n_sectors(id);
-                if (dev->id[59] & 0x100)
+                /* get current R/W Multiple count setting */
-                        dev->multi_count = dev->id[59] & 0xff;
+                if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
+                        unsigned int max = dev->id[47] & 0xff;
+                        unsigned int cnt = dev->id[59] & 0xff;
+                        /* only recognize/allow powers of two here */
+                        if (is_power_of_2(max) && is_power_of_2(cnt))
+                                if (cnt <= max)
+                                        dev->multi_count = cnt;
+                }
                if (ata_id_has_lba(id)) {
                        const char *lba_desc;
@@ -6709,6 +6718,7 @@ EXPORT_SYMBOL_GPL(ata_id_c_string);
 EXPORT_SYMBOL_GPL(ata_do_dev_read_id);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
+EXPORT_SYMBOL_GPL(ata_pio_queue_task);
 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
 EXPORT_SYMBOL_GPL(ata_timing_find_mode);
 EXPORT_SYMBOL_GPL(ata_timing_compute);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index ea890911d4fa..01831312c360 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -547,7 +547,7 @@ void ata_scsi_error(struct Scsi_Host *host)
        /* For new EH, all qcs are finished in one of three ways -
         * normal completion, error completion, and SCSI timeout.
-         * Both cmpletions can race against SCSI timeout.  When normal
+         * Both completions can race against SCSI timeout.  When normal
         * completion wins, the qc never reaches EH.  When error
         * completion wins, the qc has ATA_QCFLAG_FAILED set.
         *
@@ -562,7 +562,19 @@ void ata_scsi_error(struct Scsi_Host *host)
                int nr_timedout = 0;
                spin_lock_irqsave(ap->lock, flags);
+                
+                /* This must occur under the ap->lock as we don't want
+                   a polled recovery to race the real interrupt handler
+                   
+                   The lost_interrupt handler checks for any completed but
+                   non-notified command and completes much like an IRQ handler.
+                   
+                   We then fall into the error recovery code which will treat
+                   this as if normal completion won the race */
+                if (ap->ops->lost_interrupt)
+                        ap->ops->lost_interrupt(ap);
+                        
                list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
                        struct ata_queued_cmd *qc;
@@ -606,6 +618,9 @@ void ata_scsi_error(struct Scsi_Host *host)
                ap->eh_tries = ATA_EH_MAX_TRIES;
        } else
                spin_unlock_wait(ap->lock);
+                
+        /* If we timed raced normal completion and there is nothing to
+           recover nr_timedout == 0 why exactly are we doing error recovery ? */
 repeat:
        /* invoke error handler */
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index f93dc029dfde..8332e97a9de3 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -52,6 +52,7 @@ const struct ata_port_operations ata_sff_port_ops = {
        .softreset              = ata_sff_softreset,
        .hardreset              = sata_sff_hardreset,
        .postreset              = ata_sff_postreset,
+        .drain_fifo             = ata_sff_drain_fifo,
        .error_handler          = ata_sff_error_handler,
        .post_internal_cmd      = ata_sff_post_internal_cmd,
@@ -64,6 +65,8 @@ const struct ata_port_operations ata_sff_port_ops = {
        .sff_irq_on             = ata_sff_irq_on,
        .sff_irq_clear          = ata_sff_irq_clear,
+        .lost_interrupt         = ata_sff_lost_interrupt,
        .port_start             = ata_sff_port_start,
 };
 EXPORT_SYMBOL_GPL(ata_sff_port_ops);
@@ -1646,7 +1649,7 @@ EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);
 *      RETURNS:
 *      One if interrupt was handled, zero if not (shared irq).
 */
-inline unsigned int ata_sff_host_intr(struct ata_port *ap,
+unsigned int ata_sff_host_intr(struct ata_port *ap,
                                      struct ata_queued_cmd *qc)
 {
        struct ata_eh_info *ehi = &ap->link.eh_info;
@@ -1775,6 +1778,48 @@ irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)
 EXPORT_SYMBOL_GPL(ata_sff_interrupt);
 /**
+ *      ata_sff_lost_interrupt  -       Check for an apparent lost interrupt
+ *      @ap: port that appears to have timed out
+ *
+ *      Called from the libata error handlers when the core code suspects
+ *      an interrupt has been lost. If it has complete anything we can and
+ *      then return. Interface must support altstatus for this faster
+ *      recovery to occur.
+ *
+ *      Locking:
+ *      Caller holds host lock
+ */
+void ata_sff_lost_interrupt(struct ata_port *ap)
+{
+        u8 status;
+        struct ata_queued_cmd *qc;
+        /* Only one outstanding command per SFF channel */
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
+        /* Check we have a live one.. */
+        if (qc == NULL ||  !(qc->flags & ATA_QCFLAG_ACTIVE))
+                return;
+        /* We cannot lose an interrupt on a polled command */
+        if (qc->tf.flags & ATA_TFLAG_POLLING)
+                return;
+        /* See if the controller thinks it is still busy - if so the command
+           isn't a lost IRQ but is still in progress */
+        status = ata_sff_altstatus(ap);
+        if (status & ATA_BUSY)
+                return;
+        /* There was a command running, we are no longer busy and we have
+           no interrupt. */
+        ata_port_printk(ap, KERN_WARNING, "lost interrupt (Status 0x%x)\n",
+                                                                status);
+        /* Run the host interrupt logic as if the interrupt had not been
+           lost */
+        ata_sff_host_intr(ap, qc);
+}
+EXPORT_SYMBOL_GPL(ata_sff_lost_interrupt);
+/**
 *      ata_sff_freeze - Freeze SFF controller port
 *      @ap: port to freeze
 *
@@ -2199,6 +2244,39 @@ void ata_sff_postreset(struct ata_link *link, unsigned int *classes)
 EXPORT_SYMBOL_GPL(ata_sff_postreset);
 /**
+ *      ata_sff_drain_fifo - Stock FIFO drain logic for SFF controllers
+ *      @qc: command
+ *
+ *      Drain the FIFO and device of any stuck data following a command
+ *      failing to complete. In some cases this is neccessary before a
+ *      reset will recover the device.
+ *
+ */
+void ata_sff_drain_fifo(struct ata_queued_cmd *qc)
+{
+        int count;
+        struct ata_port *ap;
+        /* We only need to flush incoming data when a command was running */
+        if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE)
+                return;
+        ap = qc->ap;
+        /* Drain up to 64K of data before we give up this recovery method */
+        for (count = 0; (ap->ops->sff_check_status(ap) & ATA_DRQ)
+                                                && count < 32768; count++)
+                ioread16(ap->ioaddr.data_addr);
+        /* Can become DEBUG later */
+        if (count)
+                ata_port_printk(ap, KERN_DEBUG,
+                        "drained %d bytes to clear DRQ.\n", count);
+}
+EXPORT_SYMBOL_GPL(ata_sff_drain_fifo);
+/**
 *      ata_sff_error_handler - Stock error handler for BMDMA controller
 *      @ap: port to handle error for
 *
@@ -2239,7 +2317,8 @@ void ata_sff_error_handler(struct ata_port *ap)
                 * really a timeout event, adjust error mask and
                 * cancel frozen state.
                 */
-                if (qc->err_mask == AC_ERR_TIMEOUT && (host_stat & ATA_DMA_ERR)) {
+                if (qc->err_mask == AC_ERR_TIMEOUT
+                                                && (host_stat & ATA_DMA_ERR)) {
                        qc->err_mask = AC_ERR_HOST_BUS;
                        thaw = 1;
                }
@@ -2250,6 +2329,13 @@ void ata_sff_error_handler(struct ata_port *ap)
        ata_sff_sync(ap);               /* FIXME: We don't need this */
        ap->ops->sff_check_status(ap);
        ap->ops->sff_irq_clear(ap);
+        /* We *MUST* do FIFO draining before we issue a reset as several
+         * devices helpfully clear their internal state and will lock solid
+         * if we touch the data port post reset. Pass qc in case anyone wants
+         *  to do different PIO/DMA recovery or has per command fixups
+         */
+        if (ap->ops->drain_fifo)
+                ap->ops->drain_fifo(qc);
        spin_unlock_irqrestore(ap->lock, flags);
@@ -2959,4 +3045,3 @@ out:
 EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);
 #endif /* CONFIG_PCI */
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index cea8014cd87e..89a1e0018e71 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -79,8 +79,6 @@ extern int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
                           u64 block, u32 n_block, unsigned int tf_flags,
                           unsigned int tag);
 extern u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev);
-extern void ata_pio_queue_task(struct ata_port *ap, void *data,
-                               unsigned long delay);
 extern void ata_port_flush_task(struct ata_port *ap);
 extern unsigned ata_exec_internal(struct ata_device *dev,
                                  struct ata_taskfile *tf, const u8 *cdb,
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
index 8b77a9802df1..d8f35fe44421 100644
--- a/drivers/ata/pata_acpi.c
+++ b/drivers/ata/pata_acpi.c
@@ -246,9 +246,9 @@ static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = 0x7f,
+                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pacpi_ops,
        };
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index eb99dbe78081..751b7ea4816c 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -492,53 +492,53 @@ static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info_early = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &ali_early_port_ops
        };
        /* Revision 0x20 added DMA */
        static const struct ata_port_info info_20 = {
                .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &ali_20_port_ops
        };
        /* Revision 0x20 with support logic added UDMA */
        static const struct ata_port_info info_20_udma = {
                .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = 0x07,      /* UDMA33 */
+                .udma_mask = ATA_UDMA2,
                .port_ops = &ali_20_port_ops
        };
        /* Revision 0xC2 adds UDMA66 */
        static const struct ata_port_info info_c2 = {
                .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA4,
                .port_ops = &ali_c2_port_ops
        };
        /* Revision 0xC3 is UDMA66 for now */
        static const struct ata_port_info info_c3 = {
                .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA4,
                .port_ops = &ali_c2_port_ops
        };
        /* Revision 0xC4 is UDMA100 */
        static const struct ata_port_info info_c4 = {
                .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &ali_c4_port_ops
        };
        /* Revision 0xC5 is UDMA133 with LBA48 DMA */
        static const struct ata_port_info info_c5 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &ali_c5_port_ops
        };
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 115b1cd6dcf5..33a74f11171c 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -455,74 +455,74 @@ static void amd_clear_fifo(struct pci_dev *pdev)
 static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info[10] = {
-                {       /* 0: AMD 7401 */
+                {       /* 0: AMD 7401 - no swdma */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,     /* No SWDMA */
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = 0x07,      /* UDMA 33 */
+                        .udma_mask = ATA_UDMA2,
                        .port_ops = &amd33_port_ops
                },
                {       /* 1: Early AMD7409 - no swdma */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA4, /* UDMA 66 */
+                        .udma_mask = ATA_UDMA4,
                        .port_ops = &amd66_port_ops
                },
-                {       /* 2: AMD 7409, no swdma errata */
+                {       /* 2: AMD 7409 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA4, /* UDMA 66 */
+                        .udma_mask = ATA_UDMA4,
                        .port_ops = &amd66_port_ops
                },
                {       /* 3: AMD 7411 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA5, /* UDMA 100 */
+                        .udma_mask = ATA_UDMA5,
                        .port_ops = &amd100_port_ops
                },
                {       /* 4: AMD 7441 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA5, /* UDMA 100 */
+                        .udma_mask = ATA_UDMA5,
                        .port_ops = &amd100_port_ops
                },
-                {       /* 5: AMD 8111*/
+                {       /* 5: AMD 8111 - no swdma */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA6, /* UDMA 133, no swdma */
+                        .udma_mask = ATA_UDMA6,
                        .port_ops = &amd133_port_ops
                },
-                {       /* 6: AMD 8111 UDMA 100 (Serenade) */
+                {       /* 6: AMD 8111 UDMA 100 (Serenade) - no swdma */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA5, /* UDMA 100, no swdma */
+                        .udma_mask = ATA_UDMA5,
                        .port_ops = &amd133_port_ops
                },
                {       /* 7: Nvidia Nforce */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA5, /* UDMA 100 */
+                        .udma_mask = ATA_UDMA5,
                        .port_ops = &nv100_port_ops
                },
-                {       /* 8: Nvidia Nforce2 and later */
+                {       /* 8: Nvidia Nforce2 and later - no swdma */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA6, /* UDMA 133, no swdma */
+                        .udma_mask = ATA_UDMA6,
                        .port_ops = &nv133_port_ops
                },
                {       /* 9: AMD CS5536 (Geode companion) */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = ATA_UDMA5, /* UDMA 100 */
+                        .udma_mask = ATA_UDMA5,
                        .port_ops = &amd100_port_ops
                }
        };
diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index 6b3092c75ffe..d332cfdb0f30 100644
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -12,7 +12,6 @@
 *              performance Alessandro Zummo <alessandro.zummo@towertech.it>
 *
 *      TODO
- *      850 serialization once the core supports it
 *      Investigate no_dsc on 850R
 *      Clock detect
 */
@@ -29,7 +28,7 @@
 #include <linux/ata.h>
 #define DRV_NAME        "pata_artop"
-#define DRV_VERSION     "0.4.4"
+#define DRV_VERSION     "0.4.5"
 /*
 *      The ARTOP has 33 Mhz and "over clocked" timing tables. Until we
@@ -283,6 +282,31 @@ static void artop6260_set_dmamode (struct ata_port *ap, struct ata_device *adev)
        pci_write_config_byte(pdev, 0x44 + ap->port_no, ultra);
 }
+/**
+ *      artop_6210_qc_defer     -       implement serialization
+ *      @qc: command
+ *
+ *      Issue commands per host on this chip.
+ */
+static int artop6210_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_host *host = qc->ap->host;
+        struct ata_port *alt = host->ports[1 ^ qc->ap->port_no];
+        int rc;
+        /* First apply the usual rules */
+        rc = ata_std_qc_defer(qc);
+        if (rc != 0)
+                return rc;
+        /* Now apply serialization rules. Only allow a command if the
+           other channel state machine is idle */
+        if (alt && alt->qc_active)
+                return  ATA_DEFER_PORT;
+        return 0;
+}
 static struct scsi_host_template artop_sht = {
        ATA_BMDMA_SHT(DRV_NAME),
 };
@@ -293,6 +317,7 @@ static struct ata_port_operations artop6210_ops = {
        .set_piomode            = artop6210_set_piomode,
        .set_dmamode            = artop6210_set_dmamode,
        .prereset               = artop6210_pre_reset,
+        .qc_defer               = artop6210_qc_defer,
 };
 static struct ata_port_operations artop6260_ops = {
@@ -323,29 +348,29 @@ static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
        static int printed_version;
        static const struct ata_port_info info_6210 = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA2,
                .port_ops       = &artop6210_ops,
        };
        static const struct ata_port_info info_626x = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA4,
                .port_ops       = &artop6260_ops,
        };
        static const struct ata_port_info info_628x = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &artop6260_ops,
        };
        static const struct ata_port_info info_628x_fast = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &artop6260_ops,
        };
@@ -362,12 +387,8 @@ static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
        if (id->driver_data == 0) {     /* 6210 variant */
                ppi[0] = &info_6210;
-                ppi[1] = &ata_dummy_port_info;
                /* BIOS may have left us in UDMA, clear it before libata probe */
                pci_write_config_byte(pdev, 0x54, 0);
-                /* For the moment (also lacks dsc) */
-                printk(KERN_WARNING "ARTOP 6210 requires serialize functionality not yet supported by libata.\n");
-                printk(KERN_WARNING "Secondary ATA ports will not be activated.\n");
        }
        else if (id->driver_data == 1)  /* 6260 */
                ppi[0] = &info_626x;
diff --git a/drivers/ata/pata_at32.c b/drivers/ata/pata_at32.c
index ab61095093b9..5c129f99a7e3 100644
--- a/drivers/ata/pata_at32.c
+++ b/drivers/ata/pata_at32.c
@@ -67,7 +67,9 @@
 *
 * Alter PIO_MASK below according to table to set maximal PIO mode.
 */
-#define PIO_MASK (0x1f)
+enum {
+  PIO_MASK = ATA_PIO4,
+};
 /*
 * Struct containing private information about device.
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 506adde8ebb3..bec0b8ade66d 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -220,9 +220,9 @@ static int atiixp_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x06,     /* No MWDMA0 support */
+                .mwdma_mask = ATA_MWDMA12_ONLY,
-                .udma_mask = 0x3F,
+                .udma_mask = ATA_UDMA5,
                .port_ops = &atiixp_port_ops
        };
        static const struct pci_bits atiixp_enable_bits[] = {
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
index 1050fed96b2b..c4b47a3e5446 100644
--- a/drivers/ata/pata_bf54x.c
+++ b/drivers/ata/pata_bf54x.c
@@ -1502,7 +1502,7 @@ static struct ata_port_info bfin_port_info[] = {
                .flags          = ATA_FLAG_SLAVE_POSS
                                | ATA_FLAG_MMIO
                                | ATA_FLAG_NO_LEGACY,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = 0,
                .udma_mask      = 0,
                .port_ops       = &bfin_pata_ops,
diff --git a/drivers/ata/pata_cmd640.c b/drivers/ata/pata_cmd640.c
index 34a394264c3d..5acf9fa9b39f 100644
--- a/drivers/ata/pata_cmd640.c
+++ b/drivers/ata/pata_cmd640.c
@@ -211,7 +211,7 @@ static int cmd640_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &cmd640_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index 3167d8fed2f2..f98dffedf4bc 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -299,40 +299,40 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        static const struct ata_port_info cmd_info[6] = {
                {       /* CMD 643 - no UDMA */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .port_ops = &cmd64x_port_ops
                },
                {       /* CMD 646 with broken UDMA */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .port_ops = &cmd64x_port_ops
                },
                {       /* CMD 646 with working UDMA */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA2,
                        .port_ops = &cmd64x_port_ops
                },
                {       /* CMD 646 rev 1  */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .port_ops = &cmd646r1_port_ops
                },
                {       /* CMD 648 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA4,
                        .port_ops = &cmd648_port_ops
                },
                {       /* CMD 649 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA5,
                        .port_ops = &cmd648_port_ops
                }
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index 1186bcd2781c..db6a96984f3f 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -158,7 +158,7 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
        static const unsigned int ctl_port[] = { 0x3F6, 0x376 };
        struct ata_port_info pi = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
                .port_ops       = &cs5520_port_ops,
        };
        const struct ata_port_info *ppi[2];
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index bba453381f44..c974b05e4129 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -298,15 +298,15 @@ static int cs5530_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = 0x07,
+                .udma_mask = ATA_UDMA2,
                .port_ops = &cs5530_port_ops
        };
        /* The docking connector doesn't do UDMA, and it seems not MWDMA */
        static const struct ata_port_info info_palmax_secondary = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &cs5530_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index 8b236af84c2e..d33aa28239a9 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -181,8 +181,8 @@ static int cs5535_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA4,
                .port_ops = &cs5535_port_ops
        };
diff --git a/drivers/ata/pata_cs5536.c b/drivers/ata/pata_cs5536.c
index afed92976198..6da4cb486c8d 100644
--- a/drivers/ata/pata_cs5536.c
+++ b/drivers/ata/pata_cs5536.c
@@ -241,8 +241,8 @@ static int cs5536_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &cs5536_port_ops,
        };
diff --git a/drivers/ata/pata_cypress.c b/drivers/ata/pata_cypress.c
index d546425cd380..8fb040bf7361 100644
--- a/drivers/ata/pata_cypress.c
+++ b/drivers/ata/pata_cypress.c
@@ -124,8 +124,8 @@ static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *i
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &cy82c693_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, &ata_dummy_port_info };
diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index ac6392ea35b0..2085e0a3a05a 100644
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -251,9 +251,9 @@ static int efar_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        static int printed_version;
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma1-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = 0x0f, /* UDMA 66 */
+                .udma_mask      = ATA_UDMA4,
                .port_ops       = &efar_ops,
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 65c28e5a6cd7..d7f2da127d13 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -336,8 +336,8 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info_hpt366 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA4,
                .port_ops = &hpt366_port_ops
        };
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index 42163998de9a..81ab57003aba 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -753,55 +753,55 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        /* HPT370 - UDMA100 */
        static const struct ata_port_info info_hpt370 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt370_port_ops
        };
        /* HPT370A - UDMA100 */
        static const struct ata_port_info info_hpt370a = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt370a_port_ops
        };
        /* HPT370 - UDMA100 */
        static const struct ata_port_info info_hpt370_33 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt370_port_ops
        };
        /* HPT370A - UDMA100 */
        static const struct ata_port_info info_hpt370a_33 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt370a_port_ops
        };
        /* HPT371, 372 and friends - UDMA133 */
        static const struct ata_port_info info_hpt372 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &hpt372_port_ops
        };
        /* HPT374 - UDMA100, function 1 uses different prereset method */
        static const struct ata_port_info info_hpt374_fn0 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt372_port_ops
        };
        static const struct ata_port_info info_hpt374_fn1 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &hpt374_fn1_port_ops
        };
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index d5c9fd7b82bb..3d59fe0a408d 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -441,8 +441,8 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        /* HPT372N and friends - UDMA133 */
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &hpt3x2n_port_ops
        };
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index f19cc645881a..7e310253b36b 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -188,11 +188,11 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        static int printed_version;
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
 #if defined(CONFIG_PATA_HPT3X3_DMA)
                /* Further debug needed */
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = 0x07,
+                .udma_mask = ATA_UDMA2,
 #endif
                .port_ops = &hpt3x3_port_ops
        };
diff --git a/drivers/ata/pata_icside.c b/drivers/ata/pata_icside.c
index cf9e9848f8b5..e7347db5b6c4 100644
--- a/drivers/ata/pata_icside.c
+++ b/drivers/ata/pata_icside.c
@@ -297,7 +297,7 @@ static int icside_dma_init(struct pata_icside_info *info)
        if (ec->dma != NO_DMA && !request_dma(ec->dma, DRV_NAME)) {
                state->dma = ec->dma;
-                info->mwdma_mask = 0x07;        /* MW0..2 */
+                info->mwdma_mask = ATA_MWDMA2;
        }
        return 0;
@@ -473,7 +473,7 @@ static int __devinit pata_icside_add_ports(struct pata_icside_info *info)
        for (i = 0; i < info->nr_ports; i++) {
                struct ata_port *ap = host->ports[i];
-                ap->pio_mask = 0x1f;
+                ap->pio_mask = ATA_PIO4;
                ap->mwdma_mask = info->mwdma_mask;
                ap->flags |= ATA_FLAG_SLAVE_POSS;
                ap->ops = &pata_icside_port_ops;
diff --git a/drivers/ata/pata_isapnp.c b/drivers/ata/pata_isapnp.c
index 15cdb9148aab..4bceb8803a10 100644
--- a/drivers/ata/pata_isapnp.c
+++ b/drivers/ata/pata_isapnp.c
@@ -17,7 +17,7 @@
 #include <linux/libata.h>
 #define DRV_NAME "pata_isapnp"
-#define DRV_VERSION "0.2.2"
+#define DRV_VERSION "0.2.5"
 static struct scsi_host_template isapnp_sht = {
        ATA_PIO_SHT(DRV_NAME),
@@ -28,6 +28,13 @@ static struct ata_port_operations isapnp_port_ops = {
        .cable_detect   = ata_cable_40wire,
 };
+static struct ata_port_operations isapnp_noalt_port_ops = {
+        .inherits       = &ata_sff_port_ops,
+        .cable_detect   = ata_cable_40wire,
+        /* No altstatus so we don't want to use the lost interrupt poll */
+        .lost_interrupt = ATA_OP_NULL,
+};
 /**
 *      isapnp_init_one         -       attach an isapnp interface
 *      @idev: PnP device
@@ -65,8 +72,8 @@ static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev
        ap = host->ports[0];
-        ap->ops = &isapnp_port_ops;
+        ap->ops = &isapnp_noalt_port_ops;
-        ap->pio_mask = 1;
+        ap->pio_mask = ATA_PIO0;
        ap->flags |= ATA_FLAG_SLAVE_POSS;
        ap->ioaddr.cmd_addr = cmd_addr;
@@ -76,6 +83,7 @@ static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev
                                           pnp_port_start(idev, 1), 1);
                ap->ioaddr.altstatus_addr = ctl_addr;
                ap->ioaddr.ctl_addr = ctl_addr;
+                ap->ops = &isapnp_port_ops;
        }
        ata_sff_std_ports(&ap->ioaddr);
diff --git a/drivers/ata/pata_it8213.c b/drivers/ata/pata_it8213.c
index c113d7c079c8..f156da8076f7 100644
--- a/drivers/ata/pata_it8213.c
+++ b/drivers/ata/pata_it8213.c
@@ -262,8 +262,8 @@ static int it8213_init_one (struct pci_dev *pdev, const struct pci_device_id *en
        static int printed_version;
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA4, /* FIXME: want UDMA 100? */
                .port_ops       = &it8213_ops,
        };
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index b05b86a912c5..188bc2fcd22c 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -875,29 +875,29 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        static const struct ata_port_info info_smart = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &it821x_smart_port_ops
        };
        static const struct ata_port_info info_passthru = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &it821x_passthru_port_ops
        };
        static const struct ata_port_info info_rdc = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &it821x_rdc_port_ops
        };
        static const struct ata_port_info info_rdc_11 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                /* No UDMA */
                .port_ops = &it821x_rdc_port_ops
        };
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index b173c157ab00..19fdecf319a6 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -176,7 +176,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
        ap = host->ports[0];
        ap->ops = &ixp4xx_port_ops;
-        ap->pio_mask = 0x1f; /* PIO4 */
+        ap->pio_mask = ATA_PIO4;
        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_NO_ATAPI;
        ixp4xx_setup_port(ap, data, cs0->start, cs1->start);
diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index 38cf1ab2d289..3a1474ac8838 100644
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -136,8 +136,8 @@ static int jmicron_init_one (struct pci_dev *pdev, const struct pci_device_id *i
        static const struct ata_port_info info = {
                .flags  = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &jmicron_ops,
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index e3bc1b436284..3f830f0fe2cc 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -129,7 +129,7 @@ static int qdi;			/* Set to probe QDI controllers */
 static int winbond;             /* Set to probe Winbond controllers,
                                        give I/O port if non standard */
 static int autospeed;           /* Chip present which snoops speed changes */
-static int pio_mask = 0x1F;     /* PIO range for autospeed devices */
+static int pio_mask = ATA_PIO4; /* PIO range for autospeed devices */
 static int iordy_mask = 0xFFFFFFFF;     /* Use iordy if available */
 /**
diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index 76e399bf8c1b..2096fb737f82 100644
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -126,8 +126,8 @@ static int marvell_init_one (struct pci_dev *pdev, const struct pci_device_id *i
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &marvell_ops,
@@ -136,8 +136,8 @@ static int marvell_init_one (struct pci_dev *pdev, const struct pci_device_id *i
                /* Slave possible as its magically mapped not real */
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &marvell_ops,
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index 50ae6d13078a..68d27bc70d06 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -737,10 +737,10 @@ mpc52xx_ata_probe(struct of_device *op, const struct of_device_id *match)
         */
        prop = of_get_property(op->node, "mwdma-mode", &proplen);
        if ((prop) && (proplen >= 4))
-                mwdma_mask = 0x7 & ((1 << (*prop + 1)) - 1);
+                mwdma_mask = ATA_MWDMA2 & ((1 << (*prop + 1)) - 1);
        prop = of_get_property(op->node, "udma-mode", &proplen);
        if ((prop) && (proplen >= 4))
-                udma_mask = 0x7 & ((1 << (*prop + 1)) - 1);
+                udma_mask = ATA_UDMA2 & ((1 << (*prop + 1)) - 1);
        ata_irq = irq_of_parse_and_map(op->node, 0);
        if (ata_irq == NO_IRQ) {
diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index aa576cac4d17..b21f0021f54a 100644
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -200,7 +200,7 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
           the MPIIX your box goes castors up */
        ap->ops = &mpiix_port_ops;
-        ap->pio_mask = 0x1F;
+        ap->pio_mask = ATA_PIO4;
        ap->flags |= ATA_FLAG_SLAVE_POSS;
        ap->ioaddr.cmd_addr = cmd_addr;
diff --git a/drivers/ata/pata_netcell.c b/drivers/ata/pata_netcell.c
index 9dc05e1656a8..bdb236957cb9 100644
--- a/drivers/ata/pata_netcell.c
+++ b/drivers/ata/pata_netcell.c
@@ -51,8 +51,8 @@ static int netcell_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                .flags          = ATA_FLAG_SLAVE_POSS,
                /* Actually we don't really care about these as the
                   firmware deals with it */
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5, /* UDMA 133 */
                .port_ops       = &netcell_ops,
        };
diff --git a/drivers/ata/pata_ninja32.c b/drivers/ata/pata_ninja32.c
index 4dd9a3b031e4..0fb6b1b1e634 100644
--- a/drivers/ata/pata_ninja32.c
+++ b/drivers/ata/pata_ninja32.c
@@ -136,7 +136,7 @@ static int ninja32_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        if (!base)
                return -ENOMEM;
        ap->ops = &ninja32_port_ops;
-        ap->pio_mask = 0x1F;
+        ap->pio_mask = ATA_PIO4;
        ap->flags |= ATA_FLAG_SLAVE_POSS;
        ap->ioaddr.cmd_addr = base + 0x10;
diff --git a/drivers/ata/pata_ns87410.c b/drivers/ata/pata_ns87410.c
index 40d411c460de..ca53fac06717 100644
--- a/drivers/ata/pata_ns87410.c
+++ b/drivers/ata/pata_ns87410.c
@@ -144,7 +144,7 @@ static int ns87410_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x0F,
+                .pio_mask = ATA_PIO3,
                .port_ops = &ns87410_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_ns87415.c b/drivers/ata/pata_ns87415.c
index 89bf5f865d6a..773b1590b492 100644
--- a/drivers/ata/pata_ns87415.c
+++ b/drivers/ata/pata_ns87415.c
@@ -346,8 +346,8 @@ static int ns87415_init_one (struct pci_dev *pdev, const struct pci_device_id *e
        static int printed_version;
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .port_ops       = &ns87415_pata_ops,
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
@@ -355,8 +355,8 @@ static int ns87415_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 #if defined(CONFIG_SUPERIO)
        static const struct ata_port_info info87560 = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .port_ops       = &ns87560_pata_ops,
        };
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
index 0fe4ef309c62..efe2c1985af3 100644
--- a/drivers/ata/pata_octeon_cf.c
+++ b/drivers/ata/pata_octeon_cf.c
@@ -871,7 +871,7 @@ static int __devinit octeon_cf_probe(struct platform_device *pdev)
        ap->private_data = cf_port;
        cf_port->ap = ap;
        ap->ops = &octeon_cf_ops;
-        ap->pio_mask = 0x7f; /* Support PIO 0-6 */
+        ap->pio_mask = ATA_PIO6;
        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY
                  | ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING;
@@ -900,7 +900,7 @@ static int __devinit octeon_cf_probe(struct platform_device *pdev)
                ap->ioaddr.ctl_addr     = cs1 + (6 << 1) + 1;
                octeon_cf_ops.sff_data_xfer = octeon_cf_data_xfer16;
-                ap->mwdma_mask  = 0x1f; /* Support MWDMA 0-4 */
+                ap->mwdma_mask  = ATA_MWDMA4;
                irq = platform_get_irq(pdev, 0);
                irq_handler = octeon_cf_interrupt;
diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 2c1a91c40c1a..84ac5033ac89 100644
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -238,8 +238,8 @@ static int oldpiix_init_one (struct pci_dev *pdev, const struct pci_device_id *e
        static int printed_version;
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma1-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .port_ops       = &oldpiix_pata_ops,
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_opti.c b/drivers/ata/pata_opti.c
index e4fa4d565e96..99eddda2d2e5 100644
--- a/drivers/ata/pata_opti.c
+++ b/drivers/ata/pata_opti.c
@@ -163,7 +163,7 @@ static int opti_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &opti_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index 93bb6e91973f..86885a445f97 100644
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -399,15 +399,15 @@ static int optidma_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info_82c700 = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &optidma_port_ops
        };
        static const struct ata_port_info info_82c700_udma = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = 0x07,
+                .udma_mask = ATA_UDMA2,
                .port_ops = &optiplus_port_ops
        };
        const struct ata_port_info *ppi[] = { &info_82c700, NULL };
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index 64b2e2281ee7..f4d009ed50ac 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -42,7 +42,7 @@
 #define DRV_NAME "pata_pcmcia"
-#define DRV_VERSION "0.3.3"
+#define DRV_VERSION "0.3.5"
 /*
 *      Private data structure to glue stuff together
@@ -126,6 +126,37 @@ static unsigned int ata_data_xfer_8bit(struct ata_device *dev,
        return buflen;
 }
+/**
+ *      pcmcia_8bit_drain_fifo - Stock FIFO drain logic for SFF controllers
+ *      @qc: command
+ *
+ *      Drain the FIFO and device of any stuck data following a command
+ *      failing to complete. In some cases this is neccessary before a
+ *      reset will recover the device.
+ *
+ */
+ 
+void pcmcia_8bit_drain_fifo(struct ata_queued_cmd *qc)
+{
+        int count;
+        struct ata_port *ap;
+        /* We only need to flush incoming data when a command was running */
+        if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE)
+                return;
+        ap = qc->ap;
+        /* Drain up to 64K of data before we give up this recovery method */
+        for (count = 0; (ap->ops->sff_check_status(ap) & ATA_DRQ)
+                                                        && count++ < 65536;)
+                ioread8(ap->ioaddr.data_addr);
+        if (count)
+                ata_port_printk(ap, KERN_WARNING, "drained %d bytes to clear DRQ.\n",
+                                                                count);
+}
 static struct scsi_host_template pcmcia_sht = {
        ATA_PIO_SHT(DRV_NAME),
@@ -143,6 +174,7 @@ static struct ata_port_operations pcmcia_8bit_port_ops = {
        .sff_data_xfer  = ata_data_xfer_8bit,
        .cable_detect   = ata_cable_40wire,
        .set_mode       = pcmcia_set_mode_8bit,
+        .drain_fifo     = pcmcia_8bit_drain_fifo,
 };
 #define CS_CHECK(fn, ret) \
@@ -299,7 +331,7 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
                ap = host->ports[p];
                ap->ops = ops;
-                ap->pio_mask = 1;               /* ISA so PIO 0 cycles */
+                ap->pio_mask = ATA_PIO0;        /* ISA so PIO 0 cycles */
                ap->flags |= ATA_FLAG_SLAVE_POSS;
                ap->ioaddr.cmd_addr = io_addr + 0x10 * p;
                ap->ioaddr.altstatus_addr = ctl_addr + 0x10 * p;
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index e94efccaa482..ca5cad0fd80b 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -152,18 +152,18 @@ static struct ata_port_info pdc2027x_port_info[] = {
        {
                .flags          = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
                                  ATA_FLAG_MMIO,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA5, /* udma0-5 */
+                .udma_mask      = ATA_UDMA5,
                .port_ops       = &pdc2027x_pata100_ops,
        },
        /* PDC_UDMA_133 */
        {
                .flags          = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
                                  ATA_FLAG_MMIO,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA6, /* udma0-6 */
+                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc2027x_pata133_ops,
        },
 };
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index 799a6a098712..5fedb3d4032b 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -291,22 +291,22 @@ static int pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id
        static const struct ata_port_info info[3] = {
                {
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA2,
                        .port_ops = &pdc2024x_port_ops
                },
                {
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA4,
                        .port_ops = &pdc2026x_port_ops
                },
                {
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA5,
                        .port_ops = &pdc2026x_port_ops
                }
diff --git a/drivers/ata/pata_qdi.c b/drivers/ata/pata_qdi.c
index f1b26f7c8e4d..45879dc6fa41 100644
--- a/drivers/ata/pata_qdi.c
+++ b/drivers/ata/pata_qdi.c
@@ -212,11 +212,11 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
        if (type == 6580) {
                ap->ops = &qdi6580_port_ops;
-                ap->pio_mask = 0x1F;
+                ap->pio_mask = ATA_PIO4;
                ap->flags |= ATA_FLAG_SLAVE_POSS;
        } else {
                ap->ops = &qdi6500_port_ops;
-                ap->pio_mask = 0x07;    /* Actually PIO3 !IORDY is possible */
+                ap->pio_mask = ATA_PIO2; /* Actually PIO3 !IORDY is possible */
                ap->flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_NO_IORDY;
        }
diff --git a/drivers/ata/pata_radisys.c b/drivers/ata/pata_radisys.c
index 695d44ae52c6..4401b332eaab 100644
--- a/drivers/ata/pata_radisys.c
+++ b/drivers/ata/pata_radisys.c
@@ -216,9 +216,9 @@ static int radisys_init_one (struct pci_dev *pdev, const struct pci_device_id *e
        static int printed_version;
        static const struct ata_port_info info = {
                .flags          = ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma1-2 */
+                .mwdma_mask     = ATA_MWDMA12_ONLY,
-                .udma_mask      = 0x14, /* UDMA33/66 only */
+                .udma_mask      = ATA_UDMA24_ONLY,
                .port_ops       = &radisys_pata_ops,
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_rb532_cf.c b/drivers/ata/pata_rb532_cf.c
index ebfcda26d639..8e3cdef8a25f 100644
--- a/drivers/ata/pata_rb532_cf.c
+++ b/drivers/ata/pata_rb532_cf.c
@@ -48,63 +48,11 @@
 struct rb532_cf_info {
        void __iomem    *iobase;
        unsigned int    gpio_line;
-        int             frozen;
        unsigned int    irq;
 };
 /* ------------------------------------------------------------------------ */
-static inline void rb532_pata_finish_io(struct ata_port *ap)
-{
-        struct ata_host *ah = ap->host;
-        struct rb532_cf_info *info = ah->private_data;
-        /* FIXME: Keep previous delay. If this is merely a fence then
-           ata_sff_sync might be sufficient. */
-        ata_sff_dma_pause(ap);
-        ndelay(RB500_CF_IO_DELAY);
-}
-static void rb532_pata_exec_command(struct ata_port *ap,
-                                const struct ata_taskfile *tf)
-{
-        writeb(tf->command, ap->ioaddr.command_addr);
-        rb532_pata_finish_io(ap);
-}
-static unsigned int rb532_pata_data_xfer(struct ata_device *adev, unsigned char *buf,
-                                unsigned int buflen, int write_data)
-{
-        struct ata_port *ap = adev->link->ap;
-        void __iomem *ioaddr = ap->ioaddr.data_addr;
-        int retlen = buflen;
-        if (write_data) {
-                for (; buflen > 0; buflen--, buf++)
-                        writeb(*buf, ioaddr);
-        } else {
-                for (; buflen > 0; buflen--, buf++)
-                        *buf = readb(ioaddr);
-        }
-        rb532_pata_finish_io(adev->link->ap);
-        return retlen;
-}
-static void rb532_pata_freeze(struct ata_port *ap)
-{
-        struct rb532_cf_info *info = ap->host->private_data;
-        info->frozen = 1;
-}
-static void rb532_pata_thaw(struct ata_port *ap)
-{
-        struct rb532_cf_info *info = ap->host->private_data;
-        info->frozen = 0;
-}
 static irqreturn_t rb532_pata_irq_handler(int irq, void *dev_instance)
 {
        struct ata_host *ah = dev_instance;
@@ -112,8 +60,7 @@ static irqreturn_t rb532_pata_irq_handler(int irq, void *dev_instance)
        if (gpio_get_value(info->gpio_line)) {
                set_irq_type(info->irq, IRQ_TYPE_LEVEL_LOW);
-                if (!info->frozen)
+                ata_sff_interrupt(info->irq, dev_instance);
-                        ata_sff_interrupt(info->irq, dev_instance);
        } else {
                set_irq_type(info->irq, IRQ_TYPE_LEVEL_HIGH);
        }
@@ -123,10 +70,7 @@ static irqreturn_t rb532_pata_irq_handler(int irq, void *dev_instance)
 static struct ata_port_operations rb532_pata_port_ops = {
        .inherits               = &ata_sff_port_ops,
-        .sff_exec_command       = rb532_pata_exec_command,
+        .sff_data_xfer          = ata_sff_data_xfer32,
-        .sff_data_xfer          = rb532_pata_data_xfer,
-        .freeze                 = rb532_pata_freeze,
-        .thaw                   = rb532_pata_thaw,
 };
 /* ------------------------------------------------------------------------ */
@@ -145,7 +89,7 @@ static void rb532_pata_setup_ports(struct ata_host *ah)
        ap = ah->ports[0];
        ap->ops         = &rb532_pata_port_ops;
-        ap->pio_mask    = 0x1f; /* PIO4 */
+        ap->pio_mask    = ATA_PIO4;
        ap->flags       = ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO;
        ap->ioaddr.cmd_addr     = info->iobase + RB500_CF_REG_BASE;
@@ -160,7 +104,7 @@ static void rb532_pata_setup_ports(struct ata_host *ah)
 static __devinit int rb532_pata_driver_probe(struct platform_device *pdev)
 {
-        unsigned int irq;
+        int irq;
        int gpio;
        struct resource *res;
        struct ata_host *ah;
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 46d6bc1bf1e9..0c574c065c62 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -88,7 +88,7 @@ static int rz1000_init_one (struct pci_dev *pdev, const struct pci_device_id *en
        static int printed_version;
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &rz1000_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index 9a4bdca54616..f49814d6fd2e 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -2,7 +2,6 @@
 * New ATA layer SC1200 driver          Alan Cox <alan@lxorguk.ukuu.org.uk>
 *
 * TODO: Mode selection filtering
- * TODO: Can't enable second channel until ATA core has serialize
 * TODO: Needs custom DMA cleanup code
 *
 * Based very heavily on
@@ -178,6 +177,31 @@ static unsigned int sc1200_qc_issue(struct ata_queued_cmd *qc)
        return ata_sff_qc_issue(qc);
 }
+/**
+ *      sc1200_qc_defer -       implement serialization
+ *      @qc: command
+ *
+ *      Serialize command issue on this controller.
+ */
+static int sc1200_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_host *host = qc->ap->host;
+        struct ata_port *alt = host->ports[1 ^ qc->ap->port_no];
+        int rc;
+        /* First apply the usual rules */
+        rc = ata_std_qc_defer(qc);
+        if (rc != 0)
+                return rc;
+        /* Now apply serialization rules. Only allow a command if the
+           other channel state machine is idle */
+        if (alt && alt->qc_active)
+                return  ATA_DEFER_PORT;
+        return 0;
+}
 static struct scsi_host_template sc1200_sht = {
        ATA_BMDMA_SHT(DRV_NAME),
        .sg_tablesize   = LIBATA_DUMB_MAX_PRD,
@@ -187,6 +211,7 @@ static struct ata_port_operations sc1200_port_ops = {
        .inherits       = &ata_bmdma_port_ops,
        .qc_prep        = ata_sff_dumb_qc_prep,
        .qc_issue       = sc1200_qc_issue,
+        .qc_defer       = sc1200_qc_defer,
        .cable_detect   = ata_cable_40wire,
        .set_piomode    = sc1200_set_piomode,
        .set_dmamode    = sc1200_set_dmamode,
@@ -205,13 +230,13 @@ static int sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = 0x07,
+                .udma_mask = ATA_UDMA2,
                .port_ops = &sc1200_port_ops
        };
        /* Can't enable port 2 yet, see top comments */
-        const struct ata_port_info *ppi[] = { &info, &ata_dummy_port_info };
+        const struct ata_port_info *ppi[] = { &info, };
        return ata_pci_sff_init_one(dev, ppi, &sc1200_sht, NULL);
 }
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index d447f1cb46ec..4257d6b40af4 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -1001,8 +1001,8 @@ static struct ata_port_operations scc_pata_ops = {
 static struct ata_port_info scc_port_info[] = {
        {
                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x00,
+                /* No MWDMA */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &scc_pata_ops,
        },
diff --git a/drivers/ata/pata_sch.c b/drivers/ata/pata_sch.c
index 6aeeeeb34124..99cceb458e2a 100644
--- a/drivers/ata/pata_sch.c
+++ b/drivers/ata/pata_sch.c
@@ -84,9 +84,9 @@ static struct ata_port_operations sch_pata_ops = {
 static struct ata_port_info sch_port_info = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = ATA_PIO4,   /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = ATA_MWDMA2, /* mwdma0-2 */
+        .mwdma_mask     = ATA_MWDMA2,
-        .udma_mask      = ATA_UDMA5,  /* udma0-5 */
+        .udma_mask      = ATA_UDMA5,
        .port_ops       = &sch_pata_ops,
 };
diff --git a/drivers/ata/pata_serverworks.c b/drivers/ata/pata_serverworks.c
index 8d2fd9dd40c7..beaed12d50e4 100644
--- a/drivers/ata/pata_serverworks.c
+++ b/drivers/ata/pata_serverworks.c
@@ -398,26 +398,26 @@ static int serverworks_init_one(struct pci_dev *pdev, const struct pci_device_id
        static const struct ata_port_info info[4] = {
                { /* OSB4 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = 0x07,
+                        .udma_mask = ATA_UDMA2,
                        .port_ops = &serverworks_osb4_port_ops
                }, { /* OSB4 no UDMA */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
-                        .udma_mask = 0x00,
+                        /* No UDMA */
                        .port_ops = &serverworks_osb4_port_ops
                }, { /* CSB5 */
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA4,
                        .port_ops = &serverworks_csb_port_ops
                }, { /* CSB5 - later revisions*/
                        .flags = ATA_FLAG_SLAVE_POSS,
-                        .pio_mask = 0x1f,
+                        .pio_mask = ATA_PIO4,
-                        .mwdma_mask = 0x07,
+                        .mwdma_mask = ATA_MWDMA2,
                        .udma_mask = ATA_UDMA5,
                        .port_ops = &serverworks_csb_port_ops
                }
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 9e764e5747e6..4cb649d8d38c 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -282,15 +282,15 @@ static int __devinit sil680_init_one(struct pci_dev *pdev,
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6,
                .port_ops = &sil680_port_ops
        };
        static const struct ata_port_info info_slow = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &sil680_port_ops
        };
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index 27ceb42a774b..488e77bcd22b 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -552,51 +552,57 @@ static struct ata_port_operations sis_old_ops = {
 static const struct ata_port_info sis_info = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x07,
+        .mwdma_mask     = ATA_MWDMA2,
-        .udma_mask      = 0,
+        /* No UDMA */
        .port_ops       = &sis_old_ops,
 };
 static const struct ata_port_info sis_info33 = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x07,
+        .mwdma_mask     = ATA_MWDMA2,
-        .udma_mask      = ATA_UDMA2,    /* UDMA 33 */
+        .udma_mask      = ATA_UDMA2,
        .port_ops       = &sis_old_ops,
 };
 static const struct ata_port_info sis_info66 = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
-        .udma_mask      = ATA_UDMA4,    /* UDMA 66 */
+        /* No MWDMA */
+        .udma_mask      = ATA_UDMA4,
        .port_ops       = &sis_66_ops,
 };
 static const struct ata_port_info sis_info100 = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA5,
        .port_ops       = &sis_100_ops,
 };
 static const struct ata_port_info sis_info100_early = {
        .flags          = ATA_FLAG_SLAVE_POSS,
+        .pio_mask       = ATA_PIO4,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA5,
-        .pio_mask       = 0x1f, /* pio0-4 */
        .port_ops       = &sis_66_ops,
 };
 static const struct ata_port_info sis_info133 = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &sis_133_ops,
 };
 const struct ata_port_info sis_info133_for_sata = {
        .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &sis_133_for_sata_ops,
 };
 static const struct ata_port_info sis_info133_early = {
        .flags          = ATA_FLAG_SLAVE_POSS,
-        .pio_mask       = 0x1f, /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &sis_133_early_ops,
 };
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index 1b0e7b6d8ef5..29f733c32066 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -283,13 +283,13 @@ static int sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id
 {
        static const struct ata_port_info info_dma = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &sl82c105_port_ops
        };
        static const struct ata_port_info info_early = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
                .port_ops = &sl82c105_port_ops
        };
        /* for now use only the first port */
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index ef9597517cdd..f1f13ff222fd 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -191,8 +191,8 @@ static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &triflex_port_ops
        };
        const struct ata_port_info *ppi[] = { &info, NULL };
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index ba556d3e6963..b08e6e0f82b6 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -422,46 +422,46 @@ static int via_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        /* Early VIA without UDMA support */
        static const struct ata_port_info via_mwdma_info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &via_port_ops
        };
        /* Ditto with IRQ masking required */
        static const struct ata_port_info via_mwdma_info_borked = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .port_ops = &via_port_ops_noirq,
        };
        /* VIA UDMA 33 devices (and borked 66) */
        static const struct ata_port_info via_udma33_info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA2,
                .port_ops = &via_port_ops
        };
        /* VIA UDMA 66 devices */
        static const struct ata_port_info via_udma66_info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA4,
                .port_ops = &via_port_ops
        };
        /* VIA UDMA 100 devices */
        static const struct ata_port_info via_udma100_info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA5,
                .port_ops = &via_port_ops
        };
        /* UDMA133 with bad AST (All current 133) */
        static const struct ata_port_info via_udma133_info = {
                .flags = ATA_FLAG_SLAVE_POSS,
-                .pio_mask = 0x1f,
+                .pio_mask = ATA_PIO4,
-                .mwdma_mask = 0x07,
+                .mwdma_mask = ATA_MWDMA2,
                .udma_mask = ATA_UDMA6, /* FIXME: should check north bridge */
                .port_ops = &via_port_ops
        };
diff --git a/drivers/ata/pata_winbond.c b/drivers/ata/pata_winbond.c
index 319e164a3d74..6d8619b6f670 100644
--- a/drivers/ata/pata_winbond.c
+++ b/drivers/ata/pata_winbond.c
@@ -193,7 +193,7 @@ static __init int winbond_init_one(unsigned long port)
                ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", cmd_port, ctl_port);
                ap->ops = &winbond_port_ops;
-                ap->pio_mask = 0x1F;
+                ap->pio_mask = ATA_PIO4;
                ap->flags |= ATA_FLAG_SLAVE_POSS;
                ap->ioaddr.cmd_addr = cmd_addr;
                ap->ioaddr.altstatus_addr = ctl_addr;
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index be53545c9f64..39588178d028 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -148,6 +148,8 @@ static struct scsi_host_template adma_ata_sht = {
 static struct ata_port_operations adma_ata_ops = {
        .inherits               = &ata_sff_port_ops,
+        .lost_interrupt         = ATA_OP_NULL,
        .check_atapi_dma        = adma_check_atapi_dma,
        .qc_prep                = adma_qc_prep,
        .qc_issue               = adma_qc_issue,
@@ -166,7 +168,7 @@ static struct ata_port_info adma_port_info[] = {
                .flags          = ATA_FLAG_SLAVE_POSS |
                                  ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO |
                                  ATA_FLAG_PIO_POLLING,
-                .pio_mask       = 0x10, /* pio4 */
+                .pio_mask       = ATA_PIO4_ONLY,
                .udma_mask      = ATA_UDMA4,
                .port_ops       = &adma_ata_ops,
        },
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 55bc88c1707b..c2e90e1fece0 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1279,8 +1279,8 @@ static struct ata_port_operations sata_fsl_ops = {
 static const struct ata_port_info sata_fsl_port_info[] = {
        {
         .flags = SATA_FSL_HOST_FLAGS,
-         .pio_mask = 0x1f,      /* pio 0-4 */
+         .pio_mask = ATA_PIO4,
-         .udma_mask = 0x7f,     /* udma 0-6 */
+         .udma_mask = ATA_UDMA6,
         .port_ops = &sata_fsl_ops,
         },
 };
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index fbbd87c96f10..305a4f825f53 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -744,8 +744,8 @@ static struct ata_port_operations inic_port_ops = {
 static struct ata_port_info inic_port_info = {
        .flags                  = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA,
-        .pio_mask               = 0x1f, /* pio0-4 */
+        .pio_mask               = ATA_PIO4,
-        .mwdma_mask             = 0x07, /* mwdma0-2 */
+        .mwdma_mask             = ATA_MWDMA2,
        .udma_mask              = ATA_UDMA6,
        .port_ops               = &inic_port_ops
 };
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 74b1080d116d..a377226b81c8 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -1,10 +1,13 @@
 /*
 * sata_mv.c - Marvell SATA support
 *
- * Copyright 2008: Marvell Corporation, all rights reserved.
+ * Copyright 2008-2009: Marvell Corporation, all rights reserved.
 * Copyright 2005: EMC Corporation, all rights reserved.
 * Copyright 2005 Red Hat, Inc.  All rights reserved.
 *
+ * Originally written by Brett Russ.
+ * Extensive overhaul and enhancement by Mark Lord <mlord@pobox.com>.
+ *
 * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
 *
 * This program is free software; you can redistribute it and/or modify
@@ -25,20 +28,13 @@
 /*
 * sata_mv TODO list:
 *
- * --> Errata workaround for NCQ device errors.
- *
 * --> More errata workarounds for PCI-X.
 *
 * --> Complete a full errata audit for all chipsets to identify others.
 *
- * --> ATAPI support (Marvell claims the 60xx/70xx chips can do it).
- *
 * --> Develop a low-power-consumption strategy, and implement it.
 *
- * --> [Experiment, low priority] Investigate interrupt coalescing.
+ * --> Add sysfs attributes for per-chip / per-HC IRQ coalescing thresholds.
- *       Quite often, especially with PCI Message Signalled Interrupts (MSI),
- *       the overhead reduced by interrupt mitigation is quite often not
- *       worth the latency cost.
 *
 * --> [Experiment, Marvell value added] Is it possible to use target
 *       mode to cross-connect two Linux boxes with Marvell cards?  If so,
@@ -68,7 +64,27 @@
 #include <linux/libata.h>
 #define DRV_NAME        "sata_mv"
-#define DRV_VERSION     "1.25"
+#define DRV_VERSION     "1.27"
+/*
+ * module options
+ */
+static int msi;
+#ifdef CONFIG_PCI
+module_param(msi, int, S_IRUGO);
+MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
+#endif
+static int irq_coalescing_io_count;
+module_param(irq_coalescing_io_count, int, S_IRUGO);
+MODULE_PARM_DESC(irq_coalescing_io_count,
+                 "IRQ coalescing I/O count threshold (0..255)");
+static int irq_coalescing_usecs;
+module_param(irq_coalescing_usecs, int, S_IRUGO);
+MODULE_PARM_DESC(irq_coalescing_usecs,
+                 "IRQ coalescing time threshold in usecs");
 enum {
        /* BAR's are enumerated in terms of pci_resource_start() terms */
@@ -79,13 +95,32 @@ enum {
        MV_MAJOR_REG_AREA_SZ    = 0x10000,      /* 64KB */
        MV_MINOR_REG_AREA_SZ    = 0x2000,       /* 8KB */
+        /* For use with both IRQ coalescing methods ("all ports" or "per-HC" */
+        COAL_CLOCKS_PER_USEC    = 150,          /* for calculating COAL_TIMEs */
+        MAX_COAL_TIME_THRESHOLD = ((1 << 24) - 1), /* internal clocks count */
+        MAX_COAL_IO_COUNT       = 255,          /* completed I/O count */
        MV_PCI_REG_BASE         = 0,
-        MV_IRQ_COAL_REG_BASE    = 0x18000,      /* 6xxx part only */
-        MV_IRQ_COAL_CAUSE               = (MV_IRQ_COAL_REG_BASE + 0x08),
+        /*
-        MV_IRQ_COAL_CAUSE_LO            = (MV_IRQ_COAL_REG_BASE + 0x88),
+         * Per-chip ("all ports") interrupt coalescing feature.
-        MV_IRQ_COAL_CAUSE_HI            = (MV_IRQ_COAL_REG_BASE + 0x8c),
+         * This is only for GEN_II / GEN_IIE hardware.
-        MV_IRQ_COAL_THRESHOLD           = (MV_IRQ_COAL_REG_BASE + 0xcc),
+         *
-        MV_IRQ_COAL_TIME_THRESHOLD      = (MV_IRQ_COAL_REG_BASE + 0xd0),
+         * Coalescing defers the interrupt until either the IO_THRESHOLD
+         * (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
+         */
+        MV_COAL_REG_BASE        = 0x18000,
+        MV_IRQ_COAL_CAUSE       = (MV_COAL_REG_BASE + 0x08),
+        ALL_PORTS_COAL_IRQ      = (1 << 4),     /* all ports irq event */
+        MV_IRQ_COAL_IO_THRESHOLD   = (MV_COAL_REG_BASE + 0xcc),
+        MV_IRQ_COAL_TIME_THRESHOLD = (MV_COAL_REG_BASE + 0xd0),
+        /*
+         * Registers for the (unused here) transaction coalescing feature:
+         */
+        MV_TRAN_COAL_CAUSE_LO   = (MV_COAL_REG_BASE + 0x88),
+        MV_TRAN_COAL_CAUSE_HI   = (MV_COAL_REG_BASE + 0x8c),
        MV_SATAHC0_REG_BASE     = 0x20000,
        MV_FLASH_CTL_OFS        = 0x1046c,
@@ -117,17 +152,16 @@ enum {
        /* Host Flags */
        MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
-        MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
        MV_COMMON_FLAGS         = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_NO_ATAPI |
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
-                                  ATA_FLAG_PIO_POLLING,
+        MV_GEN_I_FLAGS          = MV_COMMON_FLAGS | ATA_FLAG_NO_ATAPI,
-        MV_6XXX_FLAGS           = MV_FLAG_IRQ_COALESCE,
+        MV_GEN_II_FLAGS         = MV_COMMON_FLAGS | ATA_FLAG_NCQ |
+                                  ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA,
-        MV_GENIIE_FLAGS         = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
+        MV_GEN_IIE_FLAGS        = MV_GEN_II_FLAGS | ATA_FLAG_AN,
-                                  ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA |
-                                  ATA_FLAG_NCQ | ATA_FLAG_AN,
        CRQB_FLAG_READ          = (1 << 0),
        CRQB_TAG_SHIFT          = 1,
@@ -180,16 +214,18 @@ enum {
        PCI_HC_MAIN_IRQ_MASK_OFS  = 0x1d64,
        SOC_HC_MAIN_IRQ_CAUSE_OFS = 0x20020,
        SOC_HC_MAIN_IRQ_MASK_OFS  = 0x20024,
-        ERR_IRQ                 = (1 << 0),     /* shift by port # */
+        ERR_IRQ                 = (1 << 0),     /* shift by (2 * port #) */
-        DONE_IRQ                = (1 << 1),     /* shift by port # */
+        DONE_IRQ                = (1 << 1),     /* shift by (2 * port #) */
        HC0_IRQ_PEND            = 0x1ff,        /* bits 0-8 = HC0's ports */
        HC_SHIFT                = 9,            /* bits 9-17 = HC1's ports */
+        DONE_IRQ_0_3            = 0x000000aa,   /* DONE_IRQ ports 0,1,2,3 */
+        DONE_IRQ_4_7            = (DONE_IRQ_0_3 << HC_SHIFT),  /* 4,5,6,7 */
        PCI_ERR                 = (1 << 18),
-        TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
+        TRAN_COAL_LO_DONE       = (1 << 19),    /* transaction coalescing */
-        TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
+        TRAN_COAL_HI_DONE       = (1 << 20),    /* transaction coalescing */
-        PORTS_0_3_COAL_DONE     = (1 << 8),
+        PORTS_0_3_COAL_DONE     = (1 << 8),     /* HC0 IRQ coalescing */
-        PORTS_4_7_COAL_DONE     = (1 << 17),
+        PORTS_4_7_COAL_DONE     = (1 << 17),    /* HC1 IRQ coalescing */
-        PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
+        ALL_PORTS_COAL_DONE     = (1 << 21),    /* GEN_II(E) IRQ coalescing */
        GPIO_INT                = (1 << 22),
        SELF_INT                = (1 << 23),
        TWSI_INT                = (1 << 24),
@@ -205,6 +241,21 @@ enum {
        HC_COAL_IRQ             = (1 << 4),     /* IRQ coalescing */
        DEV_IRQ                 = (1 << 8),     /* shift by port # */
+        /*
+         * Per-HC (Host-Controller) interrupt coalescing feature.
+         * This is present on all chip generations.
+         *
+         * Coalescing defers the interrupt until either the IO_THRESHOLD
+         * (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
+         */
+        HC_IRQ_COAL_IO_THRESHOLD_OFS    = 0x000c,
+        HC_IRQ_COAL_TIME_THRESHOLD_OFS  = 0x0010,
+        SOC_LED_CTRL_OFS        = 0x2c,
+        SOC_LED_CTRL_BLINK      = (1 << 0),     /* Active LED blink */
+        SOC_LED_CTRL_ACT_PRESENCE = (1 << 2),   /* Multiplex dev presence */
+                                                /*  with dev activity LED */
        /* Shadow block registers */
        SHD_BLK_OFS             = 0x100,
        SHD_CTL_AST_OFS         = 0x20,         /* ofs from SHD_BLK_OFS */
@@ -346,6 +397,12 @@ enum {
        EDMA_ARB_CFG_OFS        = 0x38,
        EDMA_HALTCOND_OFS       = 0x60,         /* GenIIe halt conditions */
+        EDMA_UNKNOWN_RSVD_OFS   = 0x6C,         /* GenIIe unknown/reserved */
+        BMDMA_CMD_OFS           = 0x224,        /* bmdma command register */
+        BMDMA_STATUS_OFS        = 0x228,        /* bmdma status register */
+        BMDMA_PRD_LOW_OFS       = 0x22c,        /* bmdma PRD addr 31:0 */
+        BMDMA_PRD_HIGH_OFS      = 0x230,        /* bmdma PRD addr 63:32 */
        /* Host private flags (hp_flags) */
        MV_HP_FLAG_MSI          = (1 << 0),
@@ -359,12 +416,14 @@ enum {
        MV_HP_PCIE              = (1 << 9),     /* PCIe bus/regs: 7042 */
        MV_HP_CUT_THROUGH       = (1 << 10),    /* can use EDMA cut-through */
        MV_HP_FLAG_SOC          = (1 << 11),    /* SystemOnChip, no PCI */
+        MV_HP_QUIRK_LED_BLINK_EN = (1 << 12),   /* is led blinking enabled? */
        /* Port private flags (pp_flags) */
        MV_PP_FLAG_EDMA_EN      = (1 << 0),     /* is EDMA engine enabled? */
        MV_PP_FLAG_NCQ_EN       = (1 << 1),     /* is EDMA set up for NCQ? */
        MV_PP_FLAG_FBS_EN       = (1 << 2),     /* is EDMA set up for FBS? */
        MV_PP_FLAG_DELAYED_EH   = (1 << 3),     /* delayed dev err handling */
+        MV_PP_FLAG_FAKE_ATA_BUSY = (1 << 4),    /* ignore initial ATA_DRDY */
 };
 #define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
@@ -433,6 +492,18 @@ struct mv_sg {
        __le32                  reserved;
 };
+/*
+ * We keep a local cache of a few frequently accessed port
+ * registers here, to avoid having to read them (very slow)
+ * when switching between EDMA and non-EDMA modes.
+ */
+struct mv_cached_regs {
+        u32                     fiscfg;
+        u32                     ltmode;
+        u32                     haltcond;
+        u32                     unknown_rsvd;
+};
 struct mv_port_priv {
        struct mv_crqb          *crqb;
        dma_addr_t              crqb_dma;
@@ -445,6 +516,7 @@ struct mv_port_priv {
        unsigned int            resp_idx;
        u32                     pp_flags;
+        struct mv_cached_regs   cached;
        unsigned int            delayed_eh_pmp_map;
 };
@@ -535,7 +607,7 @@ static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
                             unsigned int port_no);
 static int mv_stop_edma(struct ata_port *ap);
 static int mv_stop_edma_engine(void __iomem *port_mmio);
-static void mv_edma_cfg(struct ata_port *ap, int want_ncq);
+static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma);
 static void mv_pmp_select(struct ata_port *ap, int pmp);
 static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
@@ -546,6 +618,14 @@ static void mv_pmp_error_handler(struct ata_port *ap);
 static void mv_process_crpb_entries(struct ata_port *ap,
                                        struct mv_port_priv *pp);
+static void mv_sff_irq_clear(struct ata_port *ap);
+static int mv_check_atapi_dma(struct ata_queued_cmd *qc);
+static void mv_bmdma_setup(struct ata_queued_cmd *qc);
+static void mv_bmdma_start(struct ata_queued_cmd *qc);
+static void mv_bmdma_stop(struct ata_queued_cmd *qc);
+static u8   mv_bmdma_status(struct ata_port *ap);
+static u8 mv_sff_check_status(struct ata_port *ap);
 /* .sg_tablesize is (MV_MAX_SG_CT / 2) in the structures below
 * because we have to allow room for worst case splitting of
 * PRDs for 64K boundaries in mv_fill_sg().
@@ -566,6 +646,8 @@ static struct scsi_host_template mv6_sht = {
 static struct ata_port_operations mv5_ops = {
        .inherits               = &ata_sff_port_ops,
+        .lost_interrupt         = ATA_OP_NULL,
        .qc_defer               = mv_qc_defer,
        .qc_prep                = mv_qc_prep,
        .qc_issue               = mv_qc_issue,
@@ -593,6 +675,14 @@ static struct ata_port_operations mv6_ops = {
        .pmp_softreset          = mv_softreset,
        .softreset              = mv_softreset,
        .error_handler          = mv_pmp_error_handler,
+        .sff_check_status       = mv_sff_check_status,
+        .sff_irq_clear          = mv_sff_irq_clear,
+        .check_atapi_dma        = mv_check_atapi_dma,
+        .bmdma_setup            = mv_bmdma_setup,
+        .bmdma_start            = mv_bmdma_start,
+        .bmdma_stop             = mv_bmdma_stop,
+        .bmdma_status           = mv_bmdma_status,
 };
 static struct ata_port_operations mv_iie_ops = {
@@ -603,53 +693,49 @@ static struct ata_port_operations mv_iie_ops = {
 static const struct ata_port_info mv_port_info[] = {
        {  /* chip_504x */
-                .flags          = MV_COMMON_FLAGS,
+                .flags          = MV_GEN_I_FLAGS,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv5_ops,
        },
        {  /* chip_508x */
-                .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
+                .flags          = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv5_ops,
        },
        {  /* chip_5080 */
-                .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
+                .flags          = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv5_ops,
        },
        {  /* chip_604x */
-                .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
+                .flags          = MV_GEN_II_FLAGS,
-                                  ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA |
-                                  ATA_FLAG_NCQ,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv6_ops,
        },
        {  /* chip_608x */
-                .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
+                .flags          = MV_GEN_II_FLAGS | MV_FLAG_DUAL_HC,
-                                  ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA |
-                                  ATA_FLAG_NCQ | MV_FLAG_DUAL_HC,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv6_ops,
        },
        {  /* chip_6042 */
-                .flags          = MV_GENIIE_FLAGS,
+                .flags          = MV_GEN_IIE_FLAGS,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv_iie_ops,
        },
        {  /* chip_7042 */
-                .flags          = MV_GENIIE_FLAGS,
+                .flags          = MV_GEN_IIE_FLAGS,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv_iie_ops,
        },
        {  /* chip_soc */
-                .flags          = MV_GENIIE_FLAGS,
+                .flags          = MV_GEN_IIE_FLAGS,
                .pio_mask       = 0x1f, /* pio0-4 */
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &mv_iie_ops,
@@ -794,6 +880,44 @@ static inline int mv_get_hc_count(unsigned long port_flags)
        return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
 }
+/**
+ *      mv_save_cached_regs - (re-)initialize cached port registers
+ *      @ap: the port whose registers we are caching
+ *
+ *      Initialize the local cache of port registers,
+ *      so that reading them over and over again can
+ *      be avoided on the hotter paths of this driver.
+ *      This saves a few microseconds each time we switch
+ *      to/from EDMA mode to perform (eg.) a drive cache flush.
+ */
+static void mv_save_cached_regs(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        struct mv_port_priv *pp = ap->private_data;
+        pp->cached.fiscfg = readl(port_mmio + FISCFG_OFS);
+        pp->cached.ltmode = readl(port_mmio + LTMODE_OFS);
+        pp->cached.haltcond = readl(port_mmio + EDMA_HALTCOND_OFS);
+        pp->cached.unknown_rsvd = readl(port_mmio + EDMA_UNKNOWN_RSVD_OFS);
+}
+/**
+ *      mv_write_cached_reg - write to a cached port register
+ *      @addr: hardware address of the register
+ *      @old: pointer to cached value of the register
+ *      @new: new value for the register
+ *
+ *      Write a new value to a cached register,
+ *      but only if the value is different from before.
+ */
+static inline void mv_write_cached_reg(void __iomem *addr, u32 *old, u32 new)
+{
+        if (new != *old) {
+                *old = new;
+                writel(new, addr);
+        }
+}
 static void mv_set_edma_ptrs(void __iomem *port_mmio,
                             struct mv_host_priv *hpriv,
                             struct mv_port_priv *pp)
@@ -825,6 +949,23 @@ static void mv_set_edma_ptrs(void __iomem *port_mmio,
                 port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
 }
+static void mv_write_main_irq_mask(u32 mask, struct mv_host_priv *hpriv)
+{
+        /*
+         * When writing to the main_irq_mask in hardware,
+         * we must ensure exclusivity between the interrupt coalescing bits
+         * and the corresponding individual port DONE_IRQ bits.
+         *
+         * Note that this register is really an "IRQ enable" register,
+         * not an "IRQ mask" register as Marvell's naming might suggest.
+         */
+        if (mask & (ALL_PORTS_COAL_DONE | PORTS_0_3_COAL_DONE))
+                mask &= ~DONE_IRQ_0_3;
+        if (mask & (ALL_PORTS_COAL_DONE | PORTS_4_7_COAL_DONE))
+                mask &= ~DONE_IRQ_4_7;
+        writelfl(mask, hpriv->main_irq_mask_addr);
+}
 static void mv_set_main_irq_mask(struct ata_host *host,
                                 u32 disable_bits, u32 enable_bits)
 {
@@ -835,7 +976,7 @@ static void mv_set_main_irq_mask(struct ata_host *host,
        new_mask = (old_mask & ~disable_bits) | enable_bits;
        if (new_mask != old_mask) {
                hpriv->main_irq_mask = new_mask;
-                writelfl(new_mask, hpriv->main_irq_mask_addr);
+                mv_write_main_irq_mask(new_mask, hpriv);
        }
 }
@@ -852,8 +993,94 @@ static void mv_enable_port_irqs(struct ata_port *ap,
        mv_set_main_irq_mask(ap->host, disable_bits, enable_bits);
 }
+static void mv_clear_and_enable_port_irqs(struct ata_port *ap,
+                                          void __iomem *port_mmio,
+                                          unsigned int port_irqs)
+{
+        struct mv_host_priv *hpriv = ap->host->private_data;
+        int hardport = mv_hardport_from_port(ap->port_no);
+        void __iomem *hc_mmio = mv_hc_base_from_port(
+                                mv_host_base(ap->host), ap->port_no);
+        u32 hc_irq_cause;
+        /* clear EDMA event indicators, if any */
+        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+        /* clear pending irq events */
+        hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
+        writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
+        /* clear FIS IRQ Cause */
+        if (IS_GEN_IIE(hpriv))
+                writelfl(0, port_mmio + SATA_FIS_IRQ_CAUSE_OFS);
+        mv_enable_port_irqs(ap, port_irqs);
+}
+static void mv_set_irq_coalescing(struct ata_host *host,
+                                  unsigned int count, unsigned int usecs)
+{
+        struct mv_host_priv *hpriv = host->private_data;
+        void __iomem *mmio = hpriv->base, *hc_mmio;
+        u32 coal_enable = 0;
+        unsigned long flags;
+        unsigned int clks, is_dual_hc = hpriv->n_ports > MV_PORTS_PER_HC;
+        const u32 coal_disable = PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
+                                                        ALL_PORTS_COAL_DONE;
+        /* Disable IRQ coalescing if either threshold is zero */
+        if (!usecs || !count) {
+                clks = count = 0;
+        } else {
+                /* Respect maximum limits of the hardware */
+                clks = usecs * COAL_CLOCKS_PER_USEC;
+                if (clks > MAX_COAL_TIME_THRESHOLD)
+                        clks = MAX_COAL_TIME_THRESHOLD;
+                if (count > MAX_COAL_IO_COUNT)
+                        count = MAX_COAL_IO_COUNT;
+        }
+        spin_lock_irqsave(&host->lock, flags);
+        mv_set_main_irq_mask(host, coal_disable, 0);
+        if (is_dual_hc && !IS_GEN_I(hpriv)) {
+                /*
+                 * GEN_II/GEN_IIE with dual host controllers:
+                 * one set of global thresholds for the entire chip.
+                 */
+                writel(clks,  mmio + MV_IRQ_COAL_TIME_THRESHOLD);
+                writel(count, mmio + MV_IRQ_COAL_IO_THRESHOLD);
+                /* clear leftover coal IRQ bit */
+                writel(~ALL_PORTS_COAL_IRQ, mmio + MV_IRQ_COAL_CAUSE);
+                if (count)
+                        coal_enable = ALL_PORTS_COAL_DONE;
+                clks = count = 0; /* force clearing of regular regs below */
+        }
+        /*
+         * All chips: independent thresholds for each HC on the chip.
+         */
+        hc_mmio = mv_hc_base_from_port(mmio, 0);
+        writel(clks,  hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD_OFS);
+        writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD_OFS);
+        writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE_OFS);
+        if (count)
+                coal_enable |= PORTS_0_3_COAL_DONE;
+        if (is_dual_hc) {
+                hc_mmio = mv_hc_base_from_port(mmio, MV_PORTS_PER_HC);
+                writel(clks,  hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD_OFS);
+                writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD_OFS);
+                writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE_OFS);
+                if (count)
+                        coal_enable |= PORTS_4_7_COAL_DONE;
+        }
+        mv_set_main_irq_mask(host, 0, coal_enable);
+        spin_unlock_irqrestore(&host->lock, flags);
+}
 /**
- *      mv_start_dma - Enable eDMA engine
+ *      mv_start_edma - Enable eDMA engine
 *      @base: port base address
 *      @pp: port private data
 *
@@ -863,7 +1090,7 @@ static void mv_enable_port_irqs(struct ata_port *ap,
 *      LOCKING:
 *      Inherited from caller.
 */
-static void mv_start_dma(struct ata_port *ap, void __iomem *port_mmio,
+static void mv_start_edma(struct ata_port *ap, void __iomem *port_mmio,
                         struct mv_port_priv *pp, u8 protocol)
 {
        int want_ncq = (protocol == ATA_PROT_NCQ);
@@ -875,26 +1102,11 @@ static void mv_start_dma(struct ata_port *ap, void __iomem *port_mmio,
        }
        if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
                struct mv_host_priv *hpriv = ap->host->private_data;
-                int hardport = mv_hardport_from_port(ap->port_no);
-                void __iomem *hc_mmio = mv_hc_base_from_port(
-                                        mv_host_base(ap->host), ap->port_no);
-                u32 hc_irq_cause;
-                /* clear EDMA event indicators, if any */
-                writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
-                /* clear pending irq events */
+                mv_edma_cfg(ap, want_ncq, 1);
-                hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
-                writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
-                mv_edma_cfg(ap, want_ncq);
-                /* clear FIS IRQ Cause */
-                if (IS_GEN_IIE(hpriv))
-                        writelfl(0, port_mmio + SATA_FIS_IRQ_CAUSE_OFS);
                mv_set_edma_ptrs(port_mmio, hpriv, pp);
-                mv_enable_port_irqs(ap, DONE_IRQ|ERR_IRQ);
+                mv_clear_and_enable_port_irqs(ap, port_mmio, DONE_IRQ|ERR_IRQ);
                writelfl(EDMA_EN, port_mmio + EDMA_CMD_OFS);
                pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
@@ -952,6 +1164,7 @@ static int mv_stop_edma(struct ata_port *ap)
 {
        void __iomem *port_mmio = mv_ap_base(ap);
        struct mv_port_priv *pp = ap->private_data;
+        int err = 0;
        if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
                return 0;
@@ -959,9 +1172,10 @@ static int mv_stop_edma(struct ata_port *ap)
        mv_wait_for_edma_empty_idle(ap);
        if (mv_stop_edma_engine(port_mmio)) {
                ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
-                return -EIO;
+                err = -EIO;
        }
-        return 0;
+        mv_edma_cfg(ap, 0, 0);
+        return err;
 }
 #ifdef ATA_DEBUG
@@ -1130,35 +1344,33 @@ static int mv_qc_defer(struct ata_queued_cmd *qc)
        return ATA_DEFER_PORT;
 }
-static void mv_config_fbs(void __iomem *port_mmio, int want_ncq, int want_fbs)
+static void mv_config_fbs(struct ata_port *ap, int want_ncq, int want_fbs)
 {
-        u32 new_fiscfg, old_fiscfg;
+        struct mv_port_priv *pp = ap->private_data;
-        u32 new_ltmode, old_ltmode;
+        void __iomem *port_mmio;
-        u32 new_haltcond, old_haltcond;
-        old_fiscfg   = readl(port_mmio + FISCFG_OFS);
+        u32 fiscfg,   *old_fiscfg   = &pp->cached.fiscfg;
-        old_ltmode   = readl(port_mmio + LTMODE_OFS);
+        u32 ltmode,   *old_ltmode   = &pp->cached.ltmode;
-        old_haltcond = readl(port_mmio + EDMA_HALTCOND_OFS);
+        u32 haltcond, *old_haltcond = &pp->cached.haltcond;
-        new_fiscfg   = old_fiscfg & ~(FISCFG_SINGLE_SYNC | FISCFG_WAIT_DEV_ERR);
+        ltmode   = *old_ltmode & ~LTMODE_BIT8;
-        new_ltmode   = old_ltmode & ~LTMODE_BIT8;
+        haltcond = *old_haltcond | EDMA_ERR_DEV;
-        new_haltcond = old_haltcond | EDMA_ERR_DEV;
        if (want_fbs) {
-                new_fiscfg = old_fiscfg | FISCFG_SINGLE_SYNC;
+                fiscfg = *old_fiscfg | FISCFG_SINGLE_SYNC;
-                new_ltmode = old_ltmode | LTMODE_BIT8;
+                ltmode = *old_ltmode | LTMODE_BIT8;
                if (want_ncq)
-                        new_haltcond &= ~EDMA_ERR_DEV;
+                        haltcond &= ~EDMA_ERR_DEV;
                else
-                        new_fiscfg |=  FISCFG_WAIT_DEV_ERR;
+                        fiscfg |=  FISCFG_WAIT_DEV_ERR;
+        } else {
+                fiscfg = *old_fiscfg & ~(FISCFG_SINGLE_SYNC | FISCFG_WAIT_DEV_ERR);
        }
-        if (new_fiscfg != old_fiscfg)
+        port_mmio = mv_ap_base(ap);
-                writelfl(new_fiscfg, port_mmio + FISCFG_OFS);
+        mv_write_cached_reg(port_mmio + FISCFG_OFS, old_fiscfg, fiscfg);
-        if (new_ltmode != old_ltmode)
+        mv_write_cached_reg(port_mmio + LTMODE_OFS, old_ltmode, ltmode);
-                writelfl(new_ltmode, port_mmio + LTMODE_OFS);
+        mv_write_cached_reg(port_mmio + EDMA_HALTCOND_OFS, old_haltcond, haltcond);
-        if (new_haltcond != old_haltcond)
-                writelfl(new_haltcond, port_mmio + EDMA_HALTCOND_OFS);
 }
 static void mv_60x1_errata_sata25(struct ata_port *ap, int want_ncq)
@@ -1176,7 +1388,86 @@ static void mv_60x1_errata_sata25(struct ata_port *ap, int want_ncq)
                writel(new, hpriv->base + MV_GPIO_PORT_CTL_OFS);
 }
-static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
+/**
+ *      mv_bmdma_enable - set a magic bit on GEN_IIE to allow bmdma
+ *      @ap: Port being initialized
+ *
+ *      There are two DMA modes on these chips:  basic DMA, and EDMA.
+ *
+ *      Bit-0 of the "EDMA RESERVED" register enables/disables use
+ *      of basic DMA on the GEN_IIE versions of the chips.
+ *
+ *      This bit survives EDMA resets, and must be set for basic DMA
+ *      to function, and should be cleared when EDMA is active.
+ */
+static void mv_bmdma_enable_iie(struct ata_port *ap, int enable_bmdma)
+{
+        struct mv_port_priv *pp = ap->private_data;
+        u32 new, *old = &pp->cached.unknown_rsvd;
+        if (enable_bmdma)
+                new = *old | 1;
+        else
+                new = *old & ~1;
+        mv_write_cached_reg(mv_ap_base(ap) + EDMA_UNKNOWN_RSVD_OFS, old, new);
+}
+/*
+ * SOC chips have an issue whereby the HDD LEDs don't always blink
+ * during I/O when NCQ is enabled. Enabling a special "LED blink" mode
+ * of the SOC takes care of it, generating a steady blink rate when
+ * any drive on the chip is active.
+ *
+ * Unfortunately, the blink mode is a global hardware setting for the SOC,
+ * so we must use it whenever at least one port on the SOC has NCQ enabled.
+ *
+ * We turn "LED blink" off when NCQ is not in use anywhere, because the normal
+ * LED operation works then, and provides better (more accurate) feedback.
+ *
+ * Note that this code assumes that an SOC never has more than one HC onboard.
+ */
+static void mv_soc_led_blink_enable(struct ata_port *ap)
+{
+        struct ata_host *host = ap->host;
+        struct mv_host_priv *hpriv = host->private_data;
+        void __iomem *hc_mmio;
+        u32 led_ctrl;
+        if (hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN)
+                return;
+        hpriv->hp_flags |= MV_HP_QUIRK_LED_BLINK_EN;
+        hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
+        led_ctrl = readl(hc_mmio + SOC_LED_CTRL_OFS);
+        writel(led_ctrl | SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL_OFS);
+}
+static void mv_soc_led_blink_disable(struct ata_port *ap)
+{
+        struct ata_host *host = ap->host;
+        struct mv_host_priv *hpriv = host->private_data;
+        void __iomem *hc_mmio;
+        u32 led_ctrl;
+        unsigned int port;
+        if (!(hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN))
+                return;
+        /* disable led-blink only if no ports are using NCQ */
+        for (port = 0; port < hpriv->n_ports; port++) {
+                struct ata_port *this_ap = host->ports[port];
+                struct mv_port_priv *pp = this_ap->private_data;
+                if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
+                        return;
+        }
+        hpriv->hp_flags &= ~MV_HP_QUIRK_LED_BLINK_EN;
+        hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
+        led_ctrl = readl(hc_mmio + SOC_LED_CTRL_OFS);
+        writel(led_ctrl & ~SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL_OFS);
+}
+static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma)
 {
        u32 cfg;
        struct mv_port_priv *pp    = ap->private_data;
@@ -1185,7 +1476,8 @@ static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
        /* set up non-NCQ EDMA configuration */
        cfg = EDMA_CFG_Q_DEPTH;         /* always 0x1f for *all* chips */
-        pp->pp_flags &= ~MV_PP_FLAG_FBS_EN;
+        pp->pp_flags &=
+          ~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
        if (IS_GEN_I(hpriv))
                cfg |= (1 << 8);        /* enab config burst size mask */
@@ -1206,7 +1498,7 @@ static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
                 */
                want_fbs &= want_ncq;
-                mv_config_fbs(port_mmio, want_ncq, want_fbs);
+                mv_config_fbs(ap, want_ncq, want_fbs);
                if (want_fbs) {
                        pp->pp_flags |= MV_PP_FLAG_FBS_EN;
@@ -1214,18 +1506,27 @@ static void mv_edma_cfg(struct ata_port *ap, int want_ncq)
                }
                cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
-                cfg |= (1 << 22);       /* enab 4-entry host queue cache */
+                if (want_edma) {
-                if (!IS_SOC(hpriv))
+                        cfg |= (1 << 22); /* enab 4-entry host queue cache */
-                        cfg |= (1 << 18);       /* enab early completion */
+                        if (!IS_SOC(hpriv))
+                                cfg |= (1 << 18); /* enab early completion */
+                }
                if (hpriv->hp_flags & MV_HP_CUT_THROUGH)
                        cfg |= (1 << 17); /* enab cut-thru (dis stor&forwrd) */
+                mv_bmdma_enable_iie(ap, !want_edma);
+                if (IS_SOC(hpriv)) {
+                        if (want_ncq)
+                                mv_soc_led_blink_enable(ap);
+                        else
+                                mv_soc_led_blink_disable(ap);
+                }
        }
        if (want_ncq) {
                cfg |= EDMA_CFG_NCQ;
                pp->pp_flags |=  MV_PP_FLAG_NCQ_EN;
-        } else
+        }
-                pp->pp_flags &= ~MV_PP_FLAG_NCQ_EN;
        writelfl(cfg, port_mmio + EDMA_CFG_OFS);
 }
@@ -1309,6 +1610,8 @@ static int mv_port_start(struct ata_port *ap)
                        pp->sg_tbl_dma[tag] = pp->sg_tbl_dma[0];
                }
        }
+        mv_save_cached_regs(ap);
+        mv_edma_cfg(ap, 0, 0);
        return 0;
 out_port_free_dma_mem:
@@ -1357,12 +1660,13 @@ static void mv_fill_sg(struct ata_queued_cmd *qc)
                        u32 offset = addr & 0xffff;
                        u32 len = sg_len;
-                        if ((offset + sg_len > 0x10000))
+                        if (offset + len > 0x10000)
                                len = 0x10000 - offset;
                        mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
                        mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
                        mv_sg->flags_size = cpu_to_le32(len & 0xffff);
+                        mv_sg->reserved = 0;
                        sg_len -= len;
                        addr += len;
@@ -1374,6 +1678,7 @@ static void mv_fill_sg(struct ata_queued_cmd *qc)
        if (likely(last_sg))
                last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
+        mb(); /* ensure data structure is visible to the chipset */
 }
 static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
@@ -1384,6 +1689,147 @@ static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
 }
 /**
+ *      mv_sff_irq_clear - Clear hardware interrupt after DMA.
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      We need this only for ATAPI bmdma transactions,
+ *      as otherwise we experience spurious interrupts
+ *      after libata-sff handles the bmdma interrupts.
+ */
+static void mv_sff_irq_clear(struct ata_port *ap)
+{
+        mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), ERR_IRQ);
+}
+/**
+ *      mv_check_atapi_dma - Filter ATAPI cmds which are unsuitable for DMA.
+ *      @qc: queued command to check for chipset/DMA compatibility.
+ *
+ *      The bmdma engines cannot handle speculative data sizes
+ *      (bytecount under/over flow).  So only allow DMA for
+ *      data transfer commands with known data sizes.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static int mv_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        struct scsi_cmnd *scmd = qc->scsicmd;
+        if (scmd) {
+                switch (scmd->cmnd[0]) {
+                case READ_6:
+                case READ_10:
+                case READ_12:
+                case WRITE_6:
+                case WRITE_10:
+                case WRITE_12:
+                case GPCMD_READ_CD:
+                case GPCMD_SEND_DVD_STRUCTURE:
+                case GPCMD_SEND_CUE_SHEET:
+                        return 0; /* DMA is safe */
+                }
+        }
+        return -EOPNOTSUPP; /* use PIO instead */
+}
+/**
+ *      mv_bmdma_setup - Set up BMDMA transaction
+ *      @qc: queued command to prepare DMA for.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_bmdma_setup(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *port_mmio = mv_ap_base(ap);
+        struct mv_port_priv *pp = ap->private_data;
+        mv_fill_sg(qc);
+        /* clear all DMA cmd bits */
+        writel(0, port_mmio + BMDMA_CMD_OFS);
+        /* load PRD table addr. */
+        writel((pp->sg_tbl_dma[qc->tag] >> 16) >> 16,
+                port_mmio + BMDMA_PRD_HIGH_OFS);
+        writelfl(pp->sg_tbl_dma[qc->tag],
+                port_mmio + BMDMA_PRD_LOW_OFS);
+        /* issue r/w command */
+        ap->ops->sff_exec_command(ap, &qc->tf);
+}
+/**
+ *      mv_bmdma_start - Start a BMDMA transaction
+ *      @qc: queued command to start DMA on.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_bmdma_start(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *port_mmio = mv_ap_base(ap);
+        unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
+        u32 cmd = (rw ? 0 : ATA_DMA_WR) | ATA_DMA_START;
+        /* start host DMA transaction */
+        writelfl(cmd, port_mmio + BMDMA_CMD_OFS);
+}
+/**
+ *      mv_bmdma_stop - Stop BMDMA transfer
+ *      @qc: queued command to stop DMA on.
+ *
+ *      Clears the ATA_DMA_START flag in the bmdma control register
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_bmdma_stop(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *port_mmio = mv_ap_base(ap);
+        u32 cmd;
+        /* clear start/stop bit */
+        cmd = readl(port_mmio + BMDMA_CMD_OFS);
+        cmd &= ~ATA_DMA_START;
+        writelfl(cmd, port_mmio + BMDMA_CMD_OFS);
+        /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
+        ata_sff_dma_pause(ap);
+}
+/**
+ *      mv_bmdma_status - Read BMDMA status
+ *      @ap: port for which to retrieve DMA status.
+ *
+ *      Read and return equivalent of the sff BMDMA status register.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static u8 mv_bmdma_status(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        u32 reg, status;
+        /*
+         * Other bits are valid only if ATA_DMA_ACTIVE==0,
+         * and the ATA_DMA_INTR bit doesn't exist.
+         */
+        reg = readl(port_mmio + BMDMA_STATUS_OFS);
+        if (reg & ATA_DMA_ACTIVE)
+                status = ATA_DMA_ACTIVE;
+        else
+                status = (reg & ATA_DMA_ERR) | ATA_DMA_INTR;
+        return status;
+}
+/**
 *      mv_qc_prep - Host specific command preparation.
 *      @qc: queued command to prepare
 *
@@ -1545,6 +1991,132 @@ static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
 }
 /**
+ *      mv_sff_check_status - fetch device status, if valid
+ *      @ap: ATA port to fetch status from
+ *
+ *      When using command issue via mv_qc_issue_fis(),
+ *      the initial ATA_BUSY state does not show up in the
+ *      ATA status (shadow) register.  This can confuse libata!
+ *
+ *      So we have a hook here to fake ATA_BUSY for that situation,
+ *      until the first time a BUSY, DRQ, or ERR bit is seen.
+ *
+ *      The rest of the time, it simply returns the ATA status register.
+ */
+static u8 mv_sff_check_status(struct ata_port *ap)
+{
+        u8 stat = ioread8(ap->ioaddr.status_addr);
+        struct mv_port_priv *pp = ap->private_data;
+        if (pp->pp_flags & MV_PP_FLAG_FAKE_ATA_BUSY) {
+                if (stat & (ATA_BUSY | ATA_DRQ | ATA_ERR))
+                        pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY;
+                else
+                        stat = ATA_BUSY;
+        }
+        return stat;
+}
+/**
+ *      mv_send_fis - Send a FIS, using the "Vendor-Unique FIS" register
+ *      @fis: fis to be sent
+ *      @nwords: number of 32-bit words in the fis
+ */
+static unsigned int mv_send_fis(struct ata_port *ap, u32 *fis, int nwords)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        u32 ifctl, old_ifctl, ifstat;
+        int i, timeout = 200, final_word = nwords - 1;
+        /* Initiate FIS transmission mode */
+        old_ifctl = readl(port_mmio + SATA_IFCTL_OFS);
+        ifctl = 0x100 | (old_ifctl & 0xf);
+        writelfl(ifctl, port_mmio + SATA_IFCTL_OFS);
+        /* Send all words of the FIS except for the final word */
+        for (i = 0; i < final_word; ++i)
+                writel(fis[i], port_mmio + VENDOR_UNIQUE_FIS_OFS);
+        /* Flag end-of-transmission, and then send the final word */
+        writelfl(ifctl | 0x200, port_mmio + SATA_IFCTL_OFS);
+        writelfl(fis[final_word], port_mmio + VENDOR_UNIQUE_FIS_OFS);
+        /*
+         * Wait for FIS transmission to complete.
+         * This typically takes just a single iteration.
+         */
+        do {
+                ifstat = readl(port_mmio + SATA_IFSTAT_OFS);
+        } while (!(ifstat & 0x1000) && --timeout);
+        /* Restore original port configuration */
+        writelfl(old_ifctl, port_mmio + SATA_IFCTL_OFS);
+        /* See if it worked */
+        if ((ifstat & 0x3000) != 0x1000) {
+                ata_port_printk(ap, KERN_WARNING,
+                                "%s transmission error, ifstat=%08x\n",
+                                __func__, ifstat);
+                return AC_ERR_OTHER;
+        }
+        return 0;
+}
+/**
+ *      mv_qc_issue_fis - Issue a command directly as a FIS
+ *      @qc: queued command to start
+ *
+ *      Note that the ATA shadow registers are not updated
+ *      after command issue, so the device will appear "READY"
+ *      if polled, even while it is BUSY processing the command.
+ *
+ *      So we use a status hook to fake ATA_BUSY until the drive changes state.
+ *
+ *      Note: we don't get updated shadow regs on *completion*
+ *      of non-data commands. So avoid sending them via this function,
+ *      as they will appear to have completed immediately.
+ *
+ *      GEN_IIE has special registers that we could get the result tf from,
+ *      but earlier chipsets do not.  For now, we ignore those registers.
+ */
+static unsigned int mv_qc_issue_fis(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct mv_port_priv *pp = ap->private_data;
+        struct ata_link *link = qc->dev->link;
+        u32 fis[5];
+        int err = 0;
+        ata_tf_to_fis(&qc->tf, link->pmp, 1, (void *)fis);
+        err = mv_send_fis(ap, fis, sizeof(fis) / sizeof(fis[0]));
+        if (err)
+                return err;
+        switch (qc->tf.protocol) {
+        case ATAPI_PROT_PIO:
+                pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
+                /* fall through */
+        case ATAPI_PROT_NODATA:
+                ap->hsm_task_state = HSM_ST_FIRST;
+                break;
+        case ATA_PROT_PIO:
+                pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
+                if (qc->tf.flags & ATA_TFLAG_WRITE)
+                        ap->hsm_task_state = HSM_ST_FIRST;
+                else
+                        ap->hsm_task_state = HSM_ST;
+                break;
+        default:
+                ap->hsm_task_state = HSM_ST_LAST;
+                break;
+        }
+        if (qc->tf.flags & ATA_TFLAG_POLLING)
+                ata_pio_queue_task(ap, qc, 0);
+        return 0;
+}
+/**
 *      mv_qc_issue - Initiate a command to the host
 *      @qc: queued command to start
 *
@@ -1558,14 +2130,28 @@ static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
 */
 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
 {
+        static int limit_warnings = 10;
        struct ata_port *ap = qc->ap;
        void __iomem *port_mmio = mv_ap_base(ap);
        struct mv_port_priv *pp = ap->private_data;
        u32 in_index;
+        unsigned int port_irqs;
-        if ((qc->tf.protocol != ATA_PROT_DMA) &&
+        pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY; /* paranoia */
-            (qc->tf.protocol != ATA_PROT_NCQ)) {
-                static int limit_warnings = 10;
+        switch (qc->tf.protocol) {
+        case ATA_PROT_DMA:
+        case ATA_PROT_NCQ:
+                mv_start_edma(ap, port_mmio, pp, qc->tf.protocol);
+                pp->req_idx = (pp->req_idx + 1) & MV_MAX_Q_DEPTH_MASK;
+                in_index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
+                /* Write the request in pointer to kick the EDMA to life */
+                writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
+                                        port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
+                return 0;
+        case ATA_PROT_PIO:
                /*
                 * Errata SATA#16, SATA#24: warn if multiple DRQs expected.
                 *
@@ -1583,27 +2169,46 @@ static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
                                        ": attempting PIO w/multiple DRQ: "
                                        "this may fail due to h/w errata\n");
                }
-                /*
+                /* drop through */
-                 * We're about to send a non-EDMA capable command to the
+        case ATA_PROT_NODATA:
-                 * port.  Turn off EDMA so there won't be problems accessing
+        case ATAPI_PROT_PIO:
-                 * shadow block, etc registers.
+        case ATAPI_PROT_NODATA:
-                 */
+                if (ap->flags & ATA_FLAG_PIO_POLLING)
-                mv_stop_edma(ap);
+                        qc->tf.flags |= ATA_TFLAG_POLLING;
-                mv_enable_port_irqs(ap, ERR_IRQ);
+                break;
-                mv_pmp_select(ap, qc->dev->link->pmp);
-                return ata_sff_qc_issue(qc);
        }
-        mv_start_dma(ap, port_mmio, pp, qc->tf.protocol);
+        if (qc->tf.flags & ATA_TFLAG_POLLING)
+                port_irqs = ERR_IRQ;    /* mask device interrupt when polling */
-        pp->req_idx = (pp->req_idx + 1) & MV_MAX_Q_DEPTH_MASK;
+        else
-        in_index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
+                port_irqs = ERR_IRQ | DONE_IRQ; /* unmask all interrupts */
-        /* and write the request in pointer to kick the EDMA to life */
+        /*
-        writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
+         * We're about to send a non-EDMA capable command to the
-                 port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
+         * port.  Turn off EDMA so there won't be problems accessing
+         * shadow block, etc registers.
+         */
+        mv_stop_edma(ap);
+        mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), port_irqs);
+        mv_pmp_select(ap, qc->dev->link->pmp);
-        return 0;
+        if (qc->tf.command == ATA_CMD_READ_LOG_EXT) {
+                struct mv_host_priv *hpriv = ap->host->private_data;
+                /*
+                 * Workaround for 88SX60x1 FEr SATA#25 (part 2).
+                 *
+                 * After any NCQ error, the READ_LOG_EXT command
+                 * from libata-eh *must* use mv_qc_issue_fis().
+                 * Otherwise it might fail, due to chip errata.
+                 *
+                 * Rather than special-case it, we'll just *always*
+                 * use this method here for READ_LOG_EXT, making for
+                 * easier testing.
+                 */
+                if (IS_GEN_II(hpriv))
+                        return mv_qc_issue_fis(qc);
+        }
+        return ata_sff_qc_issue(qc);
 }
 static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
@@ -1614,8 +2219,12 @@ static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
        if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
                return NULL;
        qc = ata_qc_from_tag(ap, ap->link.active_tag);
-        if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
+        if (qc) {
-                qc = NULL;
+                if (qc->tf.flags & ATA_TFLAG_POLLING)
+                        qc = NULL;
+                else if (!(qc->flags & ATA_QCFLAG_ACTIVE))
+                        qc = NULL;
+        }
        return qc;
 }
@@ -2084,6 +2693,10 @@ static int mv_host_intr(struct ata_host *host, u32 main_irq_cause)
        void __iomem *mmio = hpriv->base, *hc_mmio;
        unsigned int handled = 0, port;
+        /* If asserted, clear the "all ports" IRQ coalescing bit */
+        if (main_irq_cause & ALL_PORTS_COAL_DONE)
+                writel(~ALL_PORTS_COAL_IRQ, mmio + MV_IRQ_COAL_CAUSE);
        for (port = 0; port < hpriv->n_ports; port++) {
                struct ata_port *ap = host->ports[port];
                unsigned int p, shift, hardport, port_cause;
@@ -2116,6 +2729,8 @@ static int mv_host_intr(struct ata_host *host, u32 main_irq_cause)
                         * to ack (only) those ports via hc_irq_cause.
                         */
                        ack_irqs = 0;
+                        if (hc_cause & PORTS_0_3_COAL_DONE)
+                                ack_irqs = HC_COAL_IRQ;
                        for (p = 0; p < MV_PORTS_PER_HC; ++p) {
                                if ((port + p) >= hpriv->n_ports)
                                        break;
@@ -2204,7 +2819,7 @@ static irqreturn_t mv_interrupt(int irq, void *dev_instance)
        /* for MSI:  block new interrupts while in here */
        if (using_msi)
-                writel(0, hpriv->main_irq_mask_addr);
+                mv_write_main_irq_mask(0, hpriv);
        main_irq_cause = readl(hpriv->main_irq_cause_addr);
        pending_irqs   = main_irq_cause & hpriv->main_irq_mask;
@@ -2221,7 +2836,7 @@ static irqreturn_t mv_interrupt(int irq, void *dev_instance)
        /* for MSI: unmask; interrupt cause bits will retrigger now */
        if (using_msi)
-                writel(hpriv->main_irq_mask, hpriv->main_irq_mask_addr);
+                mv_write_main_irq_mask(hpriv->main_irq_mask, hpriv);
        spin_unlock(&host->lock);
@@ -2774,6 +3389,8 @@ static int mv_hardreset(struct ata_link *link, unsigned int *class,
        mv_reset_channel(hpriv, mmio, ap->port_no);
        pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
+        pp->pp_flags &=
+          ~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
        /* Workaround for errata FEr SATA#10 (part 2) */
        do {
@@ -2793,6 +3410,8 @@ static int mv_hardreset(struct ata_link *link, unsigned int *class,
                                extra = HZ; /* only extend it once, max */
                }
        } while (sstatus != 0x0 && sstatus != 0x113 && sstatus != 0x123);
+        mv_save_cached_regs(ap);
+        mv_edma_cfg(ap, 0, 0);
        return rc;
 }
@@ -3126,6 +3745,8 @@ static int mv_init_host(struct ata_host *host, unsigned int board_idx)
         * The per-port interrupts get done later as ports are set up.
         */
        mv_set_main_irq_mask(host, 0, PCI_ERR);
+        mv_set_irq_coalescing(host, irq_coalescing_io_count,
+                                    irq_coalescing_usecs);
 done:
        return rc;
 }
@@ -3287,12 +3908,6 @@ static struct pci_driver mv_pci_driver = {
        .remove                 = ata_pci_remove_one,
 };
-/*
- * module options
- */
-static int msi;       /* Use PCI msi; either zero (off, default) or non-zero */
 /* move to PCI layer or libata core? */
 static int pci_go_64(struct pci_dev *pdev)
 {
@@ -3474,10 +4089,5 @@ MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:" DRV_NAME);
-#ifdef CONFIG_PCI
-module_param(msi, int, 0444);
-MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
-#endif
 module_init(mv_init);
 module_exit(mv_exit);
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index f65b53785a8f..6cda12ba8122 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -57,9 +57,9 @@ enum {
        NV_MMIO_BAR                     = 5,
        NV_PORTS                        = 2,
-        NV_PIO_MASK                     = 0x1f,
+        NV_PIO_MASK                     = ATA_PIO4,
-        NV_MWDMA_MASK                   = 0x07,
+        NV_MWDMA_MASK                   = ATA_MWDMA2,
-        NV_UDMA_MASK                    = 0x7f,
+        NV_UDMA_MASK                    = ATA_UDMA6,
        NV_PORT0_SCR_REG_OFFSET         = 0x00,
        NV_PORT1_SCR_REG_OFFSET         = 0x40,
@@ -408,6 +408,7 @@ static struct scsi_host_template nv_swncq_sht = {
 static struct ata_port_operations nv_common_ops = {
        .inherits               = &ata_bmdma_port_ops,
+        .lost_interrupt         = ATA_OP_NULL,
        .scr_read               = nv_scr_read,
        .scr_write              = nv_scr_write,
 };
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index ba9a2570a742..b1fd7d62071a 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -176,7 +176,9 @@ static const struct ata_port_operations pdc_common_ops = {
        .check_atapi_dma        = pdc_check_atapi_dma,
        .qc_prep                = pdc_qc_prep,
        .qc_issue               = pdc_qc_issue,
        .sff_irq_clear          = pdc_irq_clear,
+        .lost_interrupt         = ATA_OP_NULL,
        .post_internal_cmd      = pdc_post_internal_cmd,
        .error_handler          = pdc_error_handler,
@@ -213,8 +215,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
                                  PDC_FLAG_SATA_PATA,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_old_sata_ops,
        },
@@ -222,8 +224,8 @@ static const struct ata_port_info pdc_port_info[] = {
        [board_2037x_pata] =
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_pata_ops,
        },
@@ -232,8 +234,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
                                  PDC_FLAG_4_PORTS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_old_sata_ops,
        },
@@ -242,8 +244,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
                                  PDC_FLAG_4_PORTS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_pata_ops,
        },
@@ -252,8 +254,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
                                  PDC_FLAG_GEN_II | PDC_FLAG_SATA_PATA,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_sata_ops,
        },
@@ -262,8 +264,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
                                  PDC_FLAG_GEN_II,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_pata_ops,
        },
@@ -272,8 +274,8 @@ static const struct ata_port_info pdc_port_info[] = {
        {
                .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
                                  PDC_FLAG_GEN_II | PDC_FLAG_4_PORTS,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_sata_ops,
        },
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index a000c86ac859..c3936d35cdac 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -147,6 +147,7 @@ static struct ata_port_operations qs_ata_ops = {
        .softreset              = ATA_OP_NULL,
        .error_handler          = qs_error_handler,
        .post_internal_cmd      = ATA_OP_NULL,
+        .lost_interrupt         = ATA_OP_NULL,
        .scr_read               = qs_scr_read,
        .scr_write              = qs_scr_write,
@@ -160,7 +161,7 @@ static const struct ata_port_info qs_port_info[] = {
        {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
-                .pio_mask       = 0x10, /* pio4 */
+                .pio_mask       = ATA_PIO4_ONLY,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &qs_ata_ops,
        },
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index d0091609e210..e67ce8e5caa5 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -200,8 +200,8 @@ static const struct ata_port_info sil_port_info[] = {
        /* sil_3112 */
        {
                .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE,
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil_ops,
        },
@@ -209,24 +209,24 @@ static const struct ata_port_info sil_port_info[] = {
        {
                .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE |
                                  SIL_FLAG_NO_SATA_IRQ,
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil_ops,
        },
        /* sil_3512 */
        {
                .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil_ops,
        },
        /* sil_3114 */
        {
                .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil_ops,
        },
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 2590c2279fa7..0d8990dcdfcd 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -429,25 +429,25 @@ static const struct ata_port_info sil24_port_info[] = {
        {
                .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(4) |
                                  SIL24_FLAG_PCIX_IRQ_WOC,
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA5,            /* udma0-5 */
+                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil24_ops,
        },
        /* sil_3132 */
        {
                .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(2),
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA5,            /* udma0-5 */
+                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil24_ops,
        },
        /* sil_3131/sil_3531 */
        {
                .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(1),
-                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA5,            /* udma0-5 */
+                .udma_mask      = ATA_UDMA5,
                .port_ops       = &sil24_ops,
        },
 };
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 9c43b4e7c4a6..8f9833228619 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -97,8 +97,8 @@ static struct ata_port_operations sis_ops = {
 static const struct ata_port_info sis_port_info = {
        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x1f,
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x7,
+        .mwdma_mask     = ATA_MWDMA2,
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &sis_ops,
 };
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index 609d147813ae..7257f2d5c52c 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -361,8 +361,8 @@ static const struct ata_port_info k2_port_info[] = {
        {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO | K2_FLAG_NO_ATAPI_DMA,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &k2_sata_ops,
        },
@@ -371,8 +371,8 @@ static const struct ata_port_info k2_port_info[] = {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO | K2_FLAG_NO_ATAPI_DMA |
                                  K2_FLAG_SATA_8_PORTS,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &k2_sata_ops,
        },
@@ -380,8 +380,8 @@ static const struct ata_port_info k2_port_info[] = {
        {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO | K2_FLAG_BAR_POS_3,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &k2_sata_ops,
        },
@@ -389,8 +389,8 @@ static const struct ata_port_info k2_port_info[] = {
        {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &k2_sata_ops,
        },
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index ec04b8d3c791..dce3dccced3f 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -265,8 +265,8 @@ static const struct ata_port_info pdc_port_info[] = {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
                                  ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING,
-                .pio_mask       = 0x1f, /* pio0-4 */
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &pdc_20621_ops,
        },
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index 019575bb3e08..e5bff47e8aa1 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -89,7 +89,7 @@ static struct ata_port_operations uli_ops = {
 static const struct ata_port_info uli_port_info = {
        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                          ATA_FLAG_IGN_SIMPLEX,
-        .pio_mask       = 0x1f,         /* pio0-4 */
+        .pio_mask       = ATA_PIO4,
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &uli_ops,
 };
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 5c62da9cd491..98e8c50703b3 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -146,24 +146,24 @@ static struct ata_port_operations vt8251_ops = {
 static const struct ata_port_info vt6420_port_info = {
        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x1f,
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x07,
+        .mwdma_mask     = ATA_MWDMA2,
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &vt6420_sata_ops,
 };
 static struct ata_port_info vt6421_sport_info = {
        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x1f,
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x07,
+        .mwdma_mask     = ATA_MWDMA2,
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &vt6421_sata_ops,
 };
 static struct ata_port_info vt6421_pport_info = {
        .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x1f,
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0,
+        /* No MWDMA */
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &vt6421_pata_ops,
 };
@@ -171,8 +171,8 @@ static struct ata_port_info vt6421_pport_info = {
 static struct ata_port_info vt8251_port_info = {
        .flags          = ATA_FLAG_SATA | ATA_FLAG_SLAVE_POSS |
                          ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x1f,
+        .pio_mask       = ATA_PIO4,
-        .mwdma_mask     = 0x07,
+        .mwdma_mask     = ATA_MWDMA2,
        .udma_mask      = ATA_UDMA6,
        .port_ops       = &vt8251_ops,
 };
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index c57cdff9e6bd..ed70bd28fa2c 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -308,6 +308,9 @@ static struct scsi_host_template vsc_sata_sht = {
 static struct ata_port_operations vsc_sata_ops = {
        .inherits               = &ata_bmdma_port_ops,
+        /* The IRQ handling is not quite standard SFF behaviour so we
+           cannot use the default lost interrupt handler */
+        .lost_interrupt         = ATA_OP_NULL,
        .sff_tf_load            = vsc_sata_tf_load,
        .sff_tf_read            = vsc_sata_tf_read,
        .freeze                 = vsc_freeze,
@@ -345,8 +348,8 @@ static int __devinit vsc_sata_init_one(struct pci_dev *pdev,
        static const struct ata_port_info pi = {
                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_MMIO,
-                .pio_mask       = 0x1f,
+                .pio_mask       = ATA_PIO4,
-                .mwdma_mask     = 0x07,
+                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &vsc_sata_ops,
        };
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 9f50f1b545dc..ddc97496db4a 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -63,6 +63,32 @@ struct class_private {
 #define to_class(obj)   \
        container_of(obj, struct class_private, class_subsys.kobj)
+/**
+ * struct device_private - structure to hold the private to the driver core portions of the device structure.
+ *
+ * @klist_children - klist containing all children of this device
+ * @knode_parent - node in sibling list
+ * @knode_driver - node in driver list
+ * @knode_bus - node in bus list
+ * @device - pointer back to the struct class that this structure is
+ * associated with.
+ *
+ * Nothing outside of the driver core should ever touch these fields.
+ */
+struct device_private {
+        struct klist klist_children;
+        struct klist_node knode_parent;
+        struct klist_node knode_driver;
+        struct klist_node knode_bus;
+        struct device *device;
+};
+#define to_device_private_parent(obj)   \
+        container_of(obj, struct device_private, knode_parent)
+#define to_device_private_driver(obj)   \
+        container_of(obj, struct device_private, knode_driver)
+#define to_device_private_bus(obj)      \
+        container_of(obj, struct device_private, knode_bus)
 /* initialisation functions */
 extern int devices_init(void);
 extern int buses_init(void);
@@ -86,6 +112,11 @@ extern void bus_remove_driver(struct device_driver *drv);
 extern void driver_detach(struct device_driver *drv);
 extern int driver_probe_device(struct device_driver *drv, struct device *dev);
+static inline int driver_match_device(struct device_driver *drv,
+                                      struct device *dev)
+{
+        return drv->bus->match && drv->bus->match(dev, drv);
+}
 extern void sysdev_shutdown(void);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 83f32b891fa9..dc030f1f00f1 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -198,7 +198,7 @@ static ssize_t driver_bind(struct device_driver *drv,
        int err = -ENODEV;
        dev = bus_find_device_by_name(bus, NULL, buf);
-        if (dev && dev->driver == NULL) {
+        if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
                if (dev->parent)        /* Needed for USB */
                        down(&dev->parent->sem);
                down(&dev->sem);
@@ -253,7 +253,14 @@ static ssize_t store_drivers_probe(struct bus_type *bus,
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_bus) : NULL;
+        struct device *dev = NULL;
+        struct device_private *dev_prv;
+        if (n) {
+                dev_prv = to_device_private_bus(n);
+                dev = dev_prv->device;
+        }
+        return dev;
 }
 /**
@@ -286,7 +293,7 @@ int bus_for_each_dev(struct bus_type *bus, struct device *start,
                return -EINVAL;
        klist_iter_init_node(&bus->p->klist_devices, &i,
-                             (start ? &start->knode_bus : NULL));
+                             (start ? &start->p->knode_bus : NULL));
        while ((dev = next_device(&i)) && !error)
                error = fn(dev, data);
        klist_iter_exit(&i);
@@ -320,7 +327,7 @@ struct device *bus_find_device(struct bus_type *bus,
                return NULL;
        klist_iter_init_node(&bus->p->klist_devices, &i,
-                             (start ? &start->knode_bus : NULL));
+                             (start ? &start->p->knode_bus : NULL));
        while ((dev = next_device(&i)))
                if (match(dev, data) && get_device(dev))
                        break;
@@ -507,7 +514,8 @@ void bus_attach_device(struct device *dev)
                        ret = device_attach(dev);
                WARN_ON(ret < 0);
                if (ret >= 0)
-                        klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
+                        klist_add_tail(&dev->p->knode_bus,
+                                       &bus->p->klist_devices);
        }
 }
@@ -528,8 +536,8 @@ void bus_remove_device(struct device *dev)
                sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
                                  dev_name(dev));
                device_remove_attrs(dev->bus, dev);
-                if (klist_node_attached(&dev->knode_bus))
+                if (klist_node_attached(&dev->p->knode_bus))
-                        klist_del(&dev->knode_bus);
+                        klist_del(&dev->p->knode_bus);
                pr_debug("bus: '%s': remove device %s\n",
                         dev->bus->name, dev_name(dev));
@@ -831,14 +839,16 @@ static void bus_remove_attrs(struct bus_type *bus)
 static void klist_devices_get(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_bus);
+        struct device_private *dev_prv = to_device_private_bus(n);
+        struct device *dev = dev_prv->device;
        get_device(dev);
 }
 static void klist_devices_put(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_bus);
+        struct device_private *dev_prv = to_device_private_bus(n);
+        struct device *dev = dev_prv->device;
        put_device(dev);
 }
@@ -932,6 +942,7 @@ bus_uevent_fail:
        kset_unregister(&bus->p->subsys);
        kfree(bus->p);
 out:
+        bus->p = NULL;
        return retval;
 }
 EXPORT_SYMBOL_GPL(bus_register);
@@ -953,6 +964,7 @@ void bus_unregister(struct bus_type *bus)
        bus_remove_file(bus, &bus_attr_uevent);
        kset_unregister(&bus->p->subsys);
        kfree(bus->p);
+        bus->p = NULL;
 }
 EXPORT_SYMBOL_GPL(bus_unregister);
@@ -993,18 +1005,20 @@ static void device_insertion_sort_klist(struct device *a, struct list_head *list
 {
        struct list_head *pos;
        struct klist_node *n;
+        struct device_private *dev_prv;
        struct device *b;
        list_for_each(pos, list) {
                n = container_of(pos, struct klist_node, n_node);
-                b = container_of(n, struct device, knode_bus);
+                dev_prv = to_device_private_bus(n);
+                b = dev_prv->device;
                if (compare(a, b) <= 0) {
-                        list_move_tail(&a->knode_bus.n_node,
+                        list_move_tail(&a->p->knode_bus.n_node,
-                                       &b->knode_bus.n_node);
+                                       &b->p->knode_bus.n_node);
                        return;
                }
        }
-        list_move_tail(&a->knode_bus.n_node, list);
+        list_move_tail(&a->p->knode_bus.n_node, list);
 }
 void bus_sort_breadthfirst(struct bus_type *bus,
@@ -1014,6 +1028,7 @@ void bus_sort_breadthfirst(struct bus_type *bus,
        LIST_HEAD(sorted_devices);
        struct list_head *pos, *tmp;
        struct klist_node *n;
+        struct device_private *dev_prv;
        struct device *dev;
        struct klist *device_klist;
@@ -1022,7 +1037,8 @@ void bus_sort_breadthfirst(struct bus_type *bus,
        spin_lock(&device_klist->k_lock);
        list_for_each_safe(pos, tmp, &device_klist->k_list) {
                n = container_of(pos, struct klist_node, n_node);
-                dev = container_of(n, struct device, knode_bus);
+                dev_prv = to_device_private_bus(n);
+                dev = dev_prv->device;
                device_insertion_sort_klist(dev, &sorted_devices, compare);
        }
        list_splice(&sorted_devices, &device_klist->k_list);
diff --git a/drivers/base/core.c b/drivers/base/core.c
index f3eae630e589..e73c92d13a23 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -109,6 +109,7 @@ static struct sysfs_ops dev_sysfs_ops = {
 static void device_release(struct kobject *kobj)
 {
        struct device *dev = to_dev(kobj);
+        struct device_private *p = dev->p;
        if (dev->release)
                dev->release(dev);
@@ -120,6 +121,7 @@ static void device_release(struct kobject *kobj)
                WARN(1, KERN_ERR "Device '%s' does not have a release() "
                        "function, it is broken and must be fixed.\n",
                        dev_name(dev));
+        kfree(p);
 }
 static struct kobj_type device_ktype = {
@@ -134,8 +136,6 @@ static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
        if (ktype == &device_ktype) {
                struct device *dev = to_dev(kobj);
-                if (dev->uevent_suppress)
-                        return 0;
                if (dev->bus)
                        return 1;
                if (dev->class)
@@ -507,14 +507,16 @@ EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 static void klist_children_get(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_parent);
+        struct device_private *p = to_device_private_parent(n);
+        struct device *dev = p->device;
        get_device(dev);
 }
 static void klist_children_put(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_parent);
+        struct device_private *p = to_device_private_parent(n);
+        struct device *dev = p->device;
        put_device(dev);
 }
@@ -538,8 +540,6 @@ void device_initialize(struct device *dev)
 {
        dev->kobj.kset = devices_kset;
        kobject_init(&dev->kobj, &device_ktype);
-        klist_init(&dev->klist_children, klist_children_get,
-                   klist_children_put);
        INIT_LIST_HEAD(&dev->dma_pools);
        init_MUTEX(&dev->sem);
        spin_lock_init(&dev->devres_lock);
@@ -777,17 +777,12 @@ static void device_remove_class_symlinks(struct device *dev)
 int dev_set_name(struct device *dev, const char *fmt, ...)
 {
        va_list vargs;
-        char *s;
+        int err;
        va_start(vargs, fmt);
-        vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);
+        err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
        va_end(vargs);
+        return err;
-        /* ewww... some of these buggers have / in the name... */
-        while ((s = strchr(dev->bus_id, '/')))
-                *s = '!';
-        return 0;
 }
 EXPORT_SYMBOL_GPL(dev_set_name);
@@ -864,12 +859,26 @@ int device_add(struct device *dev)
        if (!dev)
                goto done;
-        /* Temporarily support init_name if it is set.
+        dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
-         * It will override bus_id for now */
+        if (!dev->p) {
-        if (dev->init_name)
+                error = -ENOMEM;
-                dev_set_name(dev, "%s", dev->init_name);
+                goto done;
+        }
+        dev->p->device = dev;
+        klist_init(&dev->p->klist_children, klist_children_get,
+                   klist_children_put);
+        /*
+         * for statically allocated devices, which should all be converted
+         * some day, we need to initialize the name. We prevent reading back
+         * the name, and force the use of dev_name()
+         */
+        if (dev->init_name) {
+                dev_set_name(dev, dev->init_name);
+                dev->init_name = NULL;
+        }
-        if (!strlen(dev->bus_id))
+        if (!dev_name(dev))
                goto done;
        pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
@@ -928,7 +937,8 @@ int device_add(struct device *dev)
        kobject_uevent(&dev->kobj, KOBJ_ADD);
        bus_attach_device(dev);
        if (parent)
-                klist_add_tail(&dev->knode_parent, &parent->klist_children);
+                klist_add_tail(&dev->p->knode_parent,
+                               &parent->p->klist_children);
        if (dev->class) {
                mutex_lock(&dev->class->p->class_mutex);
@@ -1042,7 +1052,7 @@ void device_del(struct device *dev)
        device_pm_remove(dev);
        dpm_sysfs_remove(dev);
        if (parent)
-                klist_del(&dev->knode_parent);
+                klist_del(&dev->p->knode_parent);
        if (MAJOR(dev->devt)) {
                device_remove_sys_dev_entry(dev);
                device_remove_file(dev, &devt_attr);
@@ -1103,7 +1113,14 @@ void device_unregister(struct device *dev)
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_parent) : NULL;
+        struct device *dev = NULL;
+        struct device_private *p;
+        if (n) {
+                p = to_device_private_parent(n);
+                dev = p->device;
+        }
+        return dev;
 }
 /**
@@ -1125,7 +1142,7 @@ int device_for_each_child(struct device *parent, void *data,
        struct device *child;
        int error = 0;
-        klist_iter_init(&parent->klist_children, &i);
+        klist_iter_init(&parent->p->klist_children, &i);
        while ((child = next_device(&i)) && !error)
                error = fn(child, data);
        klist_iter_exit(&i);
@@ -1156,7 +1173,7 @@ struct device *device_find_child(struct device *parent, void *data,
        if (!parent)
                return NULL;
-        klist_iter_init(&parent->klist_children, &i);
+        klist_iter_init(&parent->p->klist_children, &i);
        while ((child = next_device(&i)))
                if (match(child, data) && get_device(child))
                        break;
@@ -1348,7 +1365,10 @@ struct device *device_create_vargs(struct class *class, struct device *parent,
        dev->release = device_create_release;
        dev_set_drvdata(dev, drvdata);
-        vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);
+        retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
+        if (retval)
+                goto error;
        retval = device_register(dev);
        if (retval)
                goto error;
@@ -1452,19 +1472,15 @@ int device_rename(struct device *dev, char *new_name)
                old_class_name = make_class_name(dev->class->name, &dev->kobj);
 #endif
-        old_device_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL);
+        old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
        if (!old_device_name) {
                error = -ENOMEM;
                goto out;
        }
-        strlcpy(old_device_name, dev->bus_id, BUS_ID_SIZE);
-        strlcpy(dev->bus_id, new_name, BUS_ID_SIZE);
        error = kobject_rename(&dev->kobj, new_name);
-        if (error) {
+        if (error)
-                strlcpy(dev->bus_id, old_device_name, BUS_ID_SIZE);
                goto out;
-        }
 #ifdef CONFIG_SYSFS_DEPRECATED
        if (old_class_name) {
@@ -1545,8 +1561,10 @@ out:
 * device_move - moves a device to a new parent
 * @dev: the pointer to the struct device to be moved
 * @new_parent: the new parent of the device (can by NULL)
+ * @dpm_order: how to reorder the dpm_list
 */
-int device_move(struct device *dev, struct device *new_parent)
+int device_move(struct device *dev, struct device *new_parent,
+                enum dpm_order dpm_order)
 {
        int error;
        struct device *old_parent;
@@ -1556,6 +1574,7 @@ int device_move(struct device *dev, struct device *new_parent)
        if (!dev)
                return -EINVAL;
+        device_pm_lock();
        new_parent = get_device(new_parent);
        new_parent_kobj = get_device_parent(dev, new_parent);
@@ -1570,9 +1589,10 @@ int device_move(struct device *dev, struct device *new_parent)
        old_parent = dev->parent;
        dev->parent = new_parent;
        if (old_parent)
-                klist_remove(&dev->knode_parent);
+                klist_remove(&dev->p->knode_parent);
        if (new_parent) {
-                klist_add_tail(&dev->knode_parent, &new_parent->klist_children);
+                klist_add_tail(&dev->p->knode_parent,
+                               &new_parent->p->klist_children);
                set_dev_node(dev, dev_to_node(new_parent));
        }
@@ -1584,11 +1604,11 @@ int device_move(struct device *dev, struct device *new_parent)
                device_move_class_links(dev, new_parent, old_parent);
                if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
                        if (new_parent)
-                                klist_remove(&dev->knode_parent);
+                                klist_remove(&dev->p->knode_parent);
                        dev->parent = old_parent;
                        if (old_parent) {
-                                klist_add_tail(&dev->knode_parent,
+                                klist_add_tail(&dev->p->knode_parent,
-                                               &old_parent->klist_children);
+                                               &old_parent->p->klist_children);
                                set_dev_node(dev, dev_to_node(old_parent));
                        }
                }
@@ -1596,9 +1616,23 @@ int device_move(struct device *dev, struct device *new_parent)
                put_device(new_parent);
                goto out;
        }
+        switch (dpm_order) {
+        case DPM_ORDER_NONE:
+                break;
+        case DPM_ORDER_DEV_AFTER_PARENT:
+                device_pm_move_after(dev, new_parent);
+                break;
+        case DPM_ORDER_PARENT_BEFORE_DEV:
+                device_pm_move_before(new_parent, dev);
+                break;
+        case DPM_ORDER_DEV_LAST:
+                device_pm_move_last(dev);
+                break;
+        }
 out_put:
        put_device(old_parent);
 out:
+        device_pm_unlock();
        put_device(dev);
        return error;
 }
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 135231239103..f17c3266a0e0 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -30,7 +30,7 @@
 static void driver_bound(struct device *dev)
 {
-        if (klist_node_attached(&dev->knode_driver)) {
+        if (klist_node_attached(&dev->p->knode_driver)) {
                printk(KERN_WARNING "%s: device %s already bound\n",
                        __func__, kobject_name(&dev->kobj));
                return;
@@ -43,7 +43,7 @@ static void driver_bound(struct device *dev)
                blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                             BUS_NOTIFY_BOUND_DRIVER, dev);
-        klist_add_tail(&dev->knode_driver, &dev->driver->p->klist_devices);
+        klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
 }
 static int driver_sysfs_add(struct device *dev)
@@ -172,16 +172,12 @@ int driver_probe_done(void)
 /**
 * wait_for_device_probe
 * Wait for device probing to be completed.
- *
- * Note: this function polls at 100 msec intervals.
 */
-int wait_for_device_probe(void)
+void wait_for_device_probe(void)
 {
        /* wait for the known devices to complete their probing */
-        while (driver_probe_done() != 0)
+        wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
-                msleep(100);
        async_synchronize_full();
-        return 0;
 }
 /**
@@ -189,14 +185,8 @@ int wait_for_device_probe(void)
 * @drv: driver to bind a device to
 * @dev: device to try to bind to the driver
 *
- * First, we call the bus's match function, if one present, which should
+ * This function returns -ENODEV if the device is not registered,
- * compare the device IDs the driver supports with the device IDs of the
+ * 1 if the device is bound sucessfully and 0 otherwise.
- * device. Note we don't do this ourselves because we don't know the
- * format of the ID structures, nor what is to be considered a match and
- * what is not.
- *
- * This function returns 1 if a match is found, -ENODEV if the device is
- * not registered, and 0 otherwise.
 *
 * This function must be called with @dev->sem held.  When called for a
 * USB interface, @dev->parent->sem must be held as well.
@@ -207,21 +197,22 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
        if (!device_is_registered(dev))
                return -ENODEV;
-        if (drv->bus->match && !drv->bus->match(dev, drv))
-                goto done;
        pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
                 drv->bus->name, __func__, dev_name(dev), drv->name);
        ret = really_probe(dev, drv);
-done:
        return ret;
 }
 static int __device_attach(struct device_driver *drv, void *data)
 {
        struct device *dev = data;
+        if (!driver_match_device(drv, dev))
+                return 0;
        return driver_probe_device(drv, dev);
 }
@@ -274,7 +265,7 @@ static int __driver_attach(struct device *dev, void *data)
         * is an error.
         */
-        if (drv->bus->match && !drv->bus->match(dev, drv))
+        if (!driver_match_device(drv, dev))
                return 0;
        if (dev->parent)        /* Needed for USB */
@@ -327,7 +318,7 @@ static void __device_release_driver(struct device *dev)
                        drv->remove(dev);
                devres_release_all(dev);
                dev->driver = NULL;
-                klist_remove(&dev->knode_driver);
+                klist_remove(&dev->p->knode_driver);
        }
 }
@@ -357,6 +348,7 @@ EXPORT_SYMBOL_GPL(device_release_driver);
 */
 void driver_detach(struct device_driver *drv)
 {
+        struct device_private *dev_prv;
        struct device *dev;
        for (;;) {
@@ -365,8 +357,10 @@ void driver_detach(struct device_driver *drv)
                        spin_unlock(&drv->p->klist_devices.k_lock);
                        break;
                }
-                dev = list_entry(drv->p->klist_devices.k_list.prev,
+                dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
-                                struct device, knode_driver.n_node);
+                                     struct device_private,
+                                     knode_driver.n_node);
+                dev = dev_prv->device;
                get_device(dev);
                spin_unlock(&drv->p->klist_devices.k_lock);
diff --git a/drivers/base/driver.c b/drivers/base/driver.c
index 1e2bda780e48..c51f11bb29ae 100644
--- a/drivers/base/driver.c
+++ b/drivers/base/driver.c
@@ -19,7 +19,14 @@
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_driver) : NULL;
+        struct device *dev = NULL;
+        struct device_private *dev_prv;
+        if (n) {
+                dev_prv = to_device_private_driver(n);
+                dev = dev_prv->device;
+        }
+        return dev;
 }
 /**
@@ -42,7 +49,7 @@ int driver_for_each_device(struct device_driver *drv, struct device *start,
                return -EINVAL;
        klist_iter_init_node(&drv->p->klist_devices, &i,
-                             start ? &start->knode_driver : NULL);
+                             start ? &start->p->knode_driver : NULL);
        while ((dev = next_device(&i)) && !error)
                error = fn(dev, data);
        klist_iter_exit(&i);
@@ -76,7 +83,7 @@ struct device *driver_find_device(struct device_driver *drv,
                return NULL;
        klist_iter_init_node(&drv->p->klist_devices, &i,
-                             (start ? &start->knode_driver : NULL));
+                             (start ? &start->p->knode_driver : NULL));
        while ((dev = next_device(&i)))
                if (match(dev, data) && get_device(dev))
                        break;
@@ -216,6 +223,8 @@ int driver_register(struct device_driver *drv)
        int ret;
        struct device_driver *other;
+        BUG_ON(!drv->bus->p);
        if ((drv->bus->probe && drv->probe) ||
            (drv->bus->remove && drv->remove) ||
            (drv->bus->shutdown && drv->shutdown))
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 44699d9dd85c..d3a59c688fe4 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -319,7 +319,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
        f_dev->parent = device;
        f_dev->class = &firmware_class;
        dev_set_drvdata(f_dev, fw_priv);
-        f_dev->uevent_suppress = 1;
+        dev_set_uevent_suppress(f_dev, 1);
        retval = device_register(f_dev);
        if (retval) {
                dev_err(device, "%s: device_register failed\n", __func__);
@@ -366,7 +366,7 @@ static int fw_setup_device(struct firmware *fw, struct device **dev_p,
        }
        if (uevent)
-                f_dev->uevent_suppress = 0;
+                dev_set_uevent_suppress(f_dev, 0);
        *dev_p = f_dev;
        goto out;
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 349a1013603f..d2198f64ad4e 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -217,6 +217,7 @@ int platform_device_add_data(struct platform_device *pdev, const void *data,
        if (d) {
                memcpy(d, data, size);
                pdev->dev.platform_data = d;
+                pdev->platform_data = d;
        }
        return d ? 0 : -ENOMEM;
 }
@@ -246,6 +247,21 @@ int platform_device_add(struct platform_device *pdev)
        else
                dev_set_name(&pdev->dev, pdev->name);
+        /* We will remove platform_data field from struct device
+        * if all platform devices pass its platform specific data
+        * from platform_device. The conversion is going to be a
+        * long time, so we allow the two cases coexist to make
+        * this kind of fix more easily*/
+        if (pdev->platform_data && pdev->dev.platform_data) {
+                printk(KERN_ERR
+                               "%s: use which platform_data?\n",
+                               dev_name(&pdev->dev));
+        } else if (pdev->platform_data) {
+                pdev->dev.platform_data = pdev->platform_data;
+        } else if (pdev->dev.platform_data) {
+                pdev->platform_data = pdev->dev.platform_data;
+        }
        for (i = 0; i < pdev->num_resources; i++) {
                struct resource *p, *r = &pdev->resource[i];
@@ -584,10 +600,25 @@ static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
        struct platform_device  *pdev = to_platform_device(dev);
-        add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
+        add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
+                (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
        return 0;
 }
+static const struct platform_device_id *platform_match_id(
+                        struct platform_device_id *id,
+                        struct platform_device *pdev)
+{
+        while (id->name[0]) {
+                if (strcmp(pdev->name, id->name) == 0) {
+                        pdev->id_entry = id;
+                        return id;
+                }
+                id++;
+        }
+        return NULL;
+}
 /**
 * platform_match - bind platform device to platform driver.
 * @dev: device.
@@ -603,9 +634,14 @@ static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 */
 static int platform_match(struct device *dev, struct device_driver *drv)
 {
-        struct platform_device *pdev;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct platform_driver *pdrv = to_platform_driver(drv);
-        pdev = container_of(dev, struct platform_device, dev);
+        /* match against the id table first */
+        if (pdrv->id_table)
+                return platform_match_id(pdrv->id_table, pdev) != NULL;
+        /* fall-back to driver name match */
        return (strcmp(pdev->name, drv->name) == 0);
 }
@@ -623,26 +659,24 @@ static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
 {
-        struct platform_driver *drv = to_platform_driver(dev->driver);
+        struct platform_driver *pdrv = to_platform_driver(dev->driver);
-        struct platform_device *pdev;
+        struct platform_device *pdev = to_platform_device(dev);
        int ret = 0;
-        pdev = container_of(dev, struct platform_device, dev);
+        if (dev->driver && pdrv->suspend_late)
-        if (dev->driver && drv->suspend_late)
+                ret = pdrv->suspend_late(pdev, mesg);
-                ret = drv->suspend_late(pdev, mesg);
        return ret;
 }
 static int platform_legacy_resume_early(struct device *dev)
 {
-        struct platform_driver *drv = to_platform_driver(dev->driver);
+        struct platform_driver *pdrv = to_platform_driver(dev->driver);
-        struct platform_device *pdev;
+        struct platform_device *pdev = to_platform_device(dev);
        int ret = 0;
-        pdev = container_of(dev, struct platform_device, dev);
+        if (dev->driver && pdrv->resume_early)
-        if (dev->driver && drv->resume_early)
+                ret = pdrv->resume_early(pdev);
-                ret = drv->resume_early(pdev);
        return ret;
 }
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 2d14f4ae6c01..e255341682c8 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -107,6 +107,50 @@ void device_pm_remove(struct device *dev)
 }
 /**
+ *      device_pm_move_before - move device in dpm_list
+ *      @deva:  Device to move in dpm_list
+ *      @devb:  Device @deva should come before
+ */
+void device_pm_move_before(struct device *deva, struct device *devb)
+{
+        pr_debug("PM: Moving %s:%s before %s:%s\n",
+                 deva->bus ? deva->bus->name : "No Bus",
+                 kobject_name(&deva->kobj),
+                 devb->bus ? devb->bus->name : "No Bus",
+                 kobject_name(&devb->kobj));
+        /* Delete deva from dpm_list and reinsert before devb. */
+        list_move_tail(&deva->power.entry, &devb->power.entry);
+}
+/**
+ *      device_pm_move_after - move device in dpm_list
+ *      @deva:  Device to move in dpm_list
+ *      @devb:  Device @deva should come after
+ */
+void device_pm_move_after(struct device *deva, struct device *devb)
+{
+        pr_debug("PM: Moving %s:%s after %s:%s\n",
+                 deva->bus ? deva->bus->name : "No Bus",
+                 kobject_name(&deva->kobj),
+                 devb->bus ? devb->bus->name : "No Bus",
+                 kobject_name(&devb->kobj));
+        /* Delete deva from dpm_list and reinsert after devb. */
+        list_move(&deva->power.entry, &devb->power.entry);
+}
+/**
+ *      device_pm_move_last - move device to end of dpm_list
+ *      @dev:   Device to move in dpm_list
+ */
+void device_pm_move_last(struct device *dev)
+{
+        pr_debug("PM: Moving %s:%s to end of list\n",
+                 dev->bus ? dev->bus->name : "No Bus",
+                 kobject_name(&dev->kobj));
+        list_move_tail(&dev->power.entry, &dpm_list);
+}
+/**
 *      pm_op - execute the PM operation appropiate for given PM event
 *      @dev:   Device.
 *      @ops:   PM operations to choose from.
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 41f51fae042f..c7cb4fc3735c 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -18,11 +18,19 @@ static inline struct device *to_device(struct list_head *entry)
 extern void device_pm_add(struct device *);
 extern void device_pm_remove(struct device *);
+extern void device_pm_move_before(struct device *, struct device *);
+extern void device_pm_move_after(struct device *, struct device *);
+extern void device_pm_move_last(struct device *);
 #else /* CONFIG_PM_SLEEP */
 static inline void device_pm_add(struct device *dev) {}
 static inline void device_pm_remove(struct device *dev) {}
+static inline void device_pm_move_before(struct device *deva,
+                                         struct device *devb) {}
+static inline void device_pm_move_after(struct device *deva,
+                                        struct device *devb) {}
+static inline void device_pm_move_last(struct device *dev) {}
 #endif
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index b428c8c4bc64..cbd36cf59a0f 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -30,10 +30,10 @@
 static ssize_t
-sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
+sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
 {
-        struct sys_device * sysdev = to_sysdev(kobj);
+        struct sys_device *sysdev = to_sysdev(kobj);
-        struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
+        struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
        if (sysdev_attr->show)
                return sysdev_attr->show(sysdev, sysdev_attr, buffer);
@@ -42,11 +42,11 @@ sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
 static ssize_t
-sysdev_store(struct kobject * kobj, struct attribute * attr,
+sysdev_store(struct kobject *kobj, struct attribute *attr,
-             const char * buffer, size_t count)
+             const char *buffer, size_t count)
 {
-        struct sys_device * sysdev = to_sysdev(kobj);
+        struct sys_device *sysdev = to_sysdev(kobj);
-        struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
+        struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
        if (sysdev_attr->store)
                return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
@@ -63,13 +63,13 @@ static struct kobj_type ktype_sysdev = {
 };
-int sysdev_create_file(struct sys_device * s, struct sysdev_attribute * a)
+int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
 {
        return sysfs_create_file(&s->kobj, &a->attr);
 }
-void sysdev_remove_file(struct sys_device * s, struct sysdev_attribute * a)
+void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
 {
        sysfs_remove_file(&s->kobj, &a->attr);
 }
@@ -84,7 +84,7 @@ EXPORT_SYMBOL_GPL(sysdev_remove_file);
 static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
                                 char *buffer)
 {
-        struct sysdev_class * class = to_sysdev_class(kobj);
+        struct sysdev_class *class = to_sysdev_class(kobj);
        struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
        if (class_attr->show)
@@ -95,8 +95,8 @@ static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
 static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
                                  const char *buffer, size_t count)
 {
-        struct sysdev_class * class = to_sysdev_class(kobj);
+        struct sysdev_class *class = to_sysdev_class(kobj);
-        struct sysdev_class_attribute * class_attr = to_sysdev_class_attr(attr);
+        struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
        if (class_attr->store)
                return class_attr->store(class, buffer, count);
@@ -128,7 +128,7 @@ EXPORT_SYMBOL_GPL(sysdev_class_remove_file);
 static struct kset *system_kset;
-int sysdev_class_register(struct sysdev_class * cls)
+int sysdev_class_register(struct sysdev_class *cls)
 {
        pr_debug("Registering sysdev class '%s'\n", cls->name);
@@ -141,7 +141,7 @@ int sysdev_class_register(struct sysdev_class * cls)
        return kset_register(&cls->kset);
 }
-void sysdev_class_unregister(struct sysdev_class * cls)
+void sysdev_class_unregister(struct sysdev_class *cls)
 {
        pr_debug("Unregistering sysdev class '%s'\n",
                 kobject_name(&cls->kset.kobj));
@@ -203,8 +203,8 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 *      @cls:   Class driver belongs to.
 *      @drv:   Driver.
 */
-void sysdev_driver_unregister(struct sysdev_class * cls,
+void sysdev_driver_unregister(struct sysdev_class *cls,
-                              struct sysdev_driver * drv)
+                              struct sysdev_driver *drv)
 {
        mutex_lock(&sysdev_drivers_lock);
        list_del_init(&drv->entry);
@@ -229,10 +229,10 @@ EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
 *      @sysdev:        device in question
 *
 */
-int sysdev_register(struct sys_device * sysdev)
+int sysdev_register(struct sys_device *sysdev)
 {
        int error;
-        struct sysdev_class * cls = sysdev->cls;
+        struct sysdev_class *cls = sysdev->cls;
        if (!cls)
                return -EINVAL;
@@ -252,7 +252,7 @@ int sysdev_register(struct sys_device * sysdev)
                                     sysdev->id);
        if (!error) {
-                struct sysdev_driver * drv;
+                struct sysdev_driver *drv;
                pr_debug("Registering sys device '%s'\n",
                         kobject_name(&sysdev->kobj));
@@ -274,9 +274,9 @@ int sysdev_register(struct sys_device * sysdev)
        return error;
 }
-void sysdev_unregister(struct sys_device * sysdev)
+void sysdev_unregister(struct sys_device *sysdev)
 {
-        struct sysdev_driver * drv;
+        struct sysdev_driver *drv;
        mutex_lock(&sysdev_drivers_lock);
        list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
@@ -305,19 +305,19 @@ void sysdev_unregister(struct sys_device * sysdev)
 */
 void sysdev_shutdown(void)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
        pr_debug("Shutting Down System Devices\n");
        mutex_lock(&sysdev_drivers_lock);
        list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
-                struct sys_device * sysdev;
+                struct sys_device *sysdev;
                pr_debug("Shutting down type '%s':\n",
                         kobject_name(&cls->kset.kobj));
                list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
-                        struct sysdev_driver * drv;
+                        struct sysdev_driver *drv;
                        pr_debug(" %s\n", kobject_name(&sysdev->kobj));
                        /* Call auxillary drivers first */
@@ -364,7 +364,7 @@ static void __sysdev_resume(struct sys_device *dev)
 */
 int sysdev_suspend(pm_message_t state)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
        struct sys_device *sysdev, *err_dev;
        struct sysdev_driver *drv, *err_drv;
        int ret;
@@ -442,12 +442,12 @@ EXPORT_SYMBOL_GPL(sysdev_suspend);
 */
 int sysdev_resume(void)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
        pr_debug("Resuming System Devices\n");
        list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
-                struct sys_device * sysdev;
+                struct sys_device *sysdev;
                pr_debug("Resuming type '%s':\n",
                         kobject_name(&cls->kset.kobj));
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 83d8ed39433d..c2c95e614506 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4135,10 +4135,9 @@ static int have_no_fdc = -ENODEV;
 static ssize_t floppy_cmos_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
 {
-        struct platform_device *p;
+        struct platform_device *p = to_platform_device(dev);
        int drive;
-        p = container_of(dev, struct platform_device,dev);
        drive = p->id;
        return sprintf(buf, "%X\n", UDP->cmos);
 }
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 12fb816db7b0..69b7f8e77596 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -391,7 +391,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum);
 */
 #ifdef CONFIG_USB_LIBUSUAL
-#define ub_usb_ids  storage_usb_ids
+#define ub_usb_ids  usb_storage_usb_ids
 #else
 static struct usb_device_id ub_usb_ids[] = {
@@ -2146,10 +2146,9 @@ static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev,
                ep = &altsetting->endpoint[i].desc;
                /* Is it a BULK endpoint? */
-                if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                if (usb_endpoint_xfer_bulk(ep)) {
-                                == USB_ENDPOINT_XFER_BULK) {
                        /* BULK in or out? */
-                        if (ep->bEndpointAddress & USB_DIR_IN) {
+                        if (usb_endpoint_dir_in(ep)) {
                                if (ep_in == NULL)
                                        ep_in = ep;
                        } else {
@@ -2168,9 +2167,9 @@ static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev,
        sc->send_ctrl_pipe = usb_sndctrlpipe(dev, 0);
        sc->recv_ctrl_pipe = usb_rcvctrlpipe(dev, 0);
        sc->send_bulk_pipe = usb_sndbulkpipe(dev,
-                ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                usb_endpoint_num(ep_out));
        sc->recv_bulk_pipe = usb_rcvbulkpipe(dev, 
-                ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                usb_endpoint_num(ep_in));
        return 0;
 }
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 8822eca58ffa..5fab6470f4b2 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -20,6 +20,20 @@ config HW_RANDOM
          If unsure, say Y.
+config HW_RANDOM_TIMERIOMEM
+        tristate "Timer IOMEM HW Random Number Generator support"
+        depends on HW_RANDOM && HAS_IOMEM
+        ---help---
+          This driver provides kernel-side support for a generic Random
+          Number Generator used by reading a 'dumb' iomem address that
+          is to be read no faster than, for example, once a second;
+          the default FPGA bitstream on the TS-7800 has such functionality.
+          To compile this driver as a module, choose M here: the
+          module will be called timeriomem-rng.
+          If unsure, say Y.
 config HW_RANDOM_INTEL
        tristate "Intel HW Random Number Generator support"
        depends on HW_RANDOM && (X86 || IA64) && PCI
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index b6effb7522c2..e81d21a5f28f 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -4,6 +4,7 @@
 obj-$(CONFIG_HW_RANDOM) += rng-core.o
 rng-core-y := core.o
+obj-$(CONFIG_HW_RANDOM_TIMERIOMEM) += timeriomem-rng.o
 obj-$(CONFIG_HW_RANDOM_INTEL) += intel-rng.o
 obj-$(CONFIG_HW_RANDOM_AMD) += amd-rng.o
 obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o
diff --git a/drivers/char/hw_random/timeriomem-rng.c b/drivers/char/hw_random/timeriomem-rng.c
new file mode 100644
index 000000000000..10ad41be5897
--- /dev/null
+++ b/drivers/char/hw_random/timeriomem-rng.c
@@ -0,0 +1,151 @@
+/*
+ * drivers/char/hw_random/timeriomem-rng.c
+ *
+ * Copyright (C) 2009 Alexander Clouter <alex@digriz.org.uk>
+ *
+ * Derived from drivers/char/hw_random/omap-rng.c
+ *   Copyright 2005 (c) MontaVista Software, Inc.
+ *   Author: Deepak Saxena <dsaxena@plexity.net>
+ *
+ * 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.
+ *
+ * Overview:
+ *   This driver is useful for platforms that have an IO range that provides
+ *   periodic random data from a single IO memory address.  All the platform
+ *   has to do is provide the address and 'wait time' that new data becomes
+ *   available.
+ *
+ * TODO: add support for reading sizes other than 32bits and masking
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/hw_random.h>
+#include <linux/io.h>
+#include <linux/timeriomem-rng.h>
+#include <linux/jiffies.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/completion.h>
+static struct timeriomem_rng_data *timeriomem_rng_data;
+static void timeriomem_rng_trigger(unsigned long);
+static DEFINE_TIMER(timeriomem_rng_timer, timeriomem_rng_trigger, 0, 0);
+/*
+ * have data return 1, however return 0 if we have nothing
+ */
+static int timeriomem_rng_data_present(struct hwrng *rng, int wait)
+{
+        if (rng->priv == 0)
+                return 1;
+        if (!wait || timeriomem_rng_data->present)
+                return timeriomem_rng_data->present;
+        wait_for_completion(&timeriomem_rng_data->completion);
+        return 1;
+}
+static int timeriomem_rng_data_read(struct hwrng *rng, u32 *data)
+{
+        unsigned long cur;
+        s32 delay;
+        *data = readl(timeriomem_rng_data->address);
+        if (rng->priv != 0) {
+                cur = jiffies;
+                delay = cur - timeriomem_rng_timer.expires;
+                delay = rng->priv - (delay % rng->priv);
+                timeriomem_rng_timer.expires = cur + delay;
+                timeriomem_rng_data->present = 0;
+                init_completion(&timeriomem_rng_data->completion);
+                add_timer(&timeriomem_rng_timer);
+        }
+        return 4;
+}
+static void timeriomem_rng_trigger(unsigned long dummy)
+{
+        timeriomem_rng_data->present = 1;
+        complete(&timeriomem_rng_data->completion);
+}
+static struct hwrng timeriomem_rng_ops = {
+        .name           = "timeriomem",
+        .data_present   = timeriomem_rng_data_present,
+        .data_read      = timeriomem_rng_data_read,
+        .priv           = 0,
+};
+static int __init timeriomem_rng_probe(struct platform_device *pdev)
+{
+        int ret;
+        timeriomem_rng_data = pdev->dev.platform_data;
+        if (timeriomem_rng_data->period != 0
+                && usecs_to_jiffies(timeriomem_rng_data->period) > 0) {
+                timeriomem_rng_timer.expires = jiffies;
+                timeriomem_rng_ops.priv = usecs_to_jiffies(
+                                                timeriomem_rng_data->period);
+        }
+        timeriomem_rng_data->present = 1;
+        ret = hwrng_register(&timeriomem_rng_ops);
+        if (ret) {
+                dev_err(&pdev->dev, "problem registering\n");
+                return ret;
+        }
+        dev_info(&pdev->dev, "32bits from 0x%p @ %dus\n",
+                        timeriomem_rng_data->address,
+                        timeriomem_rng_data->period);
+        return 0;
+}
+static int __devexit timeriomem_rng_remove(struct platform_device *pdev)
+{
+        del_timer_sync(&timeriomem_rng_timer);
+        hwrng_unregister(&timeriomem_rng_ops);
+        return 0;
+}
+static struct platform_driver timeriomem_rng_driver = {
+        .driver = {
+                .name           = "timeriomem_rng",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = timeriomem_rng_probe,
+        .remove         = __devexit_p(timeriomem_rng_remove),
+};
+static int __init timeriomem_rng_init(void)
+{
+        return platform_driver_register(&timeriomem_rng_driver);
+}
+static void __exit timeriomem_rng_exit(void)
+{
+        platform_driver_unregister(&timeriomem_rng_driver);
+}
+module_init(timeriomem_rng_init);
+module_exit(timeriomem_rng_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
+MODULE_DESCRIPTION("Timer IOMEM H/W RNG driver");
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index d0e7926eb486..c64a1bc65349 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -168,12 +168,22 @@ static void atml_plat_remove(void)
        }
 }
-static struct device_driver atml_drv = {
+static int tpm_atml_suspend(struct platform_device *dev, pm_message_t msg)
-        .name = "tpm_atmel",
+{
-        .bus = &platform_bus_type,
+        return tpm_pm_suspend(&dev->dev, msg);
-        .owner = THIS_MODULE,
+}
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static int tpm_atml_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
+static struct platform_driver atml_drv = {
+        .driver = {
+                .name = "tpm_atmel",
+                .owner          = THIS_MODULE,
+        },
+        .suspend = tpm_atml_suspend,
+        .resume = tpm_atml_resume,
 };
 static int __init init_atmel(void)
@@ -184,7 +194,7 @@ static int __init init_atmel(void)
        unsigned long base;
        struct  tpm_chip *chip;
-        rc = driver_register(&atml_drv);
+        rc = platform_driver_register(&atml_drv);
        if (rc)
                return rc;
@@ -223,13 +233,13 @@ err_rel_reg:
                atmel_release_region(base,
                                     region_size);
 err_unreg_drv:
-        driver_unregister(&atml_drv);
+        platform_driver_unregister(&atml_drv);
        return rc;
 }
 static void __exit cleanup_atmel(void)
 {
-        driver_unregister(&atml_drv);
+        platform_driver_unregister(&atml_drv);
        atml_plat_remove();
 }
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 717af7ad1bdf..aec1931608aa 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -654,12 +654,22 @@ module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                    sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
-static struct device_driver tis_drv = {
+static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
-        .name = "tpm_tis",
+{
-        .bus = &platform_bus_type,
+        return tpm_pm_suspend(&dev->dev, msg);
-        .owner = THIS_MODULE,
+}
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static int tpm_tis_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
+static struct platform_driver tis_drv = {
+        .driver = {
+                .name = "tpm_tis",
+                .owner          = THIS_MODULE,
+        },
+        .suspend = tpm_tis_suspend,
+        .resume = tpm_tis_resume,
 };
 static struct platform_device *pdev;
@@ -672,14 +682,14 @@ static int __init init_tis(void)
        int rc;
        if (force) {
-                rc = driver_register(&tis_drv);
+                rc = platform_driver_register(&tis_drv);
                if (rc < 0)
                        return rc;
                if (IS_ERR(pdev=platform_device_register_simple("tpm_tis", -1, NULL, 0)))
                        return PTR_ERR(pdev);
                if((rc=tpm_tis_init(&pdev->dev, TIS_MEM_BASE, TIS_MEM_LEN, 0)) != 0) {
                        platform_device_unregister(pdev);
-                        driver_unregister(&tis_drv);
+                        platform_driver_unregister(&tis_drv);
                }
                return rc;
        }
@@ -711,7 +721,7 @@ static void __exit cleanup_tis(void)
        if (force) {
                platform_device_unregister(pdev);
-                driver_unregister(&tis_drv);
+                platform_driver_unregister(&tis_drv);
        } else
                pnp_unregister_driver(&tis_pnp_driver);
 }
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index 4f3b3f95fc42..d94d25c12aa8 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -479,18 +479,18 @@ static const struct file_operations vcs_fops = {
 static struct class *vc_class;
-void vcs_make_sysfs(struct tty_struct *tty)
+void vcs_make_sysfs(int index)
 {
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1), NULL,
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 1), NULL,
-                      "vcs%u", tty->index + 1);
+                      "vcs%u", index + 1);
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129), NULL,
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 129), NULL,
-                      "vcsa%u", tty->index + 1);
+                      "vcsa%u", index + 1);
 }
-void vcs_remove_sysfs(struct tty_struct *tty)
+void vcs_remove_sysfs(int index)
 {
-        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 1));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 1));
-        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 129));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 129));
 }
 int __init vcs_init(void)
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 7900bd63b36d..2c1d133819b5 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -778,6 +778,7 @@ int vc_allocate(unsigned int currcons)	/* return 0 on success */
            }
            vc->vc_kmalloced = 1;
            vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
+            vcs_make_sysfs(currcons);
            atomic_notifier_call_chain(&vt_notifier_list, VT_ALLOCATE, &param);
        }
        return 0;
@@ -987,7 +988,9 @@ void vc_deallocate(unsigned int currcons)
        if (vc_cons_allocated(currcons)) {
                struct vc_data *vc = vc_cons[currcons].d;
                struct vt_notifier_param param = { .vc = vc };
                atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, &param);
+                vcs_remove_sysfs(currcons);
                vc->vc_sw->con_deinit(vc);
                put_pid(vc->vt_pid);
                module_put(vc->vc_sw->owner);
@@ -2775,7 +2778,6 @@ static int con_open(struct tty_struct *tty, struct file *filp)
                                tty->termios->c_iflag |= IUTF8;
                        else
                                tty->termios->c_iflag &= ~IUTF8;
-                        vcs_make_sysfs(tty);
                        release_console_sem();
                        return ret;
                }
@@ -2795,7 +2797,6 @@ static void con_shutdown(struct tty_struct *tty)
        BUG_ON(vc == NULL);
        acquire_console_sem();
        vc->vc_tty = NULL;
-        vcs_remove_sysfs(tty);
        release_console_sem();
        tty_shutdown(tty);
 }
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index 1525882190fd..1efb2879a94f 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -2,3 +2,4 @@ obj-$(CONFIG_ATMEL_TCB_CLKSRC)	+= tcb_clksrc.o
 obj-$(CONFIG_X86_CYCLONE_TIMER) += cyclone.o
 obj-$(CONFIG_X86_PM_TIMER)      += acpi_pm.o
 obj-$(CONFIG_SCx200HR_TIMER)    += scx200_hrt.o
+obj-$(CONFIG_SH_TIMER_CMT)      += sh_cmt.o
diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
new file mode 100644
index 000000000000..7783b42f6914
--- /dev/null
+++ b/drivers/clocksource/sh_cmt.c
@@ -0,0 +1,615 @@
+/*
+ * SuperH Timer Support - CMT
+ *
+ *  Copyright (C) 2008 Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/init.h>
+#include <linux/bootmem.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/irq.h>
+#include <linux/err.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/sh_cmt.h>
+struct sh_cmt_priv {
+        void __iomem *mapbase;
+        struct clk *clk;
+        unsigned long width; /* 16 or 32 bit version of hardware block */
+        unsigned long overflow_bit;
+        unsigned long clear_bits;
+        struct irqaction irqaction;
+        struct platform_device *pdev;
+        unsigned long flags;
+        unsigned long match_value;
+        unsigned long next_match_value;
+        unsigned long max_match_value;
+        unsigned long rate;
+        spinlock_t lock;
+        struct clock_event_device ced;
+        unsigned long total_cycles;
+};
+static DEFINE_SPINLOCK(sh_cmt_lock);
+#define CMSTR -1 /* shared register */
+#define CMCSR 0 /* channel register */
+#define CMCNT 1 /* channel register */
+#define CMCOR 2 /* channel register */
+static inline unsigned long sh_cmt_read(struct sh_cmt_priv *p, int reg_nr)
+{
+        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+        if (reg_nr == CMSTR) {
+                offs = 0;
+                base -= cfg->channel_offset;
+        } else
+                offs = reg_nr;
+        if (p->width == 16)
+                offs <<= 1;
+        else {
+                offs <<= 2;
+                if ((reg_nr == CMCNT) || (reg_nr == CMCOR))
+                        return ioread32(base + offs);
+        }
+        return ioread16(base + offs);
+}
+static inline void sh_cmt_write(struct sh_cmt_priv *p, int reg_nr,
+                                unsigned long value)
+{
+        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+        if (reg_nr == CMSTR) {
+                offs = 0;
+                base -= cfg->channel_offset;
+        } else
+                offs = reg_nr;
+        if (p->width == 16)
+                offs <<= 1;
+        else {
+                offs <<= 2;
+                if ((reg_nr == CMCNT) || (reg_nr == CMCOR)) {
+                        iowrite32(value, base + offs);
+                        return;
+                }
+        }
+        iowrite16(value, base + offs);
+}
+static unsigned long sh_cmt_get_counter(struct sh_cmt_priv *p,
+                                        int *has_wrapped)
+{
+        unsigned long v1, v2, v3;
+        /* Make sure the timer value is stable. Stolen from acpi_pm.c */
+        do {
+                v1 = sh_cmt_read(p, CMCNT);
+                v2 = sh_cmt_read(p, CMCNT);
+                v3 = sh_cmt_read(p, CMCNT);
+        } while (unlikely((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
+                          || (v3 > v1 && v3 < v2)));
+        *has_wrapped = sh_cmt_read(p, CMCSR) & p->overflow_bit;
+        return v2;
+}
+static void sh_cmt_start_stop_ch(struct sh_cmt_priv *p, int start)
+{
+        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        unsigned long flags, value;
+        /* start stop register shared by multiple timer channels */
+        spin_lock_irqsave(&sh_cmt_lock, flags);
+        value = sh_cmt_read(p, CMSTR);
+        if (start)
+                value |= 1 << cfg->timer_bit;
+        else
+                value &= ~(1 << cfg->timer_bit);
+        sh_cmt_write(p, CMSTR, value);
+        spin_unlock_irqrestore(&sh_cmt_lock, flags);
+}
+static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
+{
+        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        int ret;
+        /* enable clock */
+        ret = clk_enable(p->clk);
+        if (ret) {
+                pr_err("sh_cmt: cannot enable clock \"%s\"\n", cfg->clk);
+                return ret;
+        }
+        *rate = clk_get_rate(p->clk) / 8;
+        /* make sure channel is disabled */
+        sh_cmt_start_stop_ch(p, 0);
+        /* configure channel, periodic mode and maximum timeout */
+        if (p->width == 16)
+                sh_cmt_write(p, CMCSR, 0);
+        else
+                sh_cmt_write(p, CMCSR, 0x01a4);
+        sh_cmt_write(p, CMCOR, 0xffffffff);
+        sh_cmt_write(p, CMCNT, 0);
+        /* enable channel */
+        sh_cmt_start_stop_ch(p, 1);
+        return 0;
+}
+static void sh_cmt_disable(struct sh_cmt_priv *p)
+{
+        /* disable channel */
+        sh_cmt_start_stop_ch(p, 0);
+        /* stop clock */
+        clk_disable(p->clk);
+}
+/* private flags */
+#define FLAG_CLOCKEVENT (1 << 0)
+#define FLAG_CLOCKSOURCE (1 << 1)
+#define FLAG_REPROGRAM (1 << 2)
+#define FLAG_SKIPEVENT (1 << 3)
+#define FLAG_IRQCONTEXT (1 << 4)
+static void sh_cmt_clock_event_program_verify(struct sh_cmt_priv *p,
+                                              int absolute)
+{
+        unsigned long new_match;
+        unsigned long value = p->next_match_value;
+        unsigned long delay = 0;
+        unsigned long now = 0;
+        int has_wrapped;
+        now = sh_cmt_get_counter(p, &has_wrapped);
+        p->flags |= FLAG_REPROGRAM; /* force reprogram */
+        if (has_wrapped) {
+                /* we're competing with the interrupt handler.
+                 *  -> let the interrupt handler reprogram the timer.
+                 *  -> interrupt number two handles the event.
+                 */
+                p->flags |= FLAG_SKIPEVENT;
+                return;
+        }
+        if (absolute)
+                now = 0;
+        do {
+                /* reprogram the timer hardware,
+                 * but don't save the new match value yet.
+                 */
+                new_match = now + value + delay;
+                if (new_match > p->max_match_value)
+                        new_match = p->max_match_value;
+                sh_cmt_write(p, CMCOR, new_match);
+                now = sh_cmt_get_counter(p, &has_wrapped);
+                if (has_wrapped && (new_match > p->match_value)) {
+                        /* we are changing to a greater match value,
+                         * so this wrap must be caused by the counter
+                         * matching the old value.
+                         * -> first interrupt reprograms the timer.
+                         * -> interrupt number two handles the event.
+                         */
+                        p->flags |= FLAG_SKIPEVENT;
+                        break;
+                }
+                if (has_wrapped) {
+                        /* we are changing to a smaller match value,
+                         * so the wrap must be caused by the counter
+                         * matching the new value.
+                         * -> save programmed match value.
+                         * -> let isr handle the event.
+                         */
+                        p->match_value = new_match;
+                        break;
+                }
+                /* be safe: verify hardware settings */
+                if (now < new_match) {
+                        /* timer value is below match value, all good.
+                         * this makes sure we won't miss any match events.
+                         * -> save programmed match value.
+                         * -> let isr handle the event.
+                         */
+                        p->match_value = new_match;
+                        break;
+                }
+                /* the counter has reached a value greater
+                 * than our new match value. and since the
+                 * has_wrapped flag isn't set we must have
+                 * programmed a too close event.
+                 * -> increase delay and retry.
+                 */
+                if (delay)
+                        delay <<= 1;
+                else
+                        delay = 1;
+                if (!delay)
+                        pr_warning("sh_cmt: too long delay\n");
+        } while (delay);
+}
+static void sh_cmt_set_next(struct sh_cmt_priv *p, unsigned long delta)
+{
+        unsigned long flags;
+        if (delta > p->max_match_value)
+                pr_warning("sh_cmt: delta out of range\n");
+        spin_lock_irqsave(&p->lock, flags);
+        p->next_match_value = delta;
+        sh_cmt_clock_event_program_verify(p, 0);
+        spin_unlock_irqrestore(&p->lock, flags);
+}
+static irqreturn_t sh_cmt_interrupt(int irq, void *dev_id)
+{
+        struct sh_cmt_priv *p = dev_id;
+        /* clear flags */
+        sh_cmt_write(p, CMCSR, sh_cmt_read(p, CMCSR) & p->clear_bits);
+        /* update clock source counter to begin with if enabled
+         * the wrap flag should be cleared by the timer specific
+         * isr before we end up here.
+         */
+        if (p->flags & FLAG_CLOCKSOURCE)
+                p->total_cycles += p->match_value;
+        if (!(p->flags & FLAG_REPROGRAM))
+                p->next_match_value = p->max_match_value;
+        p->flags |= FLAG_IRQCONTEXT;
+        if (p->flags & FLAG_CLOCKEVENT) {
+                if (!(p->flags & FLAG_SKIPEVENT)) {
+                        if (p->ced.mode == CLOCK_EVT_MODE_ONESHOT) {
+                                p->next_match_value = p->max_match_value;
+                                p->flags |= FLAG_REPROGRAM;
+                        }
+                        p->ced.event_handler(&p->ced);
+                }
+        }
+        p->flags &= ~FLAG_SKIPEVENT;
+        if (p->flags & FLAG_REPROGRAM) {
+                p->flags &= ~FLAG_REPROGRAM;
+                sh_cmt_clock_event_program_verify(p, 1);
+                if (p->flags & FLAG_CLOCKEVENT)
+                        if ((p->ced.mode == CLOCK_EVT_MODE_SHUTDOWN)
+                            || (p->match_value == p->next_match_value))
+                                p->flags &= ~FLAG_REPROGRAM;
+        }
+        p->flags &= ~FLAG_IRQCONTEXT;
+        return IRQ_HANDLED;
+}
+static int sh_cmt_start(struct sh_cmt_priv *p, unsigned long flag)
+{
+        int ret = 0;
+        unsigned long flags;
+        spin_lock_irqsave(&p->lock, flags);
+        if (!(p->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE)))
+                ret = sh_cmt_enable(p, &p->rate);
+        if (ret)
+                goto out;
+        p->flags |= flag;
+        /* setup timeout if no clockevent */
+        if ((flag == FLAG_CLOCKSOURCE) && (!(p->flags & FLAG_CLOCKEVENT)))
+                sh_cmt_set_next(p, p->max_match_value);
+ out:
+        spin_unlock_irqrestore(&p->lock, flags);
+        return ret;
+}
+static void sh_cmt_stop(struct sh_cmt_priv *p, unsigned long flag)
+{
+        unsigned long flags;
+        unsigned long f;
+        spin_lock_irqsave(&p->lock, flags);
+        f = p->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE);
+        p->flags &= ~flag;
+        if (f && !(p->flags & (FLAG_CLOCKEVENT | FLAG_CLOCKSOURCE)))
+                sh_cmt_disable(p);
+        /* adjust the timeout to maximum if only clocksource left */
+        if ((flag == FLAG_CLOCKEVENT) && (p->flags & FLAG_CLOCKSOURCE))
+                sh_cmt_set_next(p, p->max_match_value);
+        spin_unlock_irqrestore(&p->lock, flags);
+}
+static struct sh_cmt_priv *ced_to_sh_cmt(struct clock_event_device *ced)
+{
+        return container_of(ced, struct sh_cmt_priv, ced);
+}
+static void sh_cmt_clock_event_start(struct sh_cmt_priv *p, int periodic)
+{
+        struct clock_event_device *ced = &p->ced;
+        sh_cmt_start(p, FLAG_CLOCKEVENT);
+        /* TODO: calculate good shift from rate and counter bit width */
+        ced->shift = 32;
+        ced->mult = div_sc(p->rate, NSEC_PER_SEC, ced->shift);
+        ced->max_delta_ns = clockevent_delta2ns(p->max_match_value, ced);
+        ced->min_delta_ns = clockevent_delta2ns(0x1f, ced);
+        if (periodic)
+                sh_cmt_set_next(p, (p->rate + HZ/2) / HZ);
+        else
+                sh_cmt_set_next(p, p->max_match_value);
+}
+static void sh_cmt_clock_event_mode(enum clock_event_mode mode,
+                                    struct clock_event_device *ced)
+{
+        struct sh_cmt_priv *p = ced_to_sh_cmt(ced);
+        /* deal with old setting first */
+        switch (ced->mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+        case CLOCK_EVT_MODE_ONESHOT:
+                sh_cmt_stop(p, FLAG_CLOCKEVENT);
+                break;
+        default:
+                break;
+        }
+        switch (mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                pr_info("sh_cmt: %s used for periodic clock events\n",
+                        ced->name);
+                sh_cmt_clock_event_start(p, 1);
+                break;
+        case CLOCK_EVT_MODE_ONESHOT:
+                pr_info("sh_cmt: %s used for oneshot clock events\n",
+                        ced->name);
+                sh_cmt_clock_event_start(p, 0);
+                break;
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        case CLOCK_EVT_MODE_UNUSED:
+                sh_cmt_stop(p, FLAG_CLOCKEVENT);
+                break;
+        default:
+                break;
+        }
+}
+static int sh_cmt_clock_event_next(unsigned long delta,
+                                   struct clock_event_device *ced)
+{
+        struct sh_cmt_priv *p = ced_to_sh_cmt(ced);
+        BUG_ON(ced->mode != CLOCK_EVT_MODE_ONESHOT);
+        if (likely(p->flags & FLAG_IRQCONTEXT))
+                p->next_match_value = delta;
+        else
+                sh_cmt_set_next(p, delta);
+        return 0;
+}
+static void sh_cmt_register_clockevent(struct sh_cmt_priv *p,
+                                       char *name, unsigned long rating)
+{
+        struct clock_event_device *ced = &p->ced;
+        memset(ced, 0, sizeof(*ced));
+        ced->name = name;
+        ced->features = CLOCK_EVT_FEAT_PERIODIC;
+        ced->features |= CLOCK_EVT_FEAT_ONESHOT;
+        ced->rating = rating;
+        ced->cpumask = cpumask_of(0);
+        ced->set_next_event = sh_cmt_clock_event_next;
+        ced->set_mode = sh_cmt_clock_event_mode;
+        pr_info("sh_cmt: %s used for clock events\n", ced->name);
+        ced->mult = 1; /* work around misplaced WARN_ON() in clockevents.c */
+        clockevents_register_device(ced);
+}
+int sh_cmt_register(struct sh_cmt_priv *p, char *name,
+                    unsigned long clockevent_rating,
+                    unsigned long clocksource_rating)
+{
+        if (p->width == (sizeof(p->max_match_value) * 8))
+                p->max_match_value = ~0;
+        else
+                p->max_match_value = (1 << p->width) - 1;
+        p->match_value = p->max_match_value;
+        spin_lock_init(&p->lock);
+        if (clockevent_rating)
+                sh_cmt_register_clockevent(p, name, clockevent_rating);
+        return 0;
+}
+static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
+{
+        struct sh_cmt_config *cfg = pdev->dev.platform_data;
+        struct resource *res;
+        int irq, ret;
+        ret = -ENXIO;
+        memset(p, 0, sizeof(*p));
+        p->pdev = pdev;
+        if (!cfg) {
+                dev_err(&p->pdev->dev, "missing platform data\n");
+                goto err0;
+        }
+        platform_set_drvdata(pdev, p);
+        res = platform_get_resource(p->pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&p->pdev->dev, "failed to get I/O memory\n");
+                goto err0;
+        }
+        irq = platform_get_irq(p->pdev, 0);
+        if (irq < 0) {
+                dev_err(&p->pdev->dev, "failed to get irq\n");
+                goto err0;
+        }
+        /* map memory, let mapbase point to our channel */
+        p->mapbase = ioremap_nocache(res->start, resource_size(res));
+        if (p->mapbase == NULL) {
+                pr_err("sh_cmt: failed to remap I/O memory\n");
+                goto err0;
+        }
+        /* request irq using setup_irq() (too early for request_irq()) */
+        p->irqaction.name = cfg->name;
+        p->irqaction.handler = sh_cmt_interrupt;
+        p->irqaction.dev_id = p;
+        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
+        p->irqaction.mask = CPU_MASK_NONE;
+        ret = setup_irq(irq, &p->irqaction);
+        if (ret) {
+                pr_err("sh_cmt: failed to request irq %d\n", irq);
+                goto err1;
+        }
+        /* get hold of clock */
+        p->clk = clk_get(&p->pdev->dev, cfg->clk);
+        if (IS_ERR(p->clk)) {
+                pr_err("sh_cmt: cannot get clock \"%s\"\n", cfg->clk);
+                ret = PTR_ERR(p->clk);
+                goto err2;
+        }
+        if (resource_size(res) == 6) {
+                p->width = 16;
+                p->overflow_bit = 0x80;
+                p->clear_bits = ~0xc0;
+        } else {
+                p->width = 32;
+                p->overflow_bit = 0x8000;
+                p->clear_bits = ~0xc000;
+        }
+        return sh_cmt_register(p, cfg->name,
+                               cfg->clockevent_rating,
+                               cfg->clocksource_rating);
+ err2:
+        free_irq(irq, p);
+ err1:
+        iounmap(p->mapbase);
+ err0:
+        return ret;
+}
+static int __devinit sh_cmt_probe(struct platform_device *pdev)
+{
+        struct sh_cmt_priv *p = platform_get_drvdata(pdev);
+        int ret;
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (p == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                return -ENOMEM;
+        }
+        ret = sh_cmt_setup(p, pdev);
+        if (ret) {
+                kfree(p);
+                platform_set_drvdata(pdev, NULL);
+        }
+        return ret;
+}
+static int __devexit sh_cmt_remove(struct platform_device *pdev)
+{
+        return -EBUSY; /* cannot unregister clockevent and clocksource */
+}
+static struct platform_driver sh_cmt_device_driver = {
+        .probe          = sh_cmt_probe,
+        .remove         = __devexit_p(sh_cmt_remove),
+        .driver         = {
+                .name   = "sh_cmt",
+        }
+};
+static int __init sh_cmt_init(void)
+{
+        return platform_driver_register(&sh_cmt_device_driver);
+}
+static void __exit sh_cmt_exit(void)
+{
+        platform_driver_unregister(&sh_cmt_device_driver);
+}
+module_init(sh_cmt_init);
+module_exit(sh_cmt_exit);
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("SuperH CMT Timer Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index d6daf3c507d3..d270e8eb3e67 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -104,7 +104,8 @@ EXPORT_SYMBOL_GPL(unlock_policy_rwsem_write);
 /* internal prototypes */
-static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
+static int __cpufreq_governor(struct cpufreq_policy *policy,
+                unsigned int event);
 static unsigned int __cpufreq_get(unsigned int cpu);
 static void handle_update(struct work_struct *work);
@@ -128,7 +129,7 @@ static int __init init_cpufreq_transition_notifier_list(void)
 pure_initcall(init_cpufreq_transition_notifier_list);
 static LIST_HEAD(cpufreq_governor_list);
-static DEFINE_MUTEX (cpufreq_governor_mutex);
+static DEFINE_MUTEX(cpufreq_governor_mutex);
 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
 {
@@ -371,7 +372,7 @@ static struct cpufreq_governor *__find_governor(const char *str_governor)
        struct cpufreq_governor *t;
        list_for_each_entry(t, &cpufreq_governor_list, governor_list)
-                if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN))
+                if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
                        return t;
        return NULL;
@@ -429,15 +430,11 @@ static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
                mutex_unlock(&cpufreq_governor_mutex);
        }
-  out:
+out:
        return err;
 }
-/* drivers/base/cpu.c */
-extern struct sysdev_class cpu_sysdev_class;
 /**
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
@@ -450,11 +447,12 @@ extern struct sysdev_class cpu_sysdev_class;
 static ssize_t show_##file_name                         \
 (struct cpufreq_policy *policy, char *buf)              \
 {                                                       \
-        return sprintf (buf, "%u\n", policy->object);   \
+        return sprintf(buf, "%u\n", policy->object);    \
 }
 show_one(cpuinfo_min_freq, cpuinfo.min_freq);
 show_one(cpuinfo_max_freq, cpuinfo.max_freq);
+show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
 show_one(scaling_min_freq, min);
 show_one(scaling_max_freq, max);
 show_one(scaling_cur_freq, cur);
@@ -476,7 +474,7 @@ static ssize_t store_##file_name					\
        if (ret)                                                        \
                return -EINVAL;                                         \
                                                                        \
-        ret = sscanf (buf, "%u", &new_policy.object);                   \
+        ret = sscanf(buf, "%u", &new_policy.object);                    \
        if (ret != 1)                                                   \
                return -EINVAL;                                         \
                                                                        \
@@ -486,8 +484,8 @@ static ssize_t store_##file_name					\
        return ret ? ret : count;                                       \
 }
-store_one(scaling_min_freq,min);
+store_one(scaling_min_freq, min);
-store_one(scaling_max_freq,max);
+store_one(scaling_max_freq, max);
 /**
 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
@@ -507,12 +505,13 @@ static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
 */
 static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
 {
-        if(policy->policy == CPUFREQ_POLICY_POWERSAVE)
+        if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
                return sprintf(buf, "powersave\n");
        else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
                return sprintf(buf, "performance\n");
        else if (policy->governor)
-                return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", policy->governor->name);
+                return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n",
+                                policy->governor->name);
        return -EINVAL;
 }
@@ -531,7 +530,7 @@ static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
        if (ret)
                return ret;
-        ret = sscanf (buf, "%15s", str_governor);
+        ret = sscanf(buf, "%15s", str_governor);
        if (ret != 1)
                return -EINVAL;
@@ -575,7 +574,8 @@ static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
        }
        list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
-                if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char)) - (CPUFREQ_NAME_LEN + 2)))
+                if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
+                    - (CPUFREQ_NAME_LEN + 2)))
                        goto out;
                i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
        }
@@ -594,7 +594,7 @@ static ssize_t show_cpus(const struct cpumask *mask, char *buf)
                        i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
                i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
                if (i >= (PAGE_SIZE - 5))
-                    break;
+                        break;
        }
        i += sprintf(&buf[i], "\n");
        return i;
@@ -660,6 +660,7 @@ __ATTR(_name, 0644, show_##_name, store_##_name)
 define_one_ro0400(cpuinfo_cur_freq);
 define_one_ro(cpuinfo_min_freq);
 define_one_ro(cpuinfo_max_freq);
+define_one_ro(cpuinfo_transition_latency);
 define_one_ro(scaling_available_governors);
 define_one_ro(scaling_driver);
 define_one_ro(scaling_cur_freq);
@@ -673,6 +674,7 @@ define_one_rw(scaling_setspeed);
 static struct attribute *default_attrs[] = {
        &cpuinfo_min_freq.attr,
        &cpuinfo_max_freq.attr,
+        &cpuinfo_transition_latency.attr,
        &scaling_min_freq.attr,
        &scaling_max_freq.attr,
        &affected_cpus.attr,
@@ -684,10 +686,10 @@ static struct attribute *default_attrs[] = {
        NULL
 };
-#define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
+#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
-#define to_attr(a) container_of(a,struct freq_attr,attr)
+#define to_attr(a) container_of(a, struct freq_attr, attr)
-static ssize_t show(struct kobject *kobj, struct attribute *attr ,char *buf)
+static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 {
        struct cpufreq_policy *policy = to_policy(kobj);
        struct freq_attr *fattr = to_attr(attr);
@@ -853,10 +855,10 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                if (cpu == j)
                        continue;
-                /* check for existing affected CPUs.  They may not be aware
+                /* Check for existing affected CPUs.
-                 * of it due to CPU Hotplug.
+                 * They may not be aware of it due to CPU Hotplug.
                 */
-                managed_policy = cpufreq_cpu_get(j);            // FIXME: Where is this released?  What about error paths?
+                managed_policy = cpufreq_cpu_get(j);            /* FIXME: Where is this released?  What about error paths? */
                if (unlikely(managed_policy)) {
                        /* Set proper policy_cpu */
@@ -1127,8 +1129,8 @@ static void handle_update(struct work_struct *work)
 *      @old_freq: CPU frequency the kernel thinks the CPU runs at
 *      @new_freq: CPU frequency the CPU actually runs at
 *
- *      We adjust to current frequency first, and need to clean up later. So either call
+ *      We adjust to current frequency first, and need to clean up later.
- *      to cpufreq_update_policy() or schedule handle_update()).
+ *      So either call to cpufreq_update_policy() or schedule handle_update()).
 */
 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
                                unsigned int new_freq)
@@ -1610,7 +1612,8 @@ EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
 /**
 * cpufreq_get_policy - get the current cpufreq_policy
- * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
+ * @policy: struct cpufreq_policy into which the current cpufreq_policy
+ *      is written
 *
 * Reads the current cpufreq policy.
 */
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 0320962c4ec5..2ecd95e4ab1a 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -4,7 +4,7 @@
 *  Copyright (C)  2001 Russell King
 *            (C)  2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
 *                      Jun Nakajima <jun.nakajima@intel.com>
- *            (C)  2004 Alexander Clouter <alex-kernel@digriz.org.uk>
+ *            (C)  2009 Alexander Clouter <alex@digriz.org.uk>
 *
 * 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
@@ -13,22 +13,17 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/smp.h>
 #include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/ctype.h>
 #include <linux/cpufreq.h>
-#include <linux/sysctl.h>
-#include <linux/types.h>
-#include <linux/fs.h>
-#include <linux/sysfs.h>
 #include <linux/cpu.h>
-#include <linux/kmod.h>
-#include <linux/workqueue.h>
 #include <linux/jiffies.h>
 #include <linux/kernel_stat.h>
-#include <linux/percpu.h>
 #include <linux/mutex.h>
+#include <linux/hrtimer.h>
+#include <linux/tick.h>
+#include <linux/ktime.h>
+#include <linux/sched.h>
 /*
 * dbs is used in this file as a shortform for demandbased switching
 * It helps to keep variable names smaller, simpler
@@ -43,19 +38,31 @@
 * latency of the processor. The governor will work on any processor with
 * transition latency <= 10mS, using appropriate sampling
 * rate.
- * For CPUs with transition latency > 10mS (mostly drivers
+ * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
- * with CPUFREQ_ETERNAL), this governor will not work.
+ * this governor will not work.
 * All times here are in uS.
 */
 static unsigned int def_sampling_rate;
 #define MIN_SAMPLING_RATE_RATIO                 (2)
 /* for correct statistics, we need at least 10 ticks between each measure */
-#define MIN_STAT_SAMPLING_RATE                  \
+#define MIN_STAT_SAMPLING_RATE                  \
                        (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
 #define MIN_SAMPLING_RATE                       \
                        (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
+/* Above MIN_SAMPLING_RATE will vanish with its sysfs file soon
+ * Define the minimal settable sampling rate to the greater of:
+ *   - "HW transition latency" * 100 (same as default sampling / 10)
+ *   - MIN_STAT_SAMPLING_RATE
+ * To avoid that userspace shoots itself.
+*/
+static unsigned int minimum_sampling_rate(void)
+{
+        return max(def_sampling_rate / 10, MIN_STAT_SAMPLING_RATE);
+}
+/* This will also vanish soon with removing sampling_rate_max */
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
-#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
+#define LATENCY_MULTIPLIER                      (1000)
 #define DEF_SAMPLING_DOWN_FACTOR                (1)
 #define MAX_SAMPLING_DOWN_FACTOR                (10)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000 * 1000)
@@ -63,12 +70,15 @@ static unsigned int def_sampling_rate;
 static void do_dbs_timer(struct work_struct *work);
 struct cpu_dbs_info_s {
+        cputime64_t prev_cpu_idle;
+        cputime64_t prev_cpu_wall;
+        cputime64_t prev_cpu_nice;
        struct cpufreq_policy *cur_policy;
-        unsigned int prev_cpu_idle_up;
+        struct delayed_work work;
-        unsigned int prev_cpu_idle_down;
-        unsigned int enable;
        unsigned int down_skip;
        unsigned int requested_freq;
+        int cpu;
+        unsigned int enable:1;
 };
 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
@@ -82,19 +92,18 @@ static unsigned int dbs_enable;	/* number of CPUs using this policy */
 * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
 * is recursive for the same process. -Venki
 */
-static DEFINE_MUTEX (dbs_mutex);
+static DEFINE_MUTEX(dbs_mutex);
-static DECLARE_DELAYED_WORK(dbs_work, do_dbs_timer);
-struct dbs_tuners {
+static struct workqueue_struct  *kconservative_wq;
+static struct dbs_tuners {
        unsigned int sampling_rate;
        unsigned int sampling_down_factor;
        unsigned int up_threshold;
        unsigned int down_threshold;
        unsigned int ignore_nice;
        unsigned int freq_step;
-};
+} dbs_tuners_ins = {
-static struct dbs_tuners dbs_tuners_ins = {
        .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
        .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,
        .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
@@ -102,18 +111,37 @@ static struct dbs_tuners dbs_tuners_ins = {
        .freq_step = 5,
 };
-static inline unsigned int get_cpu_idle_time(unsigned int cpu)
+static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu,
+                                                        cputime64_t *wall)
 {
-        unsigned int add_nice = 0, ret;
+        cputime64_t idle_time;
+        cputime64_t cur_wall_time;
+        cputime64_t busy_time;
-        if (dbs_tuners_ins.ignore_nice)
+        cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
-                add_nice = kstat_cpu(cpu).cpustat.nice;
+        busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,
+                        kstat_cpu(cpu).cpustat.system);
+        busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);
+        busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);
+        busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);
+        busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);
+        idle_time = cputime64_sub(cur_wall_time, busy_time);
+        if (wall)
+                *wall = cur_wall_time;
+        return idle_time;
+}
+static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall)
+{
+        u64 idle_time = get_cpu_idle_time_us(cpu, wall);
-        ret = kstat_cpu(cpu).cpustat.idle +
+        if (idle_time == -1ULL)
-                kstat_cpu(cpu).cpustat.iowait +
+                return get_cpu_idle_time_jiffy(cpu, wall);
-                add_nice;
-        return ret;
+        return idle_time;
 }
 /* keep track of frequency transitions */
@@ -125,10 +153,21 @@ dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
        struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info,
                                                        freq->cpu);
+        struct cpufreq_policy *policy;
        if (!this_dbs_info->enable)
                return 0;
-        this_dbs_info->requested_freq = freq->new;
+        policy = this_dbs_info->cur_policy;
+        /*
+         * we only care if our internally tracked freq moves outside
+         * the 'valid' ranges of freqency available to us otherwise
+         * we do not change it
+        */
+        if (this_dbs_info->requested_freq > policy->max
+                        || this_dbs_info->requested_freq < policy->min)
+                this_dbs_info->requested_freq = freq->new;
        return 0;
 }
@@ -140,16 +179,31 @@ static struct notifier_block dbs_cpufreq_notifier_block = {
 /************************** sysfs interface ************************/
 static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
 {
-        return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
+        static int print_once;
+        if (!print_once) {
+                printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max "
+                       "sysfs file is deprecated - used by: %s\n",
+                       current->comm);
+                print_once = 1;
+        }
+        return sprintf(buf, "%u\n", MAX_SAMPLING_RATE);
 }
 static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
 {
-        return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
+        static int print_once;
+        if (!print_once) {
+                printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max "
+                       "sysfs file is deprecated - used by: %s\n", current->comm);
+                print_once = 1;
+        }
+        return sprintf(buf, "%u\n", MIN_SAMPLING_RATE);
 }
-#define define_one_ro(_name)                            \
+#define define_one_ro(_name)            \
-static struct freq_attr _name =                         \
+static struct freq_attr _name =         \
 __ATTR(_name, 0444, show_##_name, NULL)
 define_one_ro(sampling_rate_max);
@@ -174,7 +228,8 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
 {
        unsigned int input;
        int ret;
-        ret = sscanf (buf, "%u", &input);
+        ret = sscanf(buf, "%u", &input);
        if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
                return -EINVAL;
@@ -190,15 +245,13 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
 {
        unsigned int input;
        int ret;
-        ret = sscanf (buf, "%u", &input);
+        ret = sscanf(buf, "%u", &input);
-        mutex_lock(&dbs_mutex);
+        if (ret != 1)
-        if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
-                mutex_unlock(&dbs_mutex);
                return -EINVAL;
-        }
-        dbs_tuners_ins.sampling_rate = input;
+        mutex_lock(&dbs_mutex);
+        dbs_tuners_ins.sampling_rate = max(input, minimum_sampling_rate());
        mutex_unlock(&dbs_mutex);
        return count;
@@ -209,10 +262,11 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
 {
        unsigned int input;
        int ret;
-        ret = sscanf (buf, "%u", &input);
+        ret = sscanf(buf, "%u", &input);
        mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > 100 || input <= dbs_tuners_ins.down_threshold) {
+        if (ret != 1 || input > 100 ||
+                        input <= dbs_tuners_ins.down_threshold) {
                mutex_unlock(&dbs_mutex);
                return -EINVAL;
        }
@@ -228,10 +282,12 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused,
 {
        unsigned int input;
        int ret;
-        ret = sscanf (buf, "%u", &input);
+        ret = sscanf(buf, "%u", &input);
        mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > 100 || input >= dbs_tuners_ins.up_threshold) {
+        /* cannot be lower than 11 otherwise freq will not fall */
+        if (ret != 1 || input < 11 || input > 100 ||
+                        input >= dbs_tuners_ins.up_threshold) {
                mutex_unlock(&dbs_mutex);
                return -EINVAL;
        }
@@ -264,12 +320,14 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
        }
        dbs_tuners_ins.ignore_nice = input;
-        /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
+        /* we need to re-evaluate prev_cpu_idle */
        for_each_online_cpu(j) {
-                struct cpu_dbs_info_s *j_dbs_info;
+                struct cpu_dbs_info_s *dbs_info;
-                j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                dbs_info = &per_cpu(cpu_dbs_info, j);
-                j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
+                dbs_info->prev_cpu_idle = get_cpu_idle_time(j,
-                j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
+                                                &dbs_info->prev_cpu_wall);
+                if (dbs_tuners_ins.ignore_nice)
+                        dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice;
        }
        mutex_unlock(&dbs_mutex);
@@ -281,7 +339,6 @@ static ssize_t store_freq_step(struct cpufreq_policy *policy,
 {
        unsigned int input;
        int ret;
        ret = sscanf(buf, "%u", &input);
        if (ret != 1)
@@ -310,7 +367,7 @@ define_one_rw(down_threshold);
 define_one_rw(ignore_nice_load);
 define_one_rw(freq_step);
-static struct attribute * dbs_attributes[] = {
+static struct attribute *dbs_attributes[] = {
        &sampling_rate_max.attr,
        &sampling_rate_min.attr,
        &sampling_rate.attr,
@@ -329,55 +386,78 @@ static struct attribute_group dbs_attr_group = {
 /************************** sysfs end ************************/
-static void dbs_check_cpu(int cpu)
+static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
 {
-        unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
+        unsigned int load = 0;
-        unsigned int tmp_idle_ticks, total_idle_ticks;
        unsigned int freq_target;
-        unsigned int freq_down_sampling_rate;
-        struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
-        struct cpufreq_policy *policy;
-        if (!this_dbs_info->enable)
+        struct cpufreq_policy *policy;
-                return;
+        unsigned int j;
        policy = this_dbs_info->cur_policy;
        /*
-         * The default safe range is 20% to 80%
+         * Every sampling_rate, we check, if current idle time is less
-         * Every sampling_rate, we check
+         * than 20% (default), then we try to increase frequency
-         *      - If current idle time is less than 20%, then we try to
+         * Every sampling_rate*sampling_down_factor, we check, if current
-         *        increase frequency
+         * idle time is more than 80%, then we try to decrease frequency
-         * Every sampling_rate*sampling_down_factor, we check
-         *      - If current idle time is more than 80%, then we try to
-         *        decrease frequency
         *
         * Any frequency increase takes it to the maximum frequency.
         * Frequency reduction happens at minimum steps of
-         * 5% (default) of max_frequency
+         * 5% (default) of maximum frequency
         */
-        /* Check for frequency increase */
+        /* Get Absolute Load */
-        idle_ticks = UINT_MAX;
+        for_each_cpu(j, policy->cpus) {
+                struct cpu_dbs_info_s *j_dbs_info;
+                cputime64_t cur_wall_time, cur_idle_time;
+                unsigned int idle_time, wall_time;
-        /* Check for frequency increase */
+                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-        total_idle_ticks = get_cpu_idle_time(cpu);
-        tmp_idle_ticks = total_idle_ticks -
+                cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);
-                this_dbs_info->prev_cpu_idle_up;
-        this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
+                wall_time = (unsigned int) cputime64_sub(cur_wall_time,
+                                j_dbs_info->prev_cpu_wall);
+                j_dbs_info->prev_cpu_wall = cur_wall_time;
+                idle_time = (unsigned int) cputime64_sub(cur_idle_time,
+                                j_dbs_info->prev_cpu_idle);
+                j_dbs_info->prev_cpu_idle = cur_idle_time;
+                if (dbs_tuners_ins.ignore_nice) {
+                        cputime64_t cur_nice;
+                        unsigned long cur_nice_jiffies;
+                        cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice,
+                                         j_dbs_info->prev_cpu_nice);
+                        /*
+                         * Assumption: nice time between sampling periods will
+                         * be less than 2^32 jiffies for 32 bit sys
+                         */
+                        cur_nice_jiffies = (unsigned long)
+                                        cputime64_to_jiffies64(cur_nice);
-        if (tmp_idle_ticks < idle_ticks)
+                        j_dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice;
-                idle_ticks = tmp_idle_ticks;
+                        idle_time += jiffies_to_usecs(cur_nice_jiffies);
+                }
+                if (unlikely(!wall_time || wall_time < idle_time))
+                        continue;
+                load = 100 * (wall_time - idle_time) / wall_time;
+        }
-        /* Scale idle ticks by 100 and compare with up and down ticks */
+        /*
-        idle_ticks *= 100;
+         * break out if we 'cannot' reduce the speed as the user might
-        up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
+         * want freq_step to be zero
-                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
+         */
+        if (dbs_tuners_ins.freq_step == 0)
+                return;
-        if (idle_ticks < up_idle_ticks) {
+        /* Check for frequency increase */
+        if (load > dbs_tuners_ins.up_threshold) {
                this_dbs_info->down_skip = 0;
-                this_dbs_info->prev_cpu_idle_down =
-                        this_dbs_info->prev_cpu_idle_up;
                /* if we are already at full speed then break out early */
                if (this_dbs_info->requested_freq == policy->max)
@@ -398,49 +478,24 @@ static void dbs_check_cpu(int cpu)
                return;
        }
-        /* Check for frequency decrease */
+        /*
-        this_dbs_info->down_skip++;
+         * The optimal frequency is the frequency that is the lowest that
-        if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor)
+         * can support the current CPU usage without triggering the up
-                return;
+         * policy. To be safe, we focus 10 points under the threshold.
+         */
-        /* Check for frequency decrease */
+        if (load < (dbs_tuners_ins.down_threshold - 10)) {
-        total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
-        tmp_idle_ticks = total_idle_ticks -
-                this_dbs_info->prev_cpu_idle_down;
-        this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
-        if (tmp_idle_ticks < idle_ticks)
-                idle_ticks = tmp_idle_ticks;
-        /* Scale idle ticks by 100 and compare with up and down ticks */
-        idle_ticks *= 100;
-        this_dbs_info->down_skip = 0;
-        freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
-                dbs_tuners_ins.sampling_down_factor;
-        down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
-                usecs_to_jiffies(freq_down_sampling_rate);
-        if (idle_ticks > down_idle_ticks) {
-                /*
-                 * if we are already at the lowest speed then break out early
-                 * or if we 'cannot' reduce the speed as the user might want
-                 * freq_target to be zero
-                 */
-                if (this_dbs_info->requested_freq == policy->min
-                                || dbs_tuners_ins.freq_step == 0)
-                        return;
                freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100;
-                /* max freq cannot be less than 100. But who knows.... */
-                if (unlikely(freq_target == 0))
-                        freq_target = 5;
                this_dbs_info->requested_freq -= freq_target;
                if (this_dbs_info->requested_freq < policy->min)
                        this_dbs_info->requested_freq = policy->min;
+                /*
+                 * if we cannot reduce the frequency anymore, break out early
+                 */
+                if (policy->cur == policy->min)
+                        return;
                __cpufreq_driver_target(policy, this_dbs_info->requested_freq,
                                CPUFREQ_RELATION_H);
                return;
@@ -449,27 +504,45 @@ static void dbs_check_cpu(int cpu)
 static void do_dbs_timer(struct work_struct *work)
 {
-        int i;
+        struct cpu_dbs_info_s *dbs_info =
-        mutex_lock(&dbs_mutex);
+                container_of(work, struct cpu_dbs_info_s, work.work);
-        for_each_online_cpu(i)
+        unsigned int cpu = dbs_info->cpu;
-                dbs_check_cpu(i);
-        schedule_delayed_work(&dbs_work,
+        /* We want all CPUs to do sampling nearly on same jiffy */
-                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
+        int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
-        mutex_unlock(&dbs_mutex);
+        delay -= jiffies % delay;
+        if (lock_policy_rwsem_write(cpu) < 0)
+                return;
+        if (!dbs_info->enable) {
+                unlock_policy_rwsem_write(cpu);
+                return;
+        }
+        dbs_check_cpu(dbs_info);
+        queue_delayed_work_on(cpu, kconservative_wq, &dbs_info->work, delay);
+        unlock_policy_rwsem_write(cpu);
 }
-static inline void dbs_timer_init(void)
+static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
 {
-        init_timer_deferrable(&dbs_work.timer);
+        /* We want all CPUs to do sampling nearly on same jiffy */
-        schedule_delayed_work(&dbs_work,
+        int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
-                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
+        delay -= jiffies % delay;
-        return;
+        dbs_info->enable = 1;
+        INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
+        queue_delayed_work_on(dbs_info->cpu, kconservative_wq, &dbs_info->work,
+                                delay);
 }
-static inline void dbs_timer_exit(void)
+static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
 {
-        cancel_delayed_work(&dbs_work);
+        dbs_info->enable = 0;
-        return;
+        cancel_delayed_work(&dbs_info->work);
 }
 static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
@@ -503,11 +576,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
                        j_dbs_info->cur_policy = policy;
-                        j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);
+                        j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j,
-                        j_dbs_info->prev_cpu_idle_down
+                                                &j_dbs_info->prev_cpu_wall);
-                                = j_dbs_info->prev_cpu_idle_up;
+                        if (dbs_tuners_ins.ignore_nice) {
+                                j_dbs_info->prev_cpu_nice =
+                                                kstat_cpu(j).cpustat.nice;
+                        }
                }
-                this_dbs_info->enable = 1;
                this_dbs_info->down_skip = 0;
                this_dbs_info->requested_freq = policy->cur;
@@ -523,38 +598,36 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        if (latency == 0)
                                latency = 1;
-                        def_sampling_rate = 10 * latency *
+                        def_sampling_rate =
-                                        DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
+                                max(latency * LATENCY_MULTIPLIER,
+                                    MIN_STAT_SAMPLING_RATE);
-                        if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
-                                def_sampling_rate = MIN_STAT_SAMPLING_RATE;
                        dbs_tuners_ins.sampling_rate = def_sampling_rate;
-                        dbs_timer_init();
                        cpufreq_register_notifier(
                                        &dbs_cpufreq_notifier_block,
                                        CPUFREQ_TRANSITION_NOTIFIER);
                }
+                dbs_timer_init(this_dbs_info);
                mutex_unlock(&dbs_mutex);
                break;
        case CPUFREQ_GOV_STOP:
                mutex_lock(&dbs_mutex);
-                this_dbs_info->enable = 0;
+                dbs_timer_exit(this_dbs_info);
                sysfs_remove_group(&policy->kobj, &dbs_attr_group);
                dbs_enable--;
                /*
                 * Stop the timerschedule work, when this governor
                 * is used for first time
                 */
-                if (dbs_enable == 0) {
+                if (dbs_enable == 0)
-                        dbs_timer_exit();
                        cpufreq_unregister_notifier(
                                        &dbs_cpufreq_notifier_block,
                                        CPUFREQ_TRANSITION_NOTIFIER);
-                }
                mutex_unlock(&dbs_mutex);
@@ -571,6 +644,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                        this_dbs_info->cur_policy,
                                        policy->min, CPUFREQ_RELATION_L);
                mutex_unlock(&dbs_mutex);
                break;
        }
        return 0;
@@ -588,23 +662,33 @@ struct cpufreq_governor cpufreq_gov_conservative = {
 static int __init cpufreq_gov_dbs_init(void)
 {
-        return cpufreq_register_governor(&cpufreq_gov_conservative);
+        int err;
+        kconservative_wq = create_workqueue("kconservative");
+        if (!kconservative_wq) {
+                printk(KERN_ERR "Creation of kconservative failed\n");
+                return -EFAULT;
+        }
+        err = cpufreq_register_governor(&cpufreq_gov_conservative);
+        if (err)
+                destroy_workqueue(kconservative_wq);
+        return err;
 }
 static void __exit cpufreq_gov_dbs_exit(void)
 {
-        /* Make sure that the scheduled work is indeed not running */
-        flush_scheduled_work();
        cpufreq_unregister_governor(&cpufreq_gov_conservative);
+        destroy_workqueue(kconservative_wq);
 }
-MODULE_AUTHOR ("Alexander Clouter <alex-kernel@digriz.org.uk>");
+MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
-MODULE_DESCRIPTION ("'cpufreq_conservative' - A dynamic cpufreq governor for "
+MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "
                "Low Latency Frequency Transition capable processors "
                "optimised for use in a battery environment");
-MODULE_LICENSE ("GPL");
+MODULE_LICENSE("GPL");
 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
 fs_initcall(cpufreq_gov_dbs_init);
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 6f45b1658a67..338f428a15b7 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -21,6 +21,7 @@
 #include <linux/hrtimer.h>
 #include <linux/tick.h>
 #include <linux/ktime.h>
+#include <linux/sched.h>
 /*
 * dbs is used in this file as a shortform for demandbased switching
@@ -51,8 +52,20 @@ static unsigned int def_sampling_rate;
                        (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
 #define MIN_SAMPLING_RATE                       \
                        (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
+/* Above MIN_SAMPLING_RATE will vanish with its sysfs file soon
+ * Define the minimal settable sampling rate to the greater of:
+ *   - "HW transition latency" * 100 (same as default sampling / 10)
+ *   - MIN_STAT_SAMPLING_RATE
+ * To avoid that userspace shoots itself.
+*/
+static unsigned int minimum_sampling_rate(void)
+{
+        return max(def_sampling_rate / 10, MIN_STAT_SAMPLING_RATE);
+}
+/* This will also vanish soon with removing sampling_rate_max */
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
-#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
+#define LATENCY_MULTIPLIER                      (1000)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000 * 1000)
 static void do_dbs_timer(struct work_struct *work);
@@ -65,14 +78,14 @@ struct cpu_dbs_info_s {
        cputime64_t prev_cpu_wall;
        cputime64_t prev_cpu_nice;
        struct cpufreq_policy *cur_policy;
-        struct delayed_work work;
+        struct delayed_work work;
        struct cpufreq_frequency_table *freq_table;
        unsigned int freq_lo;
        unsigned int freq_lo_jiffies;
        unsigned int freq_hi_jiffies;
        int cpu;
        unsigned int enable:1,
-                     sample_type:1;
+                sample_type:1;
 };
 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
@@ -203,12 +216,28 @@ static void ondemand_powersave_bias_init(void)
 /************************** sysfs interface ************************/
 static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
 {
-        return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
+        static int print_once;
+        if (!print_once) {
+                printk(KERN_INFO "CPUFREQ: ondemand sampling_rate_max "
+                       "sysfs file is deprecated - used by: %s\n",
+                       current->comm);
+                print_once = 1;
+        }
+        return sprintf(buf, "%u\n", MAX_SAMPLING_RATE);
 }
 static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
 {
-        return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
+        static int print_once;
+        if (!print_once) {
+                printk(KERN_INFO "CPUFREQ: ondemand sampling_rate_min "
+                       "sysfs file is deprecated - used by: %s\n",
+                       current->comm);
+                print_once = 1;
+        }
+        return sprintf(buf, "%u\n", MIN_SAMPLING_RATE);
 }
 #define define_one_ro(_name)            \
@@ -238,13 +267,11 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
        ret = sscanf(buf, "%u", &input);
        mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > MAX_SAMPLING_RATE
+        if (ret != 1) {
-                     || input < MIN_SAMPLING_RATE) {
                mutex_unlock(&dbs_mutex);
                return -EINVAL;
        }
+        dbs_tuners_ins.sampling_rate = max(input, minimum_sampling_rate());
-        dbs_tuners_ins.sampling_rate = input;
        mutex_unlock(&dbs_mutex);
        return count;
@@ -279,14 +306,14 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
        unsigned int j;
        ret = sscanf(buf, "%u", &input);
-        if ( ret != 1 )
+        if (ret != 1)
                return -EINVAL;
-        if ( input > 1 )
+        if (input > 1)
                input = 1;
        mutex_lock(&dbs_mutex);
-        if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
+        if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */
                mutex_unlock(&dbs_mutex);
                return count;
        }
@@ -337,7 +364,7 @@ define_one_rw(up_threshold);
 define_one_rw(ignore_nice_load);
 define_one_rw(powersave_bias);
-static struct attribute * dbs_attributes[] = {
+static struct attribute *dbs_attributes[] = {
        &sampling_rate_max.attr,
        &sampling_rate_min.attr,
        &sampling_rate.attr,
@@ -512,8 +539,7 @@ static void do_dbs_timer(struct work_struct *work)
                }
        } else {
                __cpufreq_driver_target(dbs_info->cur_policy,
-                                        dbs_info->freq_lo,
+                        dbs_info->freq_lo, CPUFREQ_RELATION_H);
-                                        CPUFREQ_RELATION_H);
        }
        queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
        unlock_policy_rwsem_write(cpu);
@@ -530,7 +556,7 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
        dbs_info->sample_type = DBS_NORMAL_SAMPLE;
        INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
        queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work,
-                              delay);
+                delay);
 }
 static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
@@ -591,11 +617,9 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        if (latency == 0)
                                latency = 1;
-                        def_sampling_rate = latency *
+                        def_sampling_rate =
-                                        DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
+                                max(latency * LATENCY_MULTIPLIER,
+                                    MIN_STAT_SAMPLING_RATE);
-                        if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
-                                def_sampling_rate = MIN_STAT_SAMPLING_RATE;
                        dbs_tuners_ins.sampling_rate = def_sampling_rate;
                }
@@ -617,12 +641,10 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                mutex_lock(&dbs_mutex);
                if (policy->max < this_dbs_info->cur_policy->cur)
                        __cpufreq_driver_target(this_dbs_info->cur_policy,
-                                                policy->max,
+                                policy->max, CPUFREQ_RELATION_H);
-                                                CPUFREQ_RELATION_H);
                else if (policy->min > this_dbs_info->cur_policy->cur)
                        __cpufreq_driver_target(this_dbs_info->cur_policy,
-                                                policy->min,
+                                policy->min, CPUFREQ_RELATION_L);
-                                                CPUFREQ_RELATION_L);
                mutex_unlock(&dbs_mutex);
                break;
        }
@@ -677,7 +699,7 @@ static void __exit cpufreq_gov_dbs_exit(void)
 MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>");
 MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>");
 MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for "
-                   "Low Latency Frequency Transition capable processors");
+        "Low Latency Frequency Transition capable processors");
 MODULE_LICENSE("GPL");
 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index c0ff97d375d7..5a62d678dd19 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -2,7 +2,7 @@
 *  drivers/cpufreq/cpufreq_stats.c
 *
 *  Copyright (C) 2003-2004 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
- *            (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
+ *  (C) 2004 Zou Nan hai <nanhai.zou@intel.com>.
 *
 * 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
@@ -23,7 +23,7 @@
 static spinlock_t cpufreq_stats_lock;
-#define CPUFREQ_STATDEVICE_ATTR(_name,_mode,_show) \
+#define CPUFREQ_STATDEVICE_ATTR(_name, _mode, _show) \
 static struct freq_attr _attr_##_name = {\
        .attr = {.name = __stringify(_name), .mode = _mode, }, \
        .show = _show,\
@@ -50,8 +50,7 @@ struct cpufreq_stats_attribute {
        ssize_t(*show) (struct cpufreq_stats *, char *);
 };
-static int
+static int cpufreq_stats_update(unsigned int cpu)
-cpufreq_stats_update (unsigned int cpu)
 {
        struct cpufreq_stats *stat;
        unsigned long long cur_time;
@@ -68,8 +67,7 @@ cpufreq_stats_update (unsigned int cpu)
        return 0;
 }
-static ssize_t
+static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
-show_total_trans(struct cpufreq_policy *policy, char *buf)
 {
        struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
        if (!stat)
@@ -78,8 +76,7 @@ show_total_trans(struct cpufreq_policy *policy, char *buf)
                        per_cpu(cpufreq_stats_table, stat->cpu)->total_trans);
 }
-static ssize_t
+static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
-show_time_in_state(struct cpufreq_policy *policy, char *buf)
 {
        ssize_t len = 0;
        int i;
@@ -89,14 +86,14 @@ show_time_in_state(struct cpufreq_policy *policy, char *buf)
        cpufreq_stats_update(stat->cpu);
        for (i = 0; i < stat->state_num; i++) {
                len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i],
-                        (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i]));
+                        (unsigned long long)
+                        cputime64_to_clock_t(stat->time_in_state[i]));
        }
        return len;
 }
 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
-static ssize_t
+static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)
-show_trans_table(struct cpufreq_policy *policy, char *buf)
 {
        ssize_t len = 0;
        int i, j;
@@ -139,11 +136,11 @@ show_trans_table(struct cpufreq_policy *policy, char *buf)
                return PAGE_SIZE;
        return len;
 }
-CPUFREQ_STATDEVICE_ATTR(trans_table,0444,show_trans_table);
+CPUFREQ_STATDEVICE_ATTR(trans_table, 0444, show_trans_table);
 #endif
-CPUFREQ_STATDEVICE_ATTR(total_trans,0444,show_total_trans);
+CPUFREQ_STATDEVICE_ATTR(total_trans, 0444, show_total_trans);
-CPUFREQ_STATDEVICE_ATTR(time_in_state,0444,show_time_in_state);
+CPUFREQ_STATDEVICE_ATTR(time_in_state, 0444, show_time_in_state);
 static struct attribute *default_attrs[] = {
        &_attr_total_trans.attr,
@@ -158,8 +155,7 @@ static struct attribute_group stats_attr_group = {
        .name = "stats"
 };
-static int
+static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
-freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
 {
        int index;
        for (index = 0; index < stat->max_state; index++)
@@ -183,8 +179,7 @@ static void cpufreq_stats_free_table(unsigned int cpu)
                cpufreq_cpu_put(policy);
 }
-static int
+static int cpufreq_stats_create_table(struct cpufreq_policy *policy,
-cpufreq_stats_create_table (struct cpufreq_policy *policy,
                struct cpufreq_frequency_table *table)
 {
        unsigned int i, j, count = 0, ret = 0;
@@ -194,7 +189,8 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
        unsigned int cpu = policy->cpu;
        if (per_cpu(cpufreq_stats_table, cpu))
                return -EBUSY;
-        if ((stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL)) == NULL)
+        stat = kzalloc(sizeof(struct cpufreq_stats), GFP_KERNEL);
+        if ((stat) == NULL)
                return -ENOMEM;
        data = cpufreq_cpu_get(cpu);
@@ -203,13 +199,14 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
                goto error_get_fail;
        }
-        if ((ret = sysfs_create_group(&data->kobj, &stats_attr_group)))
+        ret = sysfs_create_group(&data->kobj, &stats_attr_group);
+        if (ret)
                goto error_out;
        stat->cpu = cpu;
        per_cpu(cpufreq_stats_table, cpu) = stat;
-        for (i=0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
+        for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
                unsigned int freq = table[i].frequency;
                if (freq == CPUFREQ_ENTRY_INVALID)
                        continue;
@@ -255,9 +252,8 @@ error_get_fail:
        return ret;
 }
-static int
+static int cpufreq_stat_notifier_policy(struct notifier_block *nb,
-cpufreq_stat_notifier_policy (struct notifier_block *nb, unsigned long val,
+                unsigned long val, void *data)
-                void *data)
 {
        int ret;
        struct cpufreq_policy *policy = data;
@@ -268,14 +264,14 @@ cpufreq_stat_notifier_policy (struct notifier_block *nb, unsigned long val,
        table = cpufreq_frequency_get_table(cpu);
        if (!table)
                return 0;
-        if ((ret = cpufreq_stats_create_table(policy, table)))
+        ret = cpufreq_stats_create_table(policy, table);
+        if (ret)
                return ret;
        return 0;
 }
-static int
+static int cpufreq_stat_notifier_trans(struct notifier_block *nb,
-cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val,
+                unsigned long val, void *data)
-                void *data)
 {
        struct cpufreq_freqs *freq = data;
        struct cpufreq_stats *stat;
@@ -340,19 +336,20 @@ static struct notifier_block notifier_trans_block = {
        .notifier_call = cpufreq_stat_notifier_trans
 };
-static int
+static int __init cpufreq_stats_init(void)
-__init cpufreq_stats_init(void)
 {
        int ret;
        unsigned int cpu;
        spin_lock_init(&cpufreq_stats_lock);
-        if ((ret = cpufreq_register_notifier(&notifier_policy_block,
+        ret = cpufreq_register_notifier(&notifier_policy_block,
-                                CPUFREQ_POLICY_NOTIFIER)))
+                                CPUFREQ_POLICY_NOTIFIER);
+        if (ret)
                return ret;
-        if ((ret = cpufreq_register_notifier(&notifier_trans_block,
+        ret = cpufreq_register_notifier(&notifier_trans_block,
-                                CPUFREQ_TRANSITION_NOTIFIER))) {
+                                CPUFREQ_TRANSITION_NOTIFIER);
+        if (ret) {
                cpufreq_unregister_notifier(&notifier_policy_block,
                                CPUFREQ_POLICY_NOTIFIER);
                return ret;
@@ -364,8 +361,7 @@ __init cpufreq_stats_init(void)
        }
        return 0;
 }
-static void
+static void __exit cpufreq_stats_exit(void)
-__exit cpufreq_stats_exit(void)
 {
        unsigned int cpu;
@@ -379,10 +375,10 @@ __exit cpufreq_stats_exit(void)
        }
 }
-MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>");
+MODULE_AUTHOR("Zou Nan hai <nanhai.zou@intel.com>");
-MODULE_DESCRIPTION ("'cpufreq_stats' - A driver to export cpufreq stats "
+MODULE_DESCRIPTION("'cpufreq_stats' - A driver to export cpufreq stats "
                                "through sysfs filesystem");
-MODULE_LICENSE ("GPL");
+MODULE_LICENSE("GPL");
 module_init(cpufreq_stats_init);
 module_exit(cpufreq_stats_exit);
diff --git a/drivers/cpufreq/cpufreq_userspace.c b/drivers/cpufreq/cpufreq_userspace.c
index 1442bbada053..66d2d1d6c80f 100644
--- a/drivers/cpufreq/cpufreq_userspace.c
+++ b/drivers/cpufreq/cpufreq_userspace.c
@@ -24,9 +24,6 @@
 #include <linux/sysfs.h>
 #include <linux/mutex.h>
-#include <asm/uaccess.h>
 /**
 * A few values needed by the userspace governor
 */
@@ -37,7 +34,7 @@ static DEFINE_PER_CPU(unsigned int, cpu_set_freq); /* CPU freq desired by
                                                        userspace */
 static DEFINE_PER_CPU(unsigned int, cpu_is_managed);
-static DEFINE_MUTEX     (userspace_mutex);
+static DEFINE_MUTEX(userspace_mutex);
 static int cpus_using_userspace_governor;
 #define dprintk(msg...) \
@@ -46,9 +43,9 @@ static int cpus_using_userspace_governor;
 /* keep track of frequency transitions */
 static int
 userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
-                       void *data)
+        void *data)
 {
-        struct cpufreq_freqs *freq = data;
+        struct cpufreq_freqs *freq = data;
        if (!per_cpu(cpu_is_managed, freq->cpu))
                return 0;
@@ -57,11 +54,11 @@ userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
                        freq->cpu, freq->new);
        per_cpu(cpu_cur_freq, freq->cpu) = freq->new;
-        return 0;
+        return 0;
 }
 static struct notifier_block userspace_cpufreq_notifier_block = {
-        .notifier_call  = userspace_cpufreq_notifier
+        .notifier_call  = userspace_cpufreq_notifier
 };
@@ -93,8 +90,11 @@ static int cpufreq_set(struct cpufreq_policy *policy, unsigned int freq)
         * We're safe from concurrent calls to ->target() here
         * as we hold the userspace_mutex lock. If we were calling
         * cpufreq_driver_target, a deadlock situation might occur:
-         * A: cpufreq_set (lock userspace_mutex) -> cpufreq_driver_target(lock policy->lock)
+         * A: cpufreq_set (lock userspace_mutex) ->
-         * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_mutex)
+         *      cpufreq_driver_target(lock policy->lock)
+         * B: cpufreq_set_policy(lock policy->lock) ->
+         *      __cpufreq_governor ->
+         *         cpufreq_governor_userspace (lock userspace_mutex)
         */
        ret = __cpufreq_driver_target(policy, freq, CPUFREQ_RELATION_L);
@@ -210,9 +210,10 @@ static void __exit cpufreq_gov_userspace_exit(void)
 }
-MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>, Russell King <rmk@arm.linux.org.uk>");
+MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>, "
-MODULE_DESCRIPTION ("CPUfreq policy governor 'userspace'");
+                "Russell King <rmk@arm.linux.org.uk>");
-MODULE_LICENSE ("GPL");
+MODULE_DESCRIPTION("CPUfreq policy governor 'userspace'");
+MODULE_LICENSE("GPL");
 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE
 fs_initcall(cpufreq_gov_userspace_init);
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index 9071d80fbba2..a9bd3a05a684 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -28,7 +28,7 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
        unsigned int max_freq = 0;
        unsigned int i;
-        for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                unsigned int freq = table[i].frequency;
                if (freq == CPUFREQ_ENTRY_INVALID) {
                        dprintk("table entry %u is invalid, skipping\n", i);
@@ -70,7 +70,7 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
        cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
                                     policy->cpuinfo.max_freq);
-        for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                unsigned int freq = table[i].frequency;
                if (freq == CPUFREQ_ENTRY_INVALID)
                        continue;
@@ -125,13 +125,13 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
        if (!cpu_online(policy->cpu))
                return -EINVAL;
-        for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                unsigned int freq = table[i].frequency;
                if (freq == CPUFREQ_ENTRY_INVALID)
                        continue;
                if ((freq < policy->min) || (freq > policy->max))
                        continue;
-                switch(relation) {
+                switch (relation) {
                case CPUFREQ_RELATION_H:
                        if (freq <= target_freq) {
                                if (freq >= optimal.frequency) {
@@ -178,7 +178,7 @@ static DEFINE_PER_CPU(struct cpufreq_frequency_table *, show_table);
 /**
 * show_available_freqs - show available frequencies for the specified CPU
 */
-static ssize_t show_available_freqs (struct cpufreq_policy *policy, char *buf)
+static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf)
 {
        unsigned int i = 0;
        unsigned int cpu = policy->cpu;
@@ -190,7 +190,7 @@ static ssize_t show_available_freqs (struct cpufreq_policy *policy, char *buf)
        table = per_cpu(show_table, cpu);
-        for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
                        continue;
                count += sprintf(&buf[count], "%d ", table[i].frequency);
@@ -234,6 +234,6 @@ struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
 }
 EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
-MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>");
+MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
-MODULE_DESCRIPTION ("CPUfreq frequency table helpers");
+MODULE_DESCRIPTION("CPUfreq frequency table helpers");
-MODULE_LICENSE ("GPL");
+MODULE_LICENSE("GPL");
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index e522144cba3a..01afd758072f 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -86,7 +86,7 @@ config ZCRYPT_MONOLITHIC
 config CRYPTO_SHA1_S390
        tristate "SHA1 digest algorithm"
        depends on S390
-        select CRYPTO_ALGAPI
+        select CRYPTO_HASH
        help
          This is the s390 hardware accelerated implementation of the
          SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
@@ -94,7 +94,7 @@ config CRYPTO_SHA1_S390
 config CRYPTO_SHA256_S390
        tristate "SHA256 digest algorithm"
        depends on S390
-        select CRYPTO_ALGAPI
+        select CRYPTO_HASH
        help
          This is the s390 hardware accelerated implementation of the
          SHA256 secure hash standard (DFIPS 180-2).
@@ -105,7 +105,7 @@ config CRYPTO_SHA256_S390
 config CRYPTO_SHA512_S390
        tristate "SHA384 and SHA512 digest algorithm"
        depends on S390
-        select CRYPTO_ALGAPI
+        select CRYPTO_HASH
        help
          This is the s390 hardware accelerated implementation of the
          SHA512 secure hash standard.
@@ -200,4 +200,13 @@ config CRYPTO_DEV_IXP4XX
        help
          Driver for the IXP4xx NPE crypto engine.
+config CRYPTO_DEV_PPC4XX
+        tristate "Driver AMCC PPC4xx crypto accelerator"
+        depends on PPC && 4xx
+        select CRYPTO_HASH
+        select CRYPTO_ALGAPI
+        select CRYPTO_BLKCIPHER
+        help
+          This option allows you to have support for AMCC crypto acceleration.
 endif # CRYPTO_HW
diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile
index 73557b2968d3..9bf4a2bc8846 100644
--- a/drivers/crypto/Makefile
+++ b/drivers/crypto/Makefile
@@ -4,3 +4,4 @@ obj-$(CONFIG_CRYPTO_DEV_GEODE) += geode-aes.o
 obj-$(CONFIG_CRYPTO_DEV_HIFN_795X) += hifn_795x.o
 obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o
 obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o
+obj-$(CONFIG_CRYPTO_DEV_PPC4XX) += amcc/
diff --git a/drivers/crypto/amcc/Makefile b/drivers/crypto/amcc/Makefile
new file mode 100644
index 000000000000..aa376e8d5ed5
--- /dev/null
+++ b/drivers/crypto/amcc/Makefile
@@ -0,0 +1,2 @@
+obj-$(CONFIG_CRYPTO_DEV_PPC4XX) += crypto4xx.o
+crypto4xx-objs :=  crypto4xx_core.o crypto4xx_alg.o crypto4xx_sa.o
diff --git a/drivers/crypto/amcc/crypto4xx_alg.c b/drivers/crypto/amcc/crypto4xx_alg.c
new file mode 100644
index 000000000000..61b6e1bec8c6
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_alg.c
@@ -0,0 +1,293 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This file implements the Linux crypto algorithms.
+ */
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock_types.h>
+#include <linux/scatterlist.h>
+#include <linux/crypto.h>
+#include <linux/hash.h>
+#include <crypto/internal/hash.h>
+#include <linux/dma-mapping.h>
+#include <crypto/algapi.h>
+#include <crypto/aes.h>
+#include <crypto/sha.h>
+#include "crypto4xx_reg_def.h"
+#include "crypto4xx_sa.h"
+#include "crypto4xx_core.h"
+void set_dynamic_sa_command_0(struct dynamic_sa_ctl *sa, u32 save_h,
+                              u32 save_iv, u32 ld_h, u32 ld_iv, u32 hdr_proc,
+                              u32 h, u32 c, u32 pad_type, u32 op_grp, u32 op,
+                              u32 dir)
+{
+        sa->sa_command_0.w = 0;
+        sa->sa_command_0.bf.save_hash_state = save_h;
+        sa->sa_command_0.bf.save_iv = save_iv;
+        sa->sa_command_0.bf.load_hash_state = ld_h;
+        sa->sa_command_0.bf.load_iv = ld_iv;
+        sa->sa_command_0.bf.hdr_proc = hdr_proc;
+        sa->sa_command_0.bf.hash_alg = h;
+        sa->sa_command_0.bf.cipher_alg = c;
+        sa->sa_command_0.bf.pad_type = pad_type & 3;
+        sa->sa_command_0.bf.extend_pad = pad_type >> 2;
+        sa->sa_command_0.bf.op_group = op_grp;
+        sa->sa_command_0.bf.opcode = op;
+        sa->sa_command_0.bf.dir = dir;
+}
+void set_dynamic_sa_command_1(struct dynamic_sa_ctl *sa, u32 cm, u32 hmac_mc,
+                              u32 cfb, u32 esn, u32 sn_mask, u32 mute,
+                              u32 cp_pad, u32 cp_pay, u32 cp_hdr)
+{
+        sa->sa_command_1.w = 0;
+        sa->sa_command_1.bf.crypto_mode31 = (cm & 4) >> 2;
+        sa->sa_command_1.bf.crypto_mode9_8 = cm & 3;
+        sa->sa_command_1.bf.feedback_mode = cfb,
+        sa->sa_command_1.bf.sa_rev = 1;
+        sa->sa_command_1.bf.extended_seq_num = esn;
+        sa->sa_command_1.bf.seq_num_mask = sn_mask;
+        sa->sa_command_1.bf.mutable_bit_proc = mute;
+        sa->sa_command_1.bf.copy_pad = cp_pad;
+        sa->sa_command_1.bf.copy_payload = cp_pay;
+        sa->sa_command_1.bf.copy_hdr = cp_hdr;
+}
+int crypto4xx_encrypt(struct ablkcipher_request *req)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
+        ctx->direction = DIR_OUTBOUND;
+        ctx->hash_final = 0;
+        ctx->is_hash = 0;
+        ctx->pd_ctl = 0x1;
+        return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,
+                                  req->nbytes, req->info,
+                                  get_dynamic_sa_iv_size(ctx));
+}
+int crypto4xx_decrypt(struct ablkcipher_request *req)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
+        ctx->direction = DIR_INBOUND;
+        ctx->hash_final = 0;
+        ctx->is_hash = 0;
+        ctx->pd_ctl = 1;
+        return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,
+                                  req->nbytes, req->info,
+                                  get_dynamic_sa_iv_size(ctx));
+}
+/**
+ * AES Functions
+ */
+static int crypto4xx_setkey_aes(struct crypto_ablkcipher *cipher,
+                                const u8 *key,
+                                unsigned int keylen,
+                                unsigned char cm,
+                                u8 fb)
+{
+        struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm);
+        struct dynamic_sa_ctl *sa;
+        int    rc;
+        if (keylen != AES_KEYSIZE_256 &&
+                keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_128) {
+                crypto_ablkcipher_set_flags(cipher,
+                                CRYPTO_TFM_RES_BAD_KEY_LEN);
+                return -EINVAL;
+        }
+        /* Create SA */
+        if (ctx->sa_in_dma_addr || ctx->sa_out_dma_addr)
+                crypto4xx_free_sa(ctx);
+        rc = crypto4xx_alloc_sa(ctx, SA_AES128_LEN + (keylen-16) / 4);
+        if (rc)
+                return rc;
+        if (ctx->state_record_dma_addr == 0) {
+                rc = crypto4xx_alloc_state_record(ctx);
+                if (rc) {
+                        crypto4xx_free_sa(ctx);
+                        return rc;
+                }
+        }
+        /* Setup SA */
+        sa = (struct dynamic_sa_ctl *) ctx->sa_in;
+        ctx->hash_final = 0;
+        set_dynamic_sa_command_0(sa, SA_NOT_SAVE_HASH, SA_NOT_SAVE_IV,
+                                 SA_LOAD_HASH_FROM_SA, SA_LOAD_IV_FROM_STATE,
+                                 SA_NO_HEADER_PROC, SA_HASH_ALG_NULL,
+                                 SA_CIPHER_ALG_AES, SA_PAD_TYPE_ZERO,
+                                 SA_OP_GROUP_BASIC, SA_OPCODE_DECRYPT,
+                                 DIR_INBOUND);
+        set_dynamic_sa_command_1(sa, cm, SA_HASH_MODE_HASH,
+                                 fb, SA_EXTENDED_SN_OFF,
+                                 SA_SEQ_MASK_OFF, SA_MC_ENABLE,
+                                 SA_NOT_COPY_PAD, SA_NOT_COPY_PAYLOAD,
+                                 SA_NOT_COPY_HDR);
+        crypto4xx_memcpy_le(ctx->sa_in + get_dynamic_sa_offset_key_field(ctx),
+                            key, keylen);
+        sa->sa_contents = SA_AES_CONTENTS | (keylen << 2);
+        sa->sa_command_1.bf.key_len = keylen >> 3;
+        ctx->is_hash = 0;
+        ctx->direction = DIR_INBOUND;
+        memcpy(ctx->sa_in + get_dynamic_sa_offset_state_ptr_field(ctx),
+                        (void *)&ctx->state_record_dma_addr, 4);
+        ctx->offset_to_sr_ptr = get_dynamic_sa_offset_state_ptr_field(ctx);
+        memcpy(ctx->sa_out, ctx->sa_in, ctx->sa_len * 4);
+        sa = (struct dynamic_sa_ctl *) ctx->sa_out;
+        sa->sa_command_0.bf.dir = DIR_OUTBOUND;
+        return 0;
+}
+int crypto4xx_setkey_aes_cbc(struct crypto_ablkcipher *cipher,
+                             const u8 *key, unsigned int keylen)
+{
+        return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_CBC,
+                                    CRYPTO_FEEDBACK_MODE_NO_FB);
+}
+/**
+ * HASH SHA1 Functions
+ */
+static int crypto4xx_hash_alg_init(struct crypto_tfm *tfm,
+                                   unsigned int sa_len,
+                                   unsigned char ha,
+                                   unsigned char hm)
+{
+        struct crypto_alg *alg = tfm->__crt_alg;
+        struct crypto4xx_alg *my_alg = crypto_alg_to_crypto4xx_alg(alg);
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm);
+        struct dynamic_sa_ctl *sa;
+        struct dynamic_sa_hash160 *sa_in;
+        int rc;
+        ctx->dev   = my_alg->dev;
+        ctx->is_hash = 1;
+        ctx->hash_final = 0;
+        /* Create SA */
+        if (ctx->sa_in_dma_addr || ctx->sa_out_dma_addr)
+                crypto4xx_free_sa(ctx);
+        rc = crypto4xx_alloc_sa(ctx, sa_len);
+        if (rc)
+                return rc;
+        if (ctx->state_record_dma_addr == 0) {
+                crypto4xx_alloc_state_record(ctx);
+                if (!ctx->state_record_dma_addr) {
+                        crypto4xx_free_sa(ctx);
+                        return -ENOMEM;
+                }
+        }
+        tfm->crt_ahash.reqsize = sizeof(struct crypto4xx_ctx);
+        sa = (struct dynamic_sa_ctl *) ctx->sa_in;
+        set_dynamic_sa_command_0(sa, SA_SAVE_HASH, SA_NOT_SAVE_IV,
+                                 SA_NOT_LOAD_HASH, SA_LOAD_IV_FROM_SA,
+                                 SA_NO_HEADER_PROC, ha, SA_CIPHER_ALG_NULL,
+                                 SA_PAD_TYPE_ZERO, SA_OP_GROUP_BASIC,
+                                 SA_OPCODE_HASH, DIR_INBOUND);
+        set_dynamic_sa_command_1(sa, 0, SA_HASH_MODE_HASH,
+                                 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF,
+                                 SA_SEQ_MASK_OFF, SA_MC_ENABLE,
+                                 SA_NOT_COPY_PAD, SA_NOT_COPY_PAYLOAD,
+                                 SA_NOT_COPY_HDR);
+        ctx->direction = DIR_INBOUND;
+        sa->sa_contents = SA_HASH160_CONTENTS;
+        sa_in = (struct dynamic_sa_hash160 *) ctx->sa_in;
+        /* Need to zero hash digest in SA */
+        memset(sa_in->inner_digest, 0, sizeof(sa_in->inner_digest));
+        memset(sa_in->outer_digest, 0, sizeof(sa_in->outer_digest));
+        sa_in->state_ptr = ctx->state_record_dma_addr;
+        ctx->offset_to_sr_ptr = get_dynamic_sa_offset_state_ptr_field(ctx);
+        return 0;
+}
+int crypto4xx_hash_init(struct ahash_request *req)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
+        int ds;
+        struct dynamic_sa_ctl *sa;
+        sa = (struct dynamic_sa_ctl *) ctx->sa_in;
+        ds = crypto_ahash_digestsize(
+                        __crypto_ahash_cast(req->base.tfm));
+        sa->sa_command_0.bf.digest_len = ds >> 2;
+        sa->sa_command_0.bf.load_hash_state = SA_LOAD_HASH_FROM_SA;
+        ctx->is_hash = 1;
+        ctx->direction = DIR_INBOUND;
+        return 0;
+}
+int crypto4xx_hash_update(struct ahash_request *req)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
+        ctx->is_hash = 1;
+        ctx->hash_final = 0;
+        ctx->pd_ctl = 0x11;
+        ctx->direction = DIR_INBOUND;
+        return crypto4xx_build_pd(&req->base, ctx, req->src,
+                                  (struct scatterlist *) req->result,
+                                  req->nbytes, NULL, 0);
+}
+int crypto4xx_hash_final(struct ahash_request *req)
+{
+        return 0;
+}
+int crypto4xx_hash_digest(struct ahash_request *req)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
+        ctx->hash_final = 1;
+        ctx->pd_ctl = 0x11;
+        ctx->direction = DIR_INBOUND;
+        return crypto4xx_build_pd(&req->base, ctx, req->src,
+                                  (struct scatterlist *) req->result,
+                                  req->nbytes, NULL, 0);
+}
+/**
+ * SHA1 Algorithm
+ */
+int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm)
+{
+        return crypto4xx_hash_alg_init(tfm, SA_HASH160_LEN, SA_HASH_ALG_SHA1,
+                                       SA_HASH_MODE_HASH);
+}
diff --git a/drivers/crypto/amcc/crypto4xx_core.c b/drivers/crypto/amcc/crypto4xx_core.c
new file mode 100644
index 000000000000..4c0dfb2b872e
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_core.c
@@ -0,0 +1,1310 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This file implements AMCC crypto offload Linux device driver for use with
+ * Linux CryptoAPI.
+ */
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock_types.h>
+#include <linux/random.h>
+#include <linux/scatterlist.h>
+#include <linux/crypto.h>
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/of_platform.h>
+#include <asm/dcr.h>
+#include <asm/dcr-regs.h>
+#include <asm/cacheflush.h>
+#include <crypto/internal/hash.h>
+#include <crypto/algapi.h>
+#include <crypto/aes.h>
+#include <crypto/sha.h>
+#include "crypto4xx_reg_def.h"
+#include "crypto4xx_core.h"
+#include "crypto4xx_sa.h"
+#define PPC4XX_SEC_VERSION_STR                  "0.5"
+/**
+ * PPC4xx Crypto Engine Initialization Routine
+ */
+static void crypto4xx_hw_init(struct crypto4xx_device *dev)
+{
+        union ce_ring_size ring_size;
+        union ce_ring_contol ring_ctrl;
+        union ce_part_ring_size part_ring_size;
+        union ce_io_threshold io_threshold;
+        u32 rand_num;
+        union ce_pe_dma_cfg pe_dma_cfg;
+        writel(PPC4XX_BYTE_ORDER, dev->ce_base + CRYPTO4XX_BYTE_ORDER_CFG);
+        /* setup pe dma, include reset sg, pdr and pe, then release reset */
+        pe_dma_cfg.w = 0;
+        pe_dma_cfg.bf.bo_sgpd_en = 1;
+        pe_dma_cfg.bf.bo_data_en = 0;
+        pe_dma_cfg.bf.bo_sa_en = 1;
+        pe_dma_cfg.bf.bo_pd_en = 1;
+        pe_dma_cfg.bf.dynamic_sa_en = 1;
+        pe_dma_cfg.bf.reset_sg = 1;
+        pe_dma_cfg.bf.reset_pdr = 1;
+        pe_dma_cfg.bf.reset_pe = 1;
+        writel(pe_dma_cfg.w, dev->ce_base + CRYPTO4XX_PE_DMA_CFG);
+        /* un reset pe,sg and pdr */
+        pe_dma_cfg.bf.pe_mode = 0;
+        pe_dma_cfg.bf.reset_sg = 0;
+        pe_dma_cfg.bf.reset_pdr = 0;
+        pe_dma_cfg.bf.reset_pe = 0;
+        pe_dma_cfg.bf.bo_td_en = 0;
+        writel(pe_dma_cfg.w, dev->ce_base + CRYPTO4XX_PE_DMA_CFG);
+        writel(dev->pdr_pa, dev->ce_base + CRYPTO4XX_PDR_BASE);
+        writel(dev->pdr_pa, dev->ce_base + CRYPTO4XX_RDR_BASE);
+        writel(PPC4XX_PRNG_CTRL_AUTO_EN, dev->ce_base + CRYPTO4XX_PRNG_CTRL);
+        get_random_bytes(&rand_num, sizeof(rand_num));
+        writel(rand_num, dev->ce_base + CRYPTO4XX_PRNG_SEED_L);
+        get_random_bytes(&rand_num, sizeof(rand_num));
+        writel(rand_num, dev->ce_base + CRYPTO4XX_PRNG_SEED_H);
+        ring_size.w = 0;
+        ring_size.bf.ring_offset = PPC4XX_PD_SIZE;
+        ring_size.bf.ring_size   = PPC4XX_NUM_PD;
+        writel(ring_size.w, dev->ce_base + CRYPTO4XX_RING_SIZE);
+        ring_ctrl.w = 0;
+        writel(ring_ctrl.w, dev->ce_base + CRYPTO4XX_RING_CTRL);
+        writel(PPC4XX_DC_3DES_EN, dev->ce_base + CRYPTO4XX_DEVICE_CTRL);
+        writel(dev->gdr_pa, dev->ce_base + CRYPTO4XX_GATH_RING_BASE);
+        writel(dev->sdr_pa, dev->ce_base + CRYPTO4XX_SCAT_RING_BASE);
+        part_ring_size.w = 0;
+        part_ring_size.bf.sdr_size = PPC4XX_SDR_SIZE;
+        part_ring_size.bf.gdr_size = PPC4XX_GDR_SIZE;
+        writel(part_ring_size.w, dev->ce_base + CRYPTO4XX_PART_RING_SIZE);
+        writel(PPC4XX_SD_BUFFER_SIZE, dev->ce_base + CRYPTO4XX_PART_RING_CFG);
+        io_threshold.w = 0;
+        io_threshold.bf.output_threshold = PPC4XX_OUTPUT_THRESHOLD;
+        io_threshold.bf.input_threshold  = PPC4XX_INPUT_THRESHOLD;
+        writel(io_threshold.w, dev->ce_base + CRYPTO4XX_IO_THRESHOLD);
+        writel(0, dev->ce_base + CRYPTO4XX_PDR_BASE_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_RDR_BASE_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_PKT_SRC_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_PKT_DEST_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_SA_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_GATH_RING_BASE_UADDR);
+        writel(0, dev->ce_base + CRYPTO4XX_SCAT_RING_BASE_UADDR);
+        /* un reset pe,sg and pdr */
+        pe_dma_cfg.bf.pe_mode = 1;
+        pe_dma_cfg.bf.reset_sg = 0;
+        pe_dma_cfg.bf.reset_pdr = 0;
+        pe_dma_cfg.bf.reset_pe = 0;
+        pe_dma_cfg.bf.bo_td_en = 0;
+        writel(pe_dma_cfg.w, dev->ce_base + CRYPTO4XX_PE_DMA_CFG);
+        /*clear all pending interrupt*/
+        writel(PPC4XX_INTERRUPT_CLR, dev->ce_base + CRYPTO4XX_INT_CLR);
+        writel(PPC4XX_INT_DESCR_CNT, dev->ce_base + CRYPTO4XX_INT_DESCR_CNT);
+        writel(PPC4XX_INT_DESCR_CNT, dev->ce_base + CRYPTO4XX_INT_DESCR_CNT);
+        writel(PPC4XX_INT_CFG, dev->ce_base + CRYPTO4XX_INT_CFG);
+        writel(PPC4XX_PD_DONE_INT, dev->ce_base + CRYPTO4XX_INT_EN);
+}
+int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
+{
+        ctx->sa_in = dma_alloc_coherent(ctx->dev->core_dev->device, size * 4,
+                                        &ctx->sa_in_dma_addr, GFP_ATOMIC);
+        if (ctx->sa_in == NULL)
+                return -ENOMEM;
+        ctx->sa_out = dma_alloc_coherent(ctx->dev->core_dev->device, size * 4,
+                                         &ctx->sa_out_dma_addr, GFP_ATOMIC);
+        if (ctx->sa_out == NULL) {
+                dma_free_coherent(ctx->dev->core_dev->device,
+                                  ctx->sa_len * 4,
+                                  ctx->sa_in, ctx->sa_in_dma_addr);
+                return -ENOMEM;
+        }
+        memset(ctx->sa_in, 0, size * 4);
+        memset(ctx->sa_out, 0, size * 4);
+        ctx->sa_len = size;
+        return 0;
+}
+void crypto4xx_free_sa(struct crypto4xx_ctx *ctx)
+{
+        if (ctx->sa_in != NULL)
+                dma_free_coherent(ctx->dev->core_dev->device, ctx->sa_len * 4,
+                                  ctx->sa_in, ctx->sa_in_dma_addr);
+        if (ctx->sa_out != NULL)
+                dma_free_coherent(ctx->dev->core_dev->device, ctx->sa_len * 4,
+                                  ctx->sa_out, ctx->sa_out_dma_addr);
+        ctx->sa_in_dma_addr = 0;
+        ctx->sa_out_dma_addr = 0;
+        ctx->sa_len = 0;
+}
+u32 crypto4xx_alloc_state_record(struct crypto4xx_ctx *ctx)
+{
+        ctx->state_record = dma_alloc_coherent(ctx->dev->core_dev->device,
+                                sizeof(struct sa_state_record),
+                                &ctx->state_record_dma_addr, GFP_ATOMIC);
+        if (!ctx->state_record_dma_addr)
+                return -ENOMEM;
+        memset(ctx->state_record, 0, sizeof(struct sa_state_record));
+        return 0;
+}
+void crypto4xx_free_state_record(struct crypto4xx_ctx *ctx)
+{
+        if (ctx->state_record != NULL)
+                dma_free_coherent(ctx->dev->core_dev->device,
+                                  sizeof(struct sa_state_record),
+                                  ctx->state_record,
+                                  ctx->state_record_dma_addr);
+        ctx->state_record_dma_addr = 0;
+}
+/**
+ * alloc memory for the gather ring
+ * no need to alloc buf for the ring
+ * gdr_tail, gdr_head and gdr_count are initialized by this function
+ */
+static u32 crypto4xx_build_pdr(struct crypto4xx_device *dev)
+{
+        int i;
+        struct pd_uinfo *pd_uinfo;
+        dev->pdr = dma_alloc_coherent(dev->core_dev->device,
+                                      sizeof(struct ce_pd) * PPC4XX_NUM_PD,
+                                      &dev->pdr_pa, GFP_ATOMIC);
+        if (!dev->pdr)
+                return -ENOMEM;
+        dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD,
+                                GFP_KERNEL);
+        if (!dev->pdr_uinfo) {
+                dma_free_coherent(dev->core_dev->device,
+                                  sizeof(struct ce_pd) * PPC4XX_NUM_PD,
+                                  dev->pdr,
+                                  dev->pdr_pa);
+                return -ENOMEM;
+        }
+        memset(dev->pdr, 0,  sizeof(struct ce_pd) * PPC4XX_NUM_PD);
+        dev->shadow_sa_pool = dma_alloc_coherent(dev->core_dev->device,
+                                   256 * PPC4XX_NUM_PD,
+                                   &dev->shadow_sa_pool_pa,
+                                   GFP_ATOMIC);
+        if (!dev->shadow_sa_pool)
+                return -ENOMEM;
+        dev->shadow_sr_pool = dma_alloc_coherent(dev->core_dev->device,
+                         sizeof(struct sa_state_record) * PPC4XX_NUM_PD,
+                         &dev->shadow_sr_pool_pa, GFP_ATOMIC);
+        if (!dev->shadow_sr_pool)
+                return -ENOMEM;
+        for (i = 0; i < PPC4XX_NUM_PD; i++) {
+                pd_uinfo = (struct pd_uinfo *) (dev->pdr_uinfo +
+                                                sizeof(struct pd_uinfo) * i);
+                /* alloc 256 bytes which is enough for any kind of dynamic sa */
+                pd_uinfo->sa_va = dev->shadow_sa_pool + 256 * i;
+                pd_uinfo->sa_pa = dev->shadow_sa_pool_pa + 256 * i;
+                /* alloc state record */
+                pd_uinfo->sr_va = dev->shadow_sr_pool +
+                    sizeof(struct sa_state_record) * i;
+                pd_uinfo->sr_pa = dev->shadow_sr_pool_pa +
+                    sizeof(struct sa_state_record) * i;
+        }
+        return 0;
+}
+static void crypto4xx_destroy_pdr(struct crypto4xx_device *dev)
+{
+        if (dev->pdr != NULL)
+                dma_free_coherent(dev->core_dev->device,
+                                  sizeof(struct ce_pd) * PPC4XX_NUM_PD,
+                                  dev->pdr, dev->pdr_pa);
+        if (dev->shadow_sa_pool)
+                dma_free_coherent(dev->core_dev->device, 256 * PPC4XX_NUM_PD,
+                                  dev->shadow_sa_pool, dev->shadow_sa_pool_pa);
+        if (dev->shadow_sr_pool)
+                dma_free_coherent(dev->core_dev->device,
+                        sizeof(struct sa_state_record) * PPC4XX_NUM_PD,
+                        dev->shadow_sr_pool, dev->shadow_sr_pool_pa);
+        kfree(dev->pdr_uinfo);
+}
+static u32 crypto4xx_get_pd_from_pdr_nolock(struct crypto4xx_device *dev)
+{
+        u32 retval;
+        u32 tmp;
+        retval = dev->pdr_head;
+        tmp = (dev->pdr_head + 1) % PPC4XX_NUM_PD;
+        if (tmp == dev->pdr_tail)
+                return ERING_WAS_FULL;
+        dev->pdr_head = tmp;
+        return retval;
+}
+static u32 crypto4xx_put_pd_to_pdr(struct crypto4xx_device *dev, u32 idx)
+{
+        struct pd_uinfo *pd_uinfo;
+        unsigned long flags;
+        pd_uinfo = (struct pd_uinfo *)(dev->pdr_uinfo +
+                                       sizeof(struct pd_uinfo) * idx);
+        spin_lock_irqsave(&dev->core_dev->lock, flags);
+        if (dev->pdr_tail != PPC4XX_LAST_PD)
+                dev->pdr_tail++;
+        else
+                dev->pdr_tail = 0;
+        pd_uinfo->state = PD_ENTRY_FREE;
+        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+        return 0;
+}
+static struct ce_pd *crypto4xx_get_pdp(struct crypto4xx_device *dev,
+                                       dma_addr_t *pd_dma, u32 idx)
+{
+        *pd_dma = dev->pdr_pa + sizeof(struct ce_pd) * idx;
+        return dev->pdr + sizeof(struct ce_pd) * idx;
+}
+/**
+ * alloc memory for the gather ring
+ * no need to alloc buf for the ring
+ * gdr_tail, gdr_head and gdr_count are initialized by this function
+ */
+static u32 crypto4xx_build_gdr(struct crypto4xx_device *dev)
+{
+        dev->gdr = dma_alloc_coherent(dev->core_dev->device,
+                                      sizeof(struct ce_gd) * PPC4XX_NUM_GD,
+                                      &dev->gdr_pa, GFP_ATOMIC);
+        if (!dev->gdr)
+                return -ENOMEM;
+        memset(dev->gdr, 0, sizeof(struct ce_gd) * PPC4XX_NUM_GD);
+        return 0;
+}
+static inline void crypto4xx_destroy_gdr(struct crypto4xx_device *dev)
+{
+        dma_free_coherent(dev->core_dev->device,
+                          sizeof(struct ce_gd) * PPC4XX_NUM_GD,
+                          dev->gdr, dev->gdr_pa);
+}
+/*
+ * when this function is called.
+ * preemption or interrupt must be disabled
+ */
+u32 crypto4xx_get_n_gd(struct crypto4xx_device *dev, int n)
+{
+        u32 retval;
+        u32 tmp;
+        if (n >= PPC4XX_NUM_GD)
+                return ERING_WAS_FULL;
+        retval = dev->gdr_head;
+        tmp = (dev->gdr_head + n) % PPC4XX_NUM_GD;
+        if (dev->gdr_head > dev->gdr_tail) {
+                if (tmp < dev->gdr_head && tmp >= dev->gdr_tail)
+                        return ERING_WAS_FULL;
+        } else if (dev->gdr_head < dev->gdr_tail) {
+                if (tmp < dev->gdr_head || tmp >= dev->gdr_tail)
+                        return ERING_WAS_FULL;
+        }
+        dev->gdr_head = tmp;
+        return retval;
+}
+static u32 crypto4xx_put_gd_to_gdr(struct crypto4xx_device *dev)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&dev->core_dev->lock, flags);
+        if (dev->gdr_tail == dev->gdr_head) {
+                spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+                return 0;
+        }
+        if (dev->gdr_tail != PPC4XX_LAST_GD)
+                dev->gdr_tail++;
+        else
+                dev->gdr_tail = 0;
+        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+        return 0;
+}
+static inline struct ce_gd *crypto4xx_get_gdp(struct crypto4xx_device *dev,
+                                              dma_addr_t *gd_dma, u32 idx)
+{
+        *gd_dma = dev->gdr_pa + sizeof(struct ce_gd) * idx;
+        return (struct ce_gd *) (dev->gdr + sizeof(struct ce_gd) * idx);
+}
+/**
+ * alloc memory for the scatter ring
+ * need to alloc buf for the ring
+ * sdr_tail, sdr_head and sdr_count are initialized by this function
+ */
+static u32 crypto4xx_build_sdr(struct crypto4xx_device *dev)
+{
+        int i;
+        struct ce_sd *sd_array;
+        /* alloc memory for scatter descriptor ring */
+        dev->sdr = dma_alloc_coherent(dev->core_dev->device,
+                                      sizeof(struct ce_sd) * PPC4XX_NUM_SD,
+                                      &dev->sdr_pa, GFP_ATOMIC);
+        if (!dev->sdr)
+                return -ENOMEM;
+        dev->scatter_buffer_size = PPC4XX_SD_BUFFER_SIZE;
+        dev->scatter_buffer_va =
+                dma_alloc_coherent(dev->core_dev->device,
+                        dev->scatter_buffer_size * PPC4XX_NUM_SD,
+                        &dev->scatter_buffer_pa, GFP_ATOMIC);
+        if (!dev->scatter_buffer_va) {
+                dma_free_coherent(dev->core_dev->device,
+                                  sizeof(struct ce_sd) * PPC4XX_NUM_SD,
+                                  dev->sdr, dev->sdr_pa);
+                return -ENOMEM;
+        }
+        sd_array = dev->sdr;
+        for (i = 0; i < PPC4XX_NUM_SD; i++) {
+                sd_array[i].ptr = dev->scatter_buffer_pa +
+                                  dev->scatter_buffer_size * i;
+        }
+        return 0;
+}
+static void crypto4xx_destroy_sdr(struct crypto4xx_device *dev)
+{
+        if (dev->sdr != NULL)
+                dma_free_coherent(dev->core_dev->device,
+                                  sizeof(struct ce_sd) * PPC4XX_NUM_SD,
+                                  dev->sdr, dev->sdr_pa);
+        if (dev->scatter_buffer_va != NULL)
+                dma_free_coherent(dev->core_dev->device,
+                                  dev->scatter_buffer_size * PPC4XX_NUM_SD,
+                                  dev->scatter_buffer_va,
+                                  dev->scatter_buffer_pa);
+}
+/*
+ * when this function is called.
+ * preemption or interrupt must be disabled
+ */
+static u32 crypto4xx_get_n_sd(struct crypto4xx_device *dev, int n)
+{
+        u32 retval;
+        u32 tmp;
+        if (n >= PPC4XX_NUM_SD)
+                return ERING_WAS_FULL;
+        retval = dev->sdr_head;
+        tmp = (dev->sdr_head + n) % PPC4XX_NUM_SD;
+        if (dev->sdr_head > dev->gdr_tail) {
+                if (tmp < dev->sdr_head && tmp >= dev->sdr_tail)
+                        return ERING_WAS_FULL;
+        } else if (dev->sdr_head < dev->sdr_tail) {
+                if (tmp < dev->sdr_head || tmp >= dev->sdr_tail)
+                        return ERING_WAS_FULL;
+        } /* the head = tail, or empty case is already take cared */
+        dev->sdr_head = tmp;
+        return retval;
+}
+static u32 crypto4xx_put_sd_to_sdr(struct crypto4xx_device *dev)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&dev->core_dev->lock, flags);
+        if (dev->sdr_tail == dev->sdr_head) {
+                spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+                return 0;
+        }
+        if (dev->sdr_tail != PPC4XX_LAST_SD)
+                dev->sdr_tail++;
+        else
+                dev->sdr_tail = 0;
+        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+        return 0;
+}
+static inline struct ce_sd *crypto4xx_get_sdp(struct crypto4xx_device *dev,
+                                              dma_addr_t *sd_dma, u32 idx)
+{
+        *sd_dma = dev->sdr_pa + sizeof(struct ce_sd) * idx;
+        return  (struct ce_sd *)(dev->sdr + sizeof(struct ce_sd) * idx);
+}
+static u32 crypto4xx_fill_one_page(struct crypto4xx_device *dev,
+                                   dma_addr_t *addr, u32 *length,
+                                   u32 *idx, u32 *offset, u32 *nbytes)
+{
+        u32 len;
+        if (*length > dev->scatter_buffer_size) {
+                memcpy(phys_to_virt(*addr),
+                        dev->scatter_buffer_va +
+                        *idx * dev->scatter_buffer_size + *offset,
+                        dev->scatter_buffer_size);
+                *offset = 0;
+                *length -= dev->scatter_buffer_size;
+                *nbytes -= dev->scatter_buffer_size;
+                if (*idx == PPC4XX_LAST_SD)
+                        *idx = 0;
+                else
+                        (*idx)++;
+                *addr = *addr +  dev->scatter_buffer_size;
+                return 1;
+        } else if (*length < dev->scatter_buffer_size) {
+                memcpy(phys_to_virt(*addr),
+                        dev->scatter_buffer_va +
+                        *idx * dev->scatter_buffer_size + *offset, *length);
+                if ((*offset + *length) == dev->scatter_buffer_size) {
+                        if (*idx == PPC4XX_LAST_SD)
+                                *idx = 0;
+                        else
+                                (*idx)++;
+                        *nbytes -= *length;
+                        *offset = 0;
+                } else {
+                        *nbytes -= *length;
+                        *offset += *length;
+                }
+                return 0;
+        } else {
+                len = (*nbytes <= dev->scatter_buffer_size) ?
+                                (*nbytes) : dev->scatter_buffer_size;
+                memcpy(phys_to_virt(*addr),
+                        dev->scatter_buffer_va +
+                        *idx * dev->scatter_buffer_size + *offset,
+                        len);
+                *offset = 0;
+                *nbytes -= len;
+                if (*idx == PPC4XX_LAST_SD)
+                        *idx = 0;
+                else
+                        (*idx)++;
+                return 0;
+    }
+}
+static void crypto4xx_copy_pkt_to_dst(struct crypto4xx_device *dev,
+                                      struct ce_pd *pd,
+                                      struct pd_uinfo *pd_uinfo,
+                                      u32 nbytes,
+                                      struct scatterlist *dst)
+{
+        dma_addr_t addr;
+        u32 this_sd;
+        u32 offset;
+        u32 len;
+        u32 i;
+        u32 sg_len;
+        struct scatterlist *sg;
+        this_sd = pd_uinfo->first_sd;
+        offset = 0;
+        i = 0;
+        while (nbytes) {
+                sg = &dst[i];
+                sg_len = sg->length;
+                addr = dma_map_page(dev->core_dev->device, sg_page(sg),
+                                sg->offset, sg->length, DMA_TO_DEVICE);
+                if (offset == 0) {
+                        len = (nbytes <= sg->length) ? nbytes : sg->length;
+                        while (crypto4xx_fill_one_page(dev, &addr, &len,
+                                &this_sd, &offset, &nbytes))
+                                ;
+                        if (!nbytes)
+                                return;
+                        i++;
+                } else {
+                        len = (nbytes <= (dev->scatter_buffer_size - offset)) ?
+                                nbytes : (dev->scatter_buffer_size - offset);
+                        len = (sg->length < len) ? sg->length : len;
+                        while (crypto4xx_fill_one_page(dev, &addr, &len,
+                                               &this_sd, &offset, &nbytes))
+                                ;
+                        if (!nbytes)
+                                return;
+                        sg_len -= len;
+                        if (sg_len) {
+                                addr += len;
+                                while (crypto4xx_fill_one_page(dev, &addr,
+                                        &sg_len, &this_sd, &offset, &nbytes))
+                                        ;
+                        }
+                        i++;
+                }
+        }
+}
+static u32 crypto4xx_copy_digest_to_dst(struct pd_uinfo *pd_uinfo,
+                                        struct crypto4xx_ctx *ctx)
+{
+        struct dynamic_sa_ctl *sa = (struct dynamic_sa_ctl *) ctx->sa_in;
+        struct sa_state_record *state_record =
+                                (struct sa_state_record *) pd_uinfo->sr_va;
+        if (sa->sa_command_0.bf.hash_alg == SA_HASH_ALG_SHA1) {
+                memcpy((void *) pd_uinfo->dest_va, state_record->save_digest,
+                       SA_HASH_ALG_SHA1_DIGEST_SIZE);
+        }
+        return 0;
+}
+static void crypto4xx_ret_sg_desc(struct crypto4xx_device *dev,
+                                  struct pd_uinfo *pd_uinfo)
+{
+        int i;
+        if (pd_uinfo->num_gd) {
+                for (i = 0; i < pd_uinfo->num_gd; i++)
+                        crypto4xx_put_gd_to_gdr(dev);
+                pd_uinfo->first_gd = 0xffffffff;
+                pd_uinfo->num_gd = 0;
+        }
+        if (pd_uinfo->num_sd) {
+                for (i = 0; i < pd_uinfo->num_sd; i++)
+                        crypto4xx_put_sd_to_sdr(dev);
+                pd_uinfo->first_sd = 0xffffffff;
+                pd_uinfo->num_sd = 0;
+        }
+}
+static u32 crypto4xx_ablkcipher_done(struct crypto4xx_device *dev,
+                                     struct pd_uinfo *pd_uinfo,
+                                     struct ce_pd *pd)
+{
+        struct crypto4xx_ctx *ctx;
+        struct ablkcipher_request *ablk_req;
+        struct scatterlist *dst;
+        dma_addr_t addr;
+        ablk_req = ablkcipher_request_cast(pd_uinfo->async_req);
+        ctx  = crypto_tfm_ctx(ablk_req->base.tfm);
+        if (pd_uinfo->using_sd) {
+                crypto4xx_copy_pkt_to_dst(dev, pd, pd_uinfo, ablk_req->nbytes,
+                                          ablk_req->dst);
+        } else {
+                dst = pd_uinfo->dest_va;
+                addr = dma_map_page(dev->core_dev->device, sg_page(dst),
+                                    dst->offset, dst->length, DMA_FROM_DEVICE);
+        }
+        crypto4xx_ret_sg_desc(dev, pd_uinfo);
+        if (ablk_req->base.complete != NULL)
+                ablk_req->base.complete(&ablk_req->base, 0);
+        return 0;
+}
+static u32 crypto4xx_ahash_done(struct crypto4xx_device *dev,
+                                struct pd_uinfo *pd_uinfo)
+{
+        struct crypto4xx_ctx *ctx;
+        struct ahash_request *ahash_req;
+        ahash_req = ahash_request_cast(pd_uinfo->async_req);
+        ctx  = crypto_tfm_ctx(ahash_req->base.tfm);
+        crypto4xx_copy_digest_to_dst(pd_uinfo,
+                                     crypto_tfm_ctx(ahash_req->base.tfm));
+        crypto4xx_ret_sg_desc(dev, pd_uinfo);
+        /* call user provided callback function x */
+        if (ahash_req->base.complete != NULL)
+                ahash_req->base.complete(&ahash_req->base, 0);
+        return 0;
+}
+static u32 crypto4xx_pd_done(struct crypto4xx_device *dev, u32 idx)
+{
+        struct ce_pd *pd;
+        struct pd_uinfo *pd_uinfo;
+        pd =  dev->pdr + sizeof(struct ce_pd)*idx;
+        pd_uinfo = dev->pdr_uinfo + sizeof(struct pd_uinfo)*idx;
+        if (crypto_tfm_alg_type(pd_uinfo->async_req->tfm) ==
+                        CRYPTO_ALG_TYPE_ABLKCIPHER)
+                return crypto4xx_ablkcipher_done(dev, pd_uinfo, pd);
+        else
+                return crypto4xx_ahash_done(dev, pd_uinfo);
+}
+/**
+ * Note: Only use this function to copy items that is word aligned.
+ */
+void crypto4xx_memcpy_le(unsigned int *dst,
+                         const unsigned char *buf,
+                         int len)
+{
+        u8 *tmp;
+        for (; len >= 4; buf += 4, len -= 4)
+                *dst++ = cpu_to_le32(*(unsigned int *) buf);
+        tmp = (u8 *)dst;
+        switch (len) {
+        case 3:
+                *tmp++ = 0;
+                *tmp++ = *(buf+2);
+                *tmp++ = *(buf+1);
+                *tmp++ = *buf;
+                break;
+        case 2:
+                *tmp++ = 0;
+                *tmp++ = 0;
+                *tmp++ = *(buf+1);
+                *tmp++ = *buf;
+                break;
+        case 1:
+                *tmp++ = 0;
+                *tmp++ = 0;
+                *tmp++ = 0;
+                *tmp++ = *buf;
+                break;
+        default:
+                break;
+        }
+}
+static void crypto4xx_stop_all(struct crypto4xx_core_device *core_dev)
+{
+        crypto4xx_destroy_pdr(core_dev->dev);
+        crypto4xx_destroy_gdr(core_dev->dev);
+        crypto4xx_destroy_sdr(core_dev->dev);
+        dev_set_drvdata(core_dev->device, NULL);
+        iounmap(core_dev->dev->ce_base);
+        kfree(core_dev->dev);
+        kfree(core_dev);
+}
+void crypto4xx_return_pd(struct crypto4xx_device *dev,
+                         u32 pd_entry, struct ce_pd *pd,
+                         struct pd_uinfo *pd_uinfo)
+{
+        /* irq should be already disabled */
+        dev->pdr_head = pd_entry;
+        pd->pd_ctl.w = 0;
+        pd->pd_ctl_len.w = 0;
+        pd_uinfo->state = PD_ENTRY_FREE;
+}
+/*
+ * derive number of elements in scatterlist
+ * Shamlessly copy from talitos.c
+ */
+static int get_sg_count(struct scatterlist *sg_list, int nbytes)
+{
+        struct scatterlist *sg = sg_list;
+        int sg_nents = 0;
+        while (nbytes) {
+                sg_nents++;
+                if (sg->length > nbytes)
+                        break;
+                nbytes -= sg->length;
+                sg = sg_next(sg);
+        }
+        return sg_nents;
+}
+static u32 get_next_gd(u32 current)
+{
+        if (current != PPC4XX_LAST_GD)
+                return current + 1;
+        else
+                return 0;
+}
+static u32 get_next_sd(u32 current)
+{
+        if (current != PPC4XX_LAST_SD)
+                return current + 1;
+        else
+                return 0;
+}
+u32 crypto4xx_build_pd(struct crypto_async_request *req,
+                       struct crypto4xx_ctx *ctx,
+                       struct scatterlist *src,
+                       struct scatterlist *dst,
+                       unsigned int datalen,
+                       void *iv, u32 iv_len)
+{
+        struct crypto4xx_device *dev = ctx->dev;
+        dma_addr_t addr, pd_dma, sd_dma, gd_dma;
+        struct dynamic_sa_ctl *sa;
+        struct scatterlist *sg;
+        struct ce_gd *gd;
+        struct ce_pd *pd;
+        u32 num_gd, num_sd;
+        u32 fst_gd = 0xffffffff;
+        u32 fst_sd = 0xffffffff;
+        u32 pd_entry;
+        unsigned long flags;
+        struct pd_uinfo *pd_uinfo = NULL;
+        unsigned int nbytes = datalen, idx;
+        unsigned int ivlen = 0;
+        u32 gd_idx = 0;
+        /* figure how many gd is needed */
+        num_gd = get_sg_count(src, datalen);
+        if (num_gd == 1)
+                num_gd = 0;
+        /* figure how many sd is needed */
+        if (sg_is_last(dst) || ctx->is_hash) {
+                num_sd = 0;
+        } else {
+                if (datalen > PPC4XX_SD_BUFFER_SIZE) {
+                        num_sd = datalen / PPC4XX_SD_BUFFER_SIZE;
+                        if (datalen % PPC4XX_SD_BUFFER_SIZE)
+                                num_sd++;
+                } else {
+                        num_sd = 1;
+                }
+        }
+        /*
+         * The follow section of code needs to be protected
+         * The gather ring and scatter ring needs to be consecutive
+         * In case of run out of any kind of descriptor, the descriptor
+         * already got must be return the original place.
+         */
+        spin_lock_irqsave(&dev->core_dev->lock, flags);
+        if (num_gd) {
+                fst_gd = crypto4xx_get_n_gd(dev, num_gd);
+                if (fst_gd == ERING_WAS_FULL) {
+                        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+                        return -EAGAIN;
+                }
+        }
+        if (num_sd) {
+                fst_sd = crypto4xx_get_n_sd(dev, num_sd);
+                if (fst_sd == ERING_WAS_FULL) {
+                        if (num_gd)
+                                dev->gdr_head = fst_gd;
+                        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+                        return -EAGAIN;
+                }
+        }
+        pd_entry = crypto4xx_get_pd_from_pdr_nolock(dev);
+        if (pd_entry == ERING_WAS_FULL) {
+                if (num_gd)
+                        dev->gdr_head = fst_gd;
+                if (num_sd)
+                        dev->sdr_head = fst_sd;
+                spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+                return -EAGAIN;
+        }
+        spin_unlock_irqrestore(&dev->core_dev->lock, flags);
+        pd_uinfo = (struct pd_uinfo *)(dev->pdr_uinfo +
+                                       sizeof(struct pd_uinfo) * pd_entry);
+        pd = crypto4xx_get_pdp(dev, &pd_dma, pd_entry);
+        pd_uinfo->async_req = req;
+        pd_uinfo->num_gd = num_gd;
+        pd_uinfo->num_sd = num_sd;
+        if (iv_len || ctx->is_hash) {
+                ivlen = iv_len;
+                pd->sa = pd_uinfo->sa_pa;
+                sa = (struct dynamic_sa_ctl *) pd_uinfo->sa_va;
+                if (ctx->direction == DIR_INBOUND)
+                        memcpy(sa, ctx->sa_in, ctx->sa_len * 4);
+                else
+                        memcpy(sa, ctx->sa_out, ctx->sa_len * 4);
+                memcpy((void *) sa + ctx->offset_to_sr_ptr,
+                        &pd_uinfo->sr_pa, 4);
+                if (iv_len)
+                        crypto4xx_memcpy_le(pd_uinfo->sr_va, iv, iv_len);
+        } else {
+                if (ctx->direction == DIR_INBOUND) {
+                        pd->sa = ctx->sa_in_dma_addr;
+                        sa = (struct dynamic_sa_ctl *) ctx->sa_in;
+                } else {
+                        pd->sa = ctx->sa_out_dma_addr;
+                        sa = (struct dynamic_sa_ctl *) ctx->sa_out;
+                }
+        }
+        pd->sa_len = ctx->sa_len;
+        if (num_gd) {
+                /* get first gd we are going to use */
+                gd_idx = fst_gd;
+                pd_uinfo->first_gd = fst_gd;
+                pd_uinfo->num_gd = num_gd;
+                gd = crypto4xx_get_gdp(dev, &gd_dma, gd_idx);
+                pd->src = gd_dma;
+                /* enable gather */
+                sa->sa_command_0.bf.gather = 1;
+                idx = 0;
+                src = &src[0];
+                /* walk the sg, and setup gather array */
+                while (nbytes) {
+                        sg = &src[idx];
+                        addr = dma_map_page(dev->core_dev->device, sg_page(sg),
+                                    sg->offset, sg->length, DMA_TO_DEVICE);
+                        gd->ptr = addr;
+                        gd->ctl_len.len = sg->length;
+                        gd->ctl_len.done = 0;
+                        gd->ctl_len.ready = 1;
+                        if (sg->length >= nbytes)
+                                break;
+                        nbytes -= sg->length;
+                        gd_idx = get_next_gd(gd_idx);
+                        gd = crypto4xx_get_gdp(dev, &gd_dma, gd_idx);
+                        idx++;
+                }
+        } else {
+                pd->src = (u32)dma_map_page(dev->core_dev->device, sg_page(src),
+                                src->offset, src->length, DMA_TO_DEVICE);
+                /*
+                 * Disable gather in sa command
+                 */
+                sa->sa_command_0.bf.gather = 0;
+                /*
+                 * Indicate gather array is not used
+                 */
+                pd_uinfo->first_gd = 0xffffffff;
+                pd_uinfo->num_gd = 0;
+        }
+        if (ctx->is_hash || sg_is_last(dst)) {
+                /*
+                 * we know application give us dst a whole piece of memory
+                 * no need to use scatter ring.
+                 * In case of is_hash, the icv is always at end of src data.
+                 */
+                pd_uinfo->using_sd = 0;
+                pd_uinfo->first_sd = 0xffffffff;
+                pd_uinfo->num_sd = 0;
+                pd_uinfo->dest_va = dst;
+                sa->sa_command_0.bf.scatter = 0;
+                if (ctx->is_hash)
+                        pd->dest = virt_to_phys((void *)dst);
+                else
+                        pd->dest = (u32)dma_map_page(dev->core_dev->device,
+                                        sg_page(dst), dst->offset,
+                                        dst->length, DMA_TO_DEVICE);
+        } else {
+                struct ce_sd *sd = NULL;
+                u32 sd_idx = fst_sd;
+                nbytes = datalen;
+                sa->sa_command_0.bf.scatter = 1;
+                pd_uinfo->using_sd = 1;
+                pd_uinfo->dest_va = dst;
+                pd_uinfo->first_sd = fst_sd;
+                pd_uinfo->num_sd = num_sd;
+                sd = crypto4xx_get_sdp(dev, &sd_dma, sd_idx);
+                pd->dest = sd_dma;
+                /* setup scatter descriptor */
+                sd->ctl.done = 0;
+                sd->ctl.rdy = 1;
+                /* sd->ptr should be setup by sd_init routine*/
+                idx = 0;
+                if (nbytes >= PPC4XX_SD_BUFFER_SIZE)
+                        nbytes -= PPC4XX_SD_BUFFER_SIZE;
+                else
+                        nbytes = 0;
+                while (nbytes) {
+                        sd_idx = get_next_sd(sd_idx);
+                        sd = crypto4xx_get_sdp(dev, &sd_dma, sd_idx);
+                        /* setup scatter descriptor */
+                        sd->ctl.done = 0;
+                        sd->ctl.rdy = 1;
+                        if (nbytes >= PPC4XX_SD_BUFFER_SIZE)
+                                nbytes -= PPC4XX_SD_BUFFER_SIZE;
+                        else
+                                /*
+                                 * SD entry can hold PPC4XX_SD_BUFFER_SIZE,
+                                 * which is more than nbytes, so done.
+                                 */
+                                nbytes = 0;
+                }
+        }
+        sa->sa_command_1.bf.hash_crypto_offset = 0;
+        pd->pd_ctl.w = ctx->pd_ctl;
+        pd->pd_ctl_len.w = 0x00400000 | (ctx->bypass << 24) | datalen;
+        pd_uinfo->state = PD_ENTRY_INUSE;
+        wmb();
+        /* write any value to push engine to read a pd */
+        writel(1, dev->ce_base + CRYPTO4XX_INT_DESCR_RD);
+        return -EINPROGRESS;
+}
+/**
+ * Algorithm Registration Functions
+ */
+static int crypto4xx_alg_init(struct crypto_tfm *tfm)
+{
+        struct crypto_alg *alg = tfm->__crt_alg;
+        struct crypto4xx_alg *amcc_alg = crypto_alg_to_crypto4xx_alg(alg);
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm);
+        ctx->dev = amcc_alg->dev;
+        ctx->sa_in = NULL;
+        ctx->sa_out = NULL;
+        ctx->sa_in_dma_addr = 0;
+        ctx->sa_out_dma_addr = 0;
+        ctx->sa_len = 0;
+        if (alg->cra_type == &crypto_ablkcipher_type)
+                tfm->crt_ablkcipher.reqsize = sizeof(struct crypto4xx_ctx);
+        else if (alg->cra_type == &crypto_ahash_type)
+                tfm->crt_ahash.reqsize = sizeof(struct crypto4xx_ctx);
+        return 0;
+}
+static void crypto4xx_alg_exit(struct crypto_tfm *tfm)
+{
+        struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm);
+        crypto4xx_free_sa(ctx);
+        crypto4xx_free_state_record(ctx);
+}
+int crypto4xx_register_alg(struct crypto4xx_device *sec_dev,
+                           struct crypto_alg *crypto_alg, int array_size)
+{
+        struct crypto4xx_alg *alg;
+        int i;
+        int rc = 0;
+        for (i = 0; i < array_size; i++) {
+                alg = kzalloc(sizeof(struct crypto4xx_alg), GFP_KERNEL);
+                if (!alg)
+                        return -ENOMEM;
+                alg->alg = crypto_alg[i];
+                INIT_LIST_HEAD(&alg->alg.cra_list);
+                if (alg->alg.cra_init == NULL)
+                        alg->alg.cra_init = crypto4xx_alg_init;
+                if (alg->alg.cra_exit == NULL)
+                        alg->alg.cra_exit = crypto4xx_alg_exit;
+                alg->dev = sec_dev;
+                rc = crypto_register_alg(&alg->alg);
+                if (rc) {
+                        list_del(&alg->entry);
+                        kfree(alg);
+                } else {
+                        list_add_tail(&alg->entry, &sec_dev->alg_list);
+                }
+        }
+        return 0;
+}
+static void crypto4xx_unregister_alg(struct crypto4xx_device *sec_dev)
+{
+        struct crypto4xx_alg *alg, *tmp;
+        list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) {
+                list_del(&alg->entry);
+                crypto_unregister_alg(&alg->alg);
+                kfree(alg);
+        }
+}
+static void crypto4xx_bh_tasklet_cb(unsigned long data)
+{
+        struct device *dev = (struct device *)data;
+        struct crypto4xx_core_device *core_dev = dev_get_drvdata(dev);
+        struct pd_uinfo *pd_uinfo;
+        struct ce_pd *pd;
+        u32 tail;
+        while (core_dev->dev->pdr_head != core_dev->dev->pdr_tail) {
+                tail = core_dev->dev->pdr_tail;
+                pd_uinfo = core_dev->dev->pdr_uinfo +
+                        sizeof(struct pd_uinfo)*tail;
+                pd =  core_dev->dev->pdr + sizeof(struct ce_pd) * tail;
+                if ((pd_uinfo->state == PD_ENTRY_INUSE) &&
+                                   pd->pd_ctl.bf.pe_done &&
+                                   !pd->pd_ctl.bf.host_ready) {
+                        pd->pd_ctl.bf.pe_done = 0;
+                        crypto4xx_pd_done(core_dev->dev, tail);
+                        crypto4xx_put_pd_to_pdr(core_dev->dev, tail);
+                        pd_uinfo->state = PD_ENTRY_FREE;
+                } else {
+                        /* if tail not done, break */
+                        break;
+                }
+        }
+}
+/**
+ * Top Half of isr.
+ */
+static irqreturn_t crypto4xx_ce_interrupt_handler(int irq, void *data)
+{
+        struct device *dev = (struct device *)data;
+        struct crypto4xx_core_device *core_dev = dev_get_drvdata(dev);
+        if (core_dev->dev->ce_base == 0)
+                return 0;
+        writel(PPC4XX_INTERRUPT_CLR,
+               core_dev->dev->ce_base + CRYPTO4XX_INT_CLR);
+        tasklet_schedule(&core_dev->tasklet);
+        return IRQ_HANDLED;
+}
+/**
+ * Supported Crypto Algorithms
+ */
+struct crypto_alg crypto4xx_alg[] = {
+        /* Crypto AES modes */
+        {
+                .cra_name       = "cbc(aes)",
+                .cra_driver_name = "cbc-aes-ppc4xx",
+                .cra_priority   = CRYPTO4XX_CRYPTO_PRIORITY,
+                .cra_flags      = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
+                .cra_blocksize  = AES_BLOCK_SIZE,
+                .cra_ctxsize    = sizeof(struct crypto4xx_ctx),
+                .cra_alignmask  = 0,
+                .cra_type       = &crypto_ablkcipher_type,
+                .cra_module     = THIS_MODULE,
+                .cra_u          = {
+                        .ablkcipher = {
+                                .min_keysize    = AES_MIN_KEY_SIZE,
+                                .max_keysize    = AES_MAX_KEY_SIZE,
+                                .ivsize         = AES_IV_SIZE,
+                                .setkey         = crypto4xx_setkey_aes_cbc,
+                                .encrypt        = crypto4xx_encrypt,
+                                .decrypt        = crypto4xx_decrypt,
+                        }
+                }
+        },
+        /* Hash SHA1 */
+        {
+                .cra_name       = "sha1",
+                .cra_driver_name = "sha1-ppc4xx",
+                .cra_priority   = CRYPTO4XX_CRYPTO_PRIORITY,
+                .cra_flags      = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
+                .cra_blocksize  = SHA1_BLOCK_SIZE,
+                .cra_ctxsize    = sizeof(struct crypto4xx_ctx),
+                .cra_alignmask  = 0,
+                .cra_type       = &crypto_ahash_type,
+                .cra_init       = crypto4xx_sha1_alg_init,
+                .cra_module     = THIS_MODULE,
+                .cra_u          = {
+                        .ahash = {
+                                .digestsize     = SHA1_DIGEST_SIZE,
+                                .init           = crypto4xx_hash_init,
+                                .update         = crypto4xx_hash_update,
+                                .final          = crypto4xx_hash_final,
+                                .digest         = crypto4xx_hash_digest,
+                        }
+                }
+        },
+};
+/**
+ * Module Initialization Routine
+ */
+static int __init crypto4xx_probe(struct of_device *ofdev,
+                                  const struct of_device_id *match)
+{
+        int rc;
+        struct resource res;
+        struct device *dev = &ofdev->dev;
+        struct crypto4xx_core_device *core_dev;
+        rc = of_address_to_resource(ofdev->node, 0, &res);
+        if (rc)
+                return -ENODEV;
+        if (of_find_compatible_node(NULL, NULL, "amcc,ppc460ex-crypto")) {
+                mtdcri(SDR0, PPC460EX_SDR0_SRST,
+                       mfdcri(SDR0, PPC460EX_SDR0_SRST) | PPC460EX_CE_RESET);
+                mtdcri(SDR0, PPC460EX_SDR0_SRST,
+                       mfdcri(SDR0, PPC460EX_SDR0_SRST) & ~PPC460EX_CE_RESET);
+        } else if (of_find_compatible_node(NULL, NULL,
+                        "amcc,ppc405ex-crypto")) {
+                mtdcri(SDR0, PPC405EX_SDR0_SRST,
+                       mfdcri(SDR0, PPC405EX_SDR0_SRST) | PPC405EX_CE_RESET);
+                mtdcri(SDR0, PPC405EX_SDR0_SRST,
+                       mfdcri(SDR0, PPC405EX_SDR0_SRST) & ~PPC405EX_CE_RESET);
+        } else if (of_find_compatible_node(NULL, NULL,
+                        "amcc,ppc460sx-crypto")) {
+                mtdcri(SDR0, PPC460SX_SDR0_SRST,
+                       mfdcri(SDR0, PPC460SX_SDR0_SRST) | PPC460SX_CE_RESET);
+                mtdcri(SDR0, PPC460SX_SDR0_SRST,
+                       mfdcri(SDR0, PPC460SX_SDR0_SRST) & ~PPC460SX_CE_RESET);
+        } else {
+                printk(KERN_ERR "Crypto Function Not supported!\n");
+                return -EINVAL;
+        }
+        core_dev = kzalloc(sizeof(struct crypto4xx_core_device), GFP_KERNEL);
+        if (!core_dev)
+                return -ENOMEM;
+        dev_set_drvdata(dev, core_dev);
+        core_dev->ofdev = ofdev;
+        core_dev->dev = kzalloc(sizeof(struct crypto4xx_device), GFP_KERNEL);
+        if (!core_dev->dev)
+                goto err_alloc_dev;
+        core_dev->dev->core_dev = core_dev;
+        core_dev->device = dev;
+        spin_lock_init(&core_dev->lock);
+        INIT_LIST_HEAD(&core_dev->dev->alg_list);
+        rc = crypto4xx_build_pdr(core_dev->dev);
+        if (rc)
+                goto err_build_pdr;
+        rc = crypto4xx_build_gdr(core_dev->dev);
+        if (rc)
+                goto err_build_gdr;
+        rc = crypto4xx_build_sdr(core_dev->dev);
+        if (rc)
+                goto err_build_sdr;
+        /* Init tasklet for bottom half processing */
+        tasklet_init(&core_dev->tasklet, crypto4xx_bh_tasklet_cb,
+                     (unsigned long) dev);
+        /* Register for Crypto isr, Crypto Engine IRQ */
+        core_dev->irq = irq_of_parse_and_map(ofdev->node, 0);
+        rc = request_irq(core_dev->irq, crypto4xx_ce_interrupt_handler, 0,
+                         core_dev->dev->name, dev);
+        if (rc)
+                goto err_request_irq;
+        core_dev->dev->ce_base = of_iomap(ofdev->node, 0);
+        if (!core_dev->dev->ce_base) {
+                dev_err(dev, "failed to of_iomap\n");
+                goto err_iomap;
+        }
+        /* need to setup pdr, rdr, gdr and sdr before this */
+        crypto4xx_hw_init(core_dev->dev);
+        /* Register security algorithms with Linux CryptoAPI */
+        rc = crypto4xx_register_alg(core_dev->dev, crypto4xx_alg,
+                               ARRAY_SIZE(crypto4xx_alg));
+        if (rc)
+                goto err_start_dev;
+        return 0;
+err_start_dev:
+        iounmap(core_dev->dev->ce_base);
+err_iomap:
+        free_irq(core_dev->irq, dev);
+        irq_dispose_mapping(core_dev->irq);
+        tasklet_kill(&core_dev->tasklet);
+err_request_irq:
+        crypto4xx_destroy_sdr(core_dev->dev);
+err_build_sdr:
+        crypto4xx_destroy_gdr(core_dev->dev);
+err_build_gdr:
+        crypto4xx_destroy_pdr(core_dev->dev);
+err_build_pdr:
+        kfree(core_dev->dev);
+err_alloc_dev:
+        kfree(core_dev);
+        return rc;
+}
+static int __exit crypto4xx_remove(struct of_device *ofdev)
+{
+        struct device *dev = &ofdev->dev;
+        struct crypto4xx_core_device *core_dev = dev_get_drvdata(dev);
+        free_irq(core_dev->irq, dev);
+        irq_dispose_mapping(core_dev->irq);
+        tasklet_kill(&core_dev->tasklet);
+        /* Un-register with Linux CryptoAPI */
+        crypto4xx_unregister_alg(core_dev->dev);
+        /* Free all allocated memory */
+        crypto4xx_stop_all(core_dev);
+        return 0;
+}
+static struct of_device_id crypto4xx_match[] = {
+        { .compatible      = "amcc,ppc4xx-crypto",},
+        { },
+};
+static struct of_platform_driver crypto4xx_driver = {
+        .name           = "crypto4xx",
+        .match_table    = crypto4xx_match,
+        .probe          = crypto4xx_probe,
+        .remove         = crypto4xx_remove,
+};
+static int __init crypto4xx_init(void)
+{
+        return of_register_platform_driver(&crypto4xx_driver);
+}
+static void __exit crypto4xx_exit(void)
+{
+        of_unregister_platform_driver(&crypto4xx_driver);
+}
+module_init(crypto4xx_init);
+module_exit(crypto4xx_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("James Hsiao <jhsiao@amcc.com>");
+MODULE_DESCRIPTION("Driver for AMCC PPC4xx crypto accelerator");
diff --git a/drivers/crypto/amcc/crypto4xx_core.h b/drivers/crypto/amcc/crypto4xx_core.h
new file mode 100644
index 000000000000..1ef103449364
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_core.h
@@ -0,0 +1,177 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This is the header file for AMCC Crypto offload Linux device driver for
+ * use with Linux CryptoAPI.
+ */
+#ifndef __CRYPTO4XX_CORE_H__
+#define __CRYPTO4XX_CORE_H__
+#define PPC460SX_SDR0_SRST                      0x201
+#define PPC405EX_SDR0_SRST                      0x200
+#define PPC460EX_SDR0_SRST                      0x201
+#define PPC460EX_CE_RESET                       0x08000000
+#define PPC460SX_CE_RESET                       0x20000000
+#define PPC405EX_CE_RESET                       0x00000008
+#define CRYPTO4XX_CRYPTO_PRIORITY               300
+#define PPC4XX_LAST_PD                          63
+#define PPC4XX_NUM_PD                           64
+#define PPC4XX_LAST_GD                          1023
+#define PPC4XX_NUM_GD                           1024
+#define PPC4XX_LAST_SD                          63
+#define PPC4XX_NUM_SD                           64
+#define PPC4XX_SD_BUFFER_SIZE                   2048
+#define PD_ENTRY_INUSE                          1
+#define PD_ENTRY_FREE                           0
+#define ERING_WAS_FULL                          0xffffffff
+struct crypto4xx_device;
+struct pd_uinfo {
+        struct crypto4xx_device *dev;
+        u32   state;
+        u32 using_sd;
+        u32 first_gd;           /* first gather discriptor
+                                used by this packet */
+        u32 num_gd;             /* number of gather discriptor
+                                used by this packet */
+        u32 first_sd;           /* first scatter discriptor
+                                used by this packet */
+        u32 num_sd;             /* number of scatter discriptors
+                                used by this packet */
+        void *sa_va;            /* shadow sa, when using cp from ctx->sa */
+        u32 sa_pa;
+        void *sr_va;            /* state record for shadow sa */
+        u32 sr_pa;
+        struct scatterlist *dest_va;
+        struct crypto_async_request *async_req;         /* base crypto request
+                                                        for this packet */
+};
+struct crypto4xx_device {
+        struct crypto4xx_core_device *core_dev;
+        char *name;
+        u64  ce_phy_address;
+        void __iomem *ce_base;
+        void *pdr;                      /* base address of packet
+                                        descriptor ring */
+        dma_addr_t pdr_pa;              /* physical address used to
+                                        program ce pdr_base_register */
+        void *gdr;                      /* gather descriptor ring */
+        dma_addr_t gdr_pa;              /* physical address used to
+                                        program ce gdr_base_register */
+        void *sdr;                      /* scatter descriptor ring */
+        dma_addr_t sdr_pa;              /* physical address used to
+                                        program ce sdr_base_register */
+        void *scatter_buffer_va;
+        dma_addr_t scatter_buffer_pa;
+        u32 scatter_buffer_size;
+        void *shadow_sa_pool;           /* pool of memory for sa in pd_uinfo */
+        dma_addr_t shadow_sa_pool_pa;
+        void *shadow_sr_pool;           /* pool of memory for sr in pd_uinfo */
+        dma_addr_t shadow_sr_pool_pa;
+        u32 pdr_tail;
+        u32 pdr_head;
+        u32 gdr_tail;
+        u32 gdr_head;
+        u32 sdr_tail;
+        u32 sdr_head;
+        void *pdr_uinfo;
+        struct list_head alg_list;      /* List of algorithm supported
+                                        by this device */
+};
+struct crypto4xx_core_device {
+        struct device *device;
+        struct of_device *ofdev;
+        struct crypto4xx_device *dev;
+        u32 int_status;
+        u32 irq;
+        struct tasklet_struct tasklet;
+        spinlock_t lock;
+};
+struct crypto4xx_ctx {
+        struct crypto4xx_device *dev;
+        void *sa_in;
+        dma_addr_t sa_in_dma_addr;
+        void *sa_out;
+        dma_addr_t sa_out_dma_addr;
+        void *state_record;
+        dma_addr_t state_record_dma_addr;
+        u32 sa_len;
+        u32 offset_to_sr_ptr;           /* offset to state ptr, in dynamic sa */
+        u32 direction;
+        u32 next_hdr;
+        u32 save_iv;
+        u32 pd_ctl_len;
+        u32 pd_ctl;
+        u32 bypass;
+        u32 is_hash;
+        u32 hash_final;
+};
+struct crypto4xx_req_ctx {
+        struct crypto4xx_device *dev;   /* Device in which
+                                        operation to send to */
+        void *sa;
+        u32 sa_dma_addr;
+        u16 sa_len;
+};
+struct crypto4xx_alg {
+        struct list_head  entry;
+        struct crypto_alg alg;
+        struct crypto4xx_device *dev;
+};
+#define crypto_alg_to_crypto4xx_alg(x) \
+                container_of(x, struct crypto4xx_alg, alg)
+extern int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size);
+extern void crypto4xx_free_sa(struct crypto4xx_ctx *ctx);
+extern u32 crypto4xx_alloc_sa_rctx(struct crypto4xx_ctx *ctx,
+                                   struct crypto4xx_ctx *rctx);
+extern void crypto4xx_free_sa_rctx(struct crypto4xx_ctx *rctx);
+extern void crypto4xx_free_ctx(struct crypto4xx_ctx *ctx);
+extern u32 crypto4xx_alloc_state_record(struct crypto4xx_ctx *ctx);
+extern u32 get_dynamic_sa_offset_state_ptr_field(struct crypto4xx_ctx *ctx);
+extern u32 get_dynamic_sa_offset_key_field(struct crypto4xx_ctx *ctx);
+extern u32 get_dynamic_sa_iv_size(struct crypto4xx_ctx *ctx);
+extern void crypto4xx_memcpy_le(unsigned int *dst,
+                                const unsigned char *buf, int len);
+extern u32 crypto4xx_build_pd(struct crypto_async_request *req,
+                              struct crypto4xx_ctx *ctx,
+                              struct scatterlist *src,
+                              struct scatterlist *dst,
+                              unsigned int datalen,
+                              void *iv, u32 iv_len);
+extern int crypto4xx_setkey_aes_cbc(struct crypto_ablkcipher *cipher,
+                                    const u8 *key, unsigned int keylen);
+extern int crypto4xx_encrypt(struct ablkcipher_request *req);
+extern int crypto4xx_decrypt(struct ablkcipher_request *req);
+extern int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm);
+extern int crypto4xx_hash_digest(struct ahash_request *req);
+extern int crypto4xx_hash_final(struct ahash_request *req);
+extern int crypto4xx_hash_update(struct ahash_request *req);
+extern int crypto4xx_hash_init(struct ahash_request *req);
+#endif
diff --git a/drivers/crypto/amcc/crypto4xx_reg_def.h b/drivers/crypto/amcc/crypto4xx_reg_def.h
new file mode 100644
index 000000000000..7d4edb002619
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_reg_def.h
@@ -0,0 +1,284 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This filr defines the register set for Security Subsystem
+ */
+#ifndef __CRYPTO4XX_REG_DEF_H__
+#define __CRYPTO4XX_REG_DEF_H__
+/* CRYPTO4XX Register offset */
+#define CRYPTO4XX_DESCRIPTOR                    0x00000000
+#define CRYPTO4XX_CTRL_STAT                     0x00000000
+#define CRYPTO4XX_SOURCE                        0x00000004
+#define CRYPTO4XX_DEST                          0x00000008
+#define CRYPTO4XX_SA                            0x0000000C
+#define CRYPTO4XX_SA_LENGTH                     0x00000010
+#define CRYPTO4XX_LENGTH                        0x00000014
+#define CRYPTO4XX_PE_DMA_CFG                    0x00000040
+#define CRYPTO4XX_PE_DMA_STAT                   0x00000044
+#define CRYPTO4XX_PDR_BASE                      0x00000048
+#define CRYPTO4XX_RDR_BASE                      0x0000004c
+#define CRYPTO4XX_RING_SIZE                     0x00000050
+#define CRYPTO4XX_RING_CTRL                     0x00000054
+#define CRYPTO4XX_INT_RING_STAT                 0x00000058
+#define CRYPTO4XX_EXT_RING_STAT                 0x0000005c
+#define CRYPTO4XX_IO_THRESHOLD                  0x00000060
+#define CRYPTO4XX_GATH_RING_BASE                0x00000064
+#define CRYPTO4XX_SCAT_RING_BASE                0x00000068
+#define CRYPTO4XX_PART_RING_SIZE                0x0000006c
+#define CRYPTO4XX_PART_RING_CFG                 0x00000070
+#define CRYPTO4XX_PDR_BASE_UADDR                0x00000080
+#define CRYPTO4XX_RDR_BASE_UADDR                0x00000084
+#define CRYPTO4XX_PKT_SRC_UADDR                 0x00000088
+#define CRYPTO4XX_PKT_DEST_UADDR                0x0000008c
+#define CRYPTO4XX_SA_UADDR                      0x00000090
+#define CRYPTO4XX_GATH_RING_BASE_UADDR          0x000000A0
+#define CRYPTO4XX_SCAT_RING_BASE_UADDR          0x000000A4
+#define CRYPTO4XX_SEQ_RD                        0x00000408
+#define CRYPTO4XX_SEQ_MASK_RD                   0x0000040C
+#define CRYPTO4XX_SA_CMD_0                      0x00010600
+#define CRYPTO4XX_SA_CMD_1                      0x00010604
+#define CRYPTO4XX_STATE_PTR                     0x000106dc
+#define CRYPTO4XX_STATE_IV                      0x00010700
+#define CRYPTO4XX_STATE_HASH_BYTE_CNT_0         0x00010710
+#define CRYPTO4XX_STATE_HASH_BYTE_CNT_1         0x00010714
+#define CRYPTO4XX_STATE_IDIGEST_0               0x00010718
+#define CRYPTO4XX_STATE_IDIGEST_1               0x0001071c
+#define CRYPTO4XX_DATA_IN                       0x00018000
+#define CRYPTO4XX_DATA_OUT                      0x0001c000
+#define CRYPTO4XX_INT_UNMASK_STAT               0x000500a0
+#define CRYPTO4XX_INT_MASK_STAT                 0x000500a4
+#define CRYPTO4XX_INT_CLR                       0x000500a4
+#define CRYPTO4XX_INT_EN                        0x000500a8
+#define CRYPTO4XX_INT_PKA                       0x00000002
+#define CRYPTO4XX_INT_PDR_DONE                  0x00008000
+#define CRYPTO4XX_INT_MA_WR_ERR                 0x00020000
+#define CRYPTO4XX_INT_MA_RD_ERR                 0x00010000
+#define CRYPTO4XX_INT_PE_ERR                    0x00000200
+#define CRYPTO4XX_INT_USER_DMA_ERR              0x00000040
+#define CRYPTO4XX_INT_SLAVE_ERR                 0x00000010
+#define CRYPTO4XX_INT_MASTER_ERR                0x00000008
+#define CRYPTO4XX_INT_ERROR                     0x00030258
+#define CRYPTO4XX_INT_CFG                       0x000500ac
+#define CRYPTO4XX_INT_DESCR_RD                  0x000500b0
+#define CRYPTO4XX_INT_DESCR_CNT                 0x000500b4
+#define CRYPTO4XX_INT_TIMEOUT_CNT               0x000500b8
+#define CRYPTO4XX_DEVICE_CTRL                   0x00060080
+#define CRYPTO4XX_DEVICE_ID                     0x00060084
+#define CRYPTO4XX_DEVICE_INFO                   0x00060088
+#define CRYPTO4XX_DMA_USER_SRC                  0x00060094
+#define CRYPTO4XX_DMA_USER_DEST                 0x00060098
+#define CRYPTO4XX_DMA_USER_CMD                  0x0006009C
+#define CRYPTO4XX_DMA_CFG                       0x000600d4
+#define CRYPTO4XX_BYTE_ORDER_CFG                0x000600d8
+#define CRYPTO4XX_ENDIAN_CFG                    0x000600d8
+#define CRYPTO4XX_PRNG_STAT                     0x00070000
+#define CRYPTO4XX_PRNG_CTRL                     0x00070004
+#define CRYPTO4XX_PRNG_SEED_L                   0x00070008
+#define CRYPTO4XX_PRNG_SEED_H                   0x0007000c
+#define CRYPTO4XX_PRNG_RES_0                    0x00070020
+#define CRYPTO4XX_PRNG_RES_1                    0x00070024
+#define CRYPTO4XX_PRNG_RES_2                    0x00070028
+#define CRYPTO4XX_PRNG_RES_3                    0x0007002C
+#define CRYPTO4XX_PRNG_LFSR_L                   0x00070030
+#define CRYPTO4XX_PRNG_LFSR_H                   0x00070034
+/**
+ * Initilize CRYPTO ENGINE registers, and memory bases.
+ */
+#define PPC4XX_PDR_POLL                         0x3ff
+#define PPC4XX_OUTPUT_THRESHOLD                 2
+#define PPC4XX_INPUT_THRESHOLD                  2
+#define PPC4XX_PD_SIZE                          6
+#define PPC4XX_CTX_DONE_INT                     0x2000
+#define PPC4XX_PD_DONE_INT                      0x8000
+#define PPC4XX_BYTE_ORDER                       0x22222
+#define PPC4XX_INTERRUPT_CLR                    0x3ffff
+#define PPC4XX_PRNG_CTRL_AUTO_EN                0x3
+#define PPC4XX_DC_3DES_EN                       1
+#define PPC4XX_INT_DESCR_CNT                    4
+#define PPC4XX_INT_TIMEOUT_CNT                  0
+#define PPC4XX_INT_CFG                          1
+/**
+ * all follow define are ad hoc
+ */
+#define PPC4XX_RING_RETRY                       100
+#define PPC4XX_RING_POLL                        100
+#define PPC4XX_SDR_SIZE                         PPC4XX_NUM_SD
+#define PPC4XX_GDR_SIZE                         PPC4XX_NUM_GD
+/**
+  * Generic Security Association (SA) with all possible fields. These will
+ * never likely used except for reference purpose. These structure format
+ * can be not changed as the hardware expects them to be layout as defined.
+ * Field can be removed or reduced but ordering can not be changed.
+ */
+#define CRYPTO4XX_DMA_CFG_OFFSET                0x40
+union ce_pe_dma_cfg {
+        struct {
+                u32 rsv:7;
+                u32 dir_host:1;
+                u32 rsv1:2;
+                u32 bo_td_en:1;
+                u32 dis_pdr_upd:1;
+                u32 bo_sgpd_en:1;
+                u32 bo_data_en:1;
+                u32 bo_sa_en:1;
+                u32 bo_pd_en:1;
+                u32 rsv2:4;
+                u32 dynamic_sa_en:1;
+                u32 pdr_mode:2;
+                u32 pe_mode:1;
+                u32 rsv3:5;
+                u32 reset_sg:1;
+                u32 reset_pdr:1;
+                u32 reset_pe:1;
+        } bf;
+    u32 w;
+} __attribute__((packed));
+#define CRYPTO4XX_PDR_BASE_OFFSET               0x48
+#define CRYPTO4XX_RDR_BASE_OFFSET               0x4c
+#define CRYPTO4XX_RING_SIZE_OFFSET              0x50
+union ce_ring_size {
+        struct {
+                u32 ring_offset:16;
+                u32 rsv:6;
+                u32 ring_size:10;
+        } bf;
+    u32 w;
+} __attribute__((packed));
+#define CRYPTO4XX_RING_CONTROL_OFFSET           0x54
+union ce_ring_contol {
+        struct {
+                u32 continuous:1;
+                u32 rsv:5;
+                u32 ring_retry_divisor:10;
+                u32 rsv1:4;
+                u32 ring_poll_divisor:10;
+        } bf;
+    u32 w;
+} __attribute__((packed));
+#define CRYPTO4XX_IO_THRESHOLD_OFFSET           0x60
+union ce_io_threshold {
+        struct {
+                u32 rsv:6;
+                u32 output_threshold:10;
+                u32 rsv1:6;
+                u32 input_threshold:10;
+        } bf;
+    u32 w;
+} __attribute__((packed));
+#define CRYPTO4XX_GATHER_RING_BASE_OFFSET       0x64
+#define CRYPTO4XX_SCATTER_RING_BASE_OFFSET      0x68
+union ce_part_ring_size  {
+        struct {
+                u32 sdr_size:16;
+                u32 gdr_size:16;
+        } bf;
+    u32 w;
+} __attribute__((packed));
+#define MAX_BURST_SIZE_32                       0
+#define MAX_BURST_SIZE_64                       1
+#define MAX_BURST_SIZE_128                      2
+#define MAX_BURST_SIZE_256                      3
+/* gather descriptor control length */
+struct gd_ctl_len {
+        u32 len:16;
+        u32 rsv:14;
+        u32 done:1;
+        u32 ready:1;
+} __attribute__((packed));
+struct ce_gd {
+        u32 ptr;
+        struct gd_ctl_len ctl_len;
+} __attribute__((packed));
+struct sd_ctl {
+        u32 ctl:30;
+        u32 done:1;
+        u32 rdy:1;
+} __attribute__((packed));
+struct ce_sd {
+    u32 ptr;
+        struct sd_ctl ctl;
+} __attribute__((packed));
+#define PD_PAD_CTL_32   0x10
+#define PD_PAD_CTL_64   0x20
+#define PD_PAD_CTL_128  0x40
+#define PD_PAD_CTL_256  0x80
+union ce_pd_ctl {
+        struct {
+                u32 pd_pad_ctl:8;
+                u32 status:8;
+                u32 next_hdr:8;
+                u32 rsv:2;
+                u32 cached_sa:1;
+                u32 hash_final:1;
+                u32 init_arc4:1;
+                u32 rsv1:1;
+                u32 pe_done:1;
+                u32 host_ready:1;
+        } bf;
+        u32 w;
+} __attribute__((packed));
+union ce_pd_ctl_len {
+        struct {
+                u32 bypass:8;
+                u32 pe_done:1;
+                u32 host_ready:1;
+                u32 rsv:2;
+                u32 pkt_len:20;
+        } bf;
+        u32 w;
+} __attribute__((packed));
+struct ce_pd {
+        union ce_pd_ctl   pd_ctl;
+        u32 src;
+        u32 dest;
+        u32 sa;                 /* get from ctx->sa_dma_addr */
+        u32 sa_len;             /* only if dynamic sa is used */
+        union ce_pd_ctl_len pd_ctl_len;
+} __attribute__((packed));
+#endif
diff --git a/drivers/crypto/amcc/crypto4xx_sa.c b/drivers/crypto/amcc/crypto4xx_sa.c
new file mode 100644
index 000000000000..466fd94cd4a3
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_sa.c
@@ -0,0 +1,108 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * @file crypto4xx_sa.c
+ *
+ * This file implements the security context
+ * assoicate format.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/mod_devicetable.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock_types.h>
+#include <linux/highmem.h>
+#include <linux/scatterlist.h>
+#include <linux/crypto.h>
+#include <crypto/algapi.h>
+#include <crypto/des.h>
+#include "crypto4xx_reg_def.h"
+#include "crypto4xx_sa.h"
+#include "crypto4xx_core.h"
+u32 get_dynamic_sa_offset_iv_field(struct crypto4xx_ctx *ctx)
+{
+        u32 offset;
+        union dynamic_sa_contents cts;
+        if (ctx->direction == DIR_INBOUND)
+                cts.w = ((struct dynamic_sa_ctl *)(ctx->sa_in))->sa_contents;
+        else
+                cts.w = ((struct dynamic_sa_ctl *)(ctx->sa_out))->sa_contents;
+        offset = cts.bf.key_size
+                + cts.bf.inner_size
+                + cts.bf.outer_size
+                + cts.bf.spi
+                + cts.bf.seq_num0
+                + cts.bf.seq_num1
+                + cts.bf.seq_num_mask0
+                + cts.bf.seq_num_mask1
+                + cts.bf.seq_num_mask2
+                + cts.bf.seq_num_mask3;
+        return sizeof(struct dynamic_sa_ctl) + offset * 4;
+}
+u32 get_dynamic_sa_offset_state_ptr_field(struct crypto4xx_ctx *ctx)
+{
+        u32 offset;
+        union dynamic_sa_contents cts;
+        if (ctx->direction == DIR_INBOUND)
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_in)->sa_contents;
+        else
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_out)->sa_contents;
+        offset = cts.bf.key_size
+                + cts.bf.inner_size
+                + cts.bf.outer_size
+                + cts.bf.spi
+                + cts.bf.seq_num0
+                + cts.bf.seq_num1
+                + cts.bf.seq_num_mask0
+                + cts.bf.seq_num_mask1
+                + cts.bf.seq_num_mask2
+                + cts.bf.seq_num_mask3
+                + cts.bf.iv0
+                + cts.bf.iv1
+                + cts.bf.iv2
+                + cts.bf.iv3;
+        return sizeof(struct dynamic_sa_ctl) + offset * 4;
+}
+u32 get_dynamic_sa_iv_size(struct crypto4xx_ctx *ctx)
+{
+        union dynamic_sa_contents cts;
+        if (ctx->direction == DIR_INBOUND)
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_in)->sa_contents;
+        else
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_out)->sa_contents;
+        return (cts.bf.iv0 + cts.bf.iv1 + cts.bf.iv2 + cts.bf.iv3) * 4;
+}
+u32 get_dynamic_sa_offset_key_field(struct crypto4xx_ctx *ctx)
+{
+        union dynamic_sa_contents cts;
+        if (ctx->direction == DIR_INBOUND)
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_in)->sa_contents;
+        else
+                cts.w = ((struct dynamic_sa_ctl *) ctx->sa_out)->sa_contents;
+        return sizeof(struct dynamic_sa_ctl);
+}
diff --git a/drivers/crypto/amcc/crypto4xx_sa.h b/drivers/crypto/amcc/crypto4xx_sa.h
new file mode 100644
index 000000000000..4b83ed7e5570
--- /dev/null
+++ b/drivers/crypto/amcc/crypto4xx_sa.h
@@ -0,0 +1,243 @@
+/**
+ * AMCC SoC PPC4xx Crypto Driver
+ *
+ * Copyright (c) 2008 Applied Micro Circuits Corporation.
+ * All rights reserved. James Hsiao <jhsiao@amcc.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This file defines the security context
+ * assoicate format.
+ */
+#ifndef __CRYPTO4XX_SA_H__
+#define __CRYPTO4XX_SA_H__
+#define AES_IV_SIZE                             16
+/**
+ * Contents of Dynamic Security Association (SA) with all possible fields
+ */
+union dynamic_sa_contents {
+        struct {
+                u32 arc4_state_ptr:1;
+                u32 arc4_ij_ptr:1;
+                u32 state_ptr:1;
+                u32 iv3:1;
+                u32 iv2:1;
+                u32 iv1:1;
+                u32 iv0:1;
+                u32 seq_num_mask3:1;
+                u32 seq_num_mask2:1;
+                u32 seq_num_mask1:1;
+                u32 seq_num_mask0:1;
+                u32 seq_num1:1;
+                u32 seq_num0:1;
+                u32 spi:1;
+                u32 outer_size:5;
+                u32 inner_size:5;
+                u32 key_size:4;
+                u32 cmd_size:4;
+        } bf;
+        u32 w;
+} __attribute__((packed));
+#define DIR_OUTBOUND                            0
+#define DIR_INBOUND                             1
+#define SA_OP_GROUP_BASIC                       0
+#define SA_OPCODE_ENCRYPT                       0
+#define SA_OPCODE_DECRYPT                       0
+#define SA_OPCODE_HASH                          3
+#define SA_CIPHER_ALG_DES                       0
+#define SA_CIPHER_ALG_3DES                      1
+#define SA_CIPHER_ALG_ARC4                      2
+#define SA_CIPHER_ALG_AES                       3
+#define SA_CIPHER_ALG_KASUMI                    4
+#define SA_CIPHER_ALG_NULL                      15
+#define SA_HASH_ALG_MD5                         0
+#define SA_HASH_ALG_SHA1                        1
+#define SA_HASH_ALG_NULL                        15
+#define SA_HASH_ALG_SHA1_DIGEST_SIZE            20
+#define SA_LOAD_HASH_FROM_SA                    0
+#define SA_LOAD_HASH_FROM_STATE                 2
+#define SA_NOT_LOAD_HASH                        3
+#define SA_LOAD_IV_FROM_SA                      0
+#define SA_LOAD_IV_FROM_INPUT                   1
+#define SA_LOAD_IV_FROM_STATE                   2
+#define SA_LOAD_IV_GEN_IV                       3
+#define SA_PAD_TYPE_CONSTANT                    2
+#define SA_PAD_TYPE_ZERO                        3
+#define SA_PAD_TYPE_TLS                         5
+#define SA_PAD_TYPE_DTLS                        5
+#define SA_NOT_SAVE_HASH                        0
+#define SA_SAVE_HASH                            1
+#define SA_NOT_SAVE_IV                          0
+#define SA_SAVE_IV                              1
+#define SA_HEADER_PROC                          1
+#define SA_NO_HEADER_PROC                       0
+union sa_command_0 {
+        struct {
+                u32 scatter:1;
+                u32 gather:1;
+                u32 save_hash_state:1;
+                u32 save_iv:1;
+                u32 load_hash_state:2;
+                u32 load_iv:2;
+                u32 digest_len:4;
+                u32 hdr_proc:1;
+                u32 extend_pad:1;
+                u32 stream_cipher_pad:1;
+                u32 rsv:1;
+                u32 hash_alg:4;
+                u32 cipher_alg:4;
+                u32 pad_type:2;
+                u32 op_group:2;
+                u32 dir:1;
+                u32 opcode:3;
+        } bf;
+        u32 w;
+} __attribute__((packed));
+#define CRYPTO_MODE_ECB                         0
+#define CRYPTO_MODE_CBC                         1
+#define CRYPTO_FEEDBACK_MODE_NO_FB              0
+#define CRYPTO_FEEDBACK_MODE_64BIT_OFB          0
+#define CRYPTO_FEEDBACK_MODE_8BIT_CFB           1
+#define CRYPTO_FEEDBACK_MODE_1BIT_CFB           2
+#define CRYPTO_FEEDBACK_MODE_128BIT_CFB         3
+#define SA_AES_KEY_LEN_128                      2
+#define SA_AES_KEY_LEN_192                      3
+#define SA_AES_KEY_LEN_256                      4
+#define SA_REV2                                 1
+/**
+ * The follow defines bits sa_command_1
+ * In Basic hash mode  this bit define simple hash or hmac.
+ * In IPsec mode, this bit define muting control.
+ */
+#define SA_HASH_MODE_HASH                       0
+#define SA_HASH_MODE_HMAC                       1
+#define SA_MC_ENABLE                            0
+#define SA_MC_DISABLE                           1
+#define SA_NOT_COPY_HDR                         0
+#define SA_COPY_HDR                             1
+#define SA_NOT_COPY_PAD                         0
+#define SA_COPY_PAD                             1
+#define SA_NOT_COPY_PAYLOAD                     0
+#define SA_COPY_PAYLOAD                         1
+#define SA_EXTENDED_SN_OFF                      0
+#define SA_EXTENDED_SN_ON                       1
+#define SA_SEQ_MASK_OFF                         0
+#define SA_SEQ_MASK_ON                          1
+union sa_command_1 {
+        struct {
+                u32 crypto_mode31:1;
+                u32 save_arc4_state:1;
+                u32 arc4_stateful:1;
+                u32 key_len:5;
+                u32 hash_crypto_offset:8;
+                u32 sa_rev:2;
+                u32 byte_offset:1;
+                u32 hmac_muting:1;
+                u32 feedback_mode:2;
+                u32 crypto_mode9_8:2;
+                u32 extended_seq_num:1;
+                u32 seq_num_mask:1;
+                u32 mutable_bit_proc:1;
+                u32 ip_version:1;
+                u32 copy_pad:1;
+                u32 copy_payload:1;
+                u32 copy_hdr:1;
+                u32 rsv1:1;
+        } bf;
+        u32 w;
+} __attribute__((packed));
+struct dynamic_sa_ctl {
+        u32 sa_contents;
+        union sa_command_0 sa_command_0;
+        union sa_command_1 sa_command_1;
+} __attribute__((packed));
+/**
+ * State Record for Security Association (SA)
+ */
+struct  sa_state_record {
+        u32 save_iv[4];
+        u32 save_hash_byte_cnt[2];
+        u32 save_digest[16];
+} __attribute__((packed));
+/**
+ * Security Association (SA) for AES128
+ *
+ */
+struct dynamic_sa_aes128 {
+        struct dynamic_sa_ctl   ctrl;
+        u32 key[4];
+        u32 iv[4]; /* for CBC, OFC, and CFB mode */
+        u32 state_ptr;
+        u32 reserved;
+} __attribute__((packed));
+#define SA_AES128_LEN           (sizeof(struct dynamic_sa_aes128)/4)
+#define SA_AES128_CONTENTS      0x3e000042
+/*
+ * Security Association (SA) for AES192
+ */
+struct dynamic_sa_aes192 {
+        struct dynamic_sa_ctl ctrl;
+        u32 key[6];
+        u32 iv[4]; /* for CBC, OFC, and CFB mode */
+        u32 state_ptr;
+        u32 reserved;
+} __attribute__((packed));
+#define SA_AES192_LEN           (sizeof(struct dynamic_sa_aes192)/4)
+#define SA_AES192_CONTENTS      0x3e000062
+/**
+ * Security Association (SA) for AES256
+ */
+struct dynamic_sa_aes256 {
+        struct dynamic_sa_ctl ctrl;
+        u32 key[8];
+        u32 iv[4]; /* for CBC, OFC, and CFB mode */
+        u32 state_ptr;
+        u32 reserved;
+} __attribute__((packed));
+#define SA_AES256_LEN           (sizeof(struct dynamic_sa_aes256)/4)
+#define SA_AES256_CONTENTS      0x3e000082
+#define SA_AES_CONTENTS         0x3e000002
+/**
+ * Security Association (SA) for HASH160: HMAC-SHA1
+ */
+struct dynamic_sa_hash160 {
+        struct dynamic_sa_ctl ctrl;
+        u32 inner_digest[5];
+        u32 outer_digest[5];
+        u32 state_ptr;
+        u32 reserved;
+} __attribute__((packed));
+#define SA_HASH160_LEN          (sizeof(struct dynamic_sa_hash160)/4)
+#define SA_HASH160_CONTENTS     0x2000a502
+#endif
diff --git a/drivers/dio/dio.c b/drivers/dio/dio.c
index 10c3c498358c..55dd88d82d6d 100644
--- a/drivers/dio/dio.c
+++ b/drivers/dio/dio.c
@@ -182,7 +182,7 @@ static int __init dio_init(void)
        /* Initialize the DIO bus */ 
        INIT_LIST_HEAD(&dio_bus.devices);
-        strcpy(dio_bus.dev.bus_id, "dio");
+        dev_set_name(&dio_bus.dev, "dio");
        error = device_register(&dio_bus.dev);
        if (error) {
                pr_err("DIO: Error registering dio_bus\n");
@@ -237,7 +237,7 @@ static int __init dio_init(void)
                dev->scode = scode;
                dev->resource.start = pa;
                dev->resource.end = pa + DIO_SIZE(scode, va);
-                sprintf(dev->dev.bus_id,"%02x", scode);
+                dev_set_name(&dev->dev, "%02x", scode);
                /* read the ID byte(s) and encode if necessary. */
                prid = DIO_ID(va);
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index a97c07eef7ec..20ad3d26bec2 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -1011,7 +1011,7 @@ static int __init dw_probe(struct platform_device *pdev)
        dma_writel(dw, CFG, DW_CFG_DMA_EN);
        printk(KERN_INFO "%s: DesignWare DMA Controller, %d channels\n",
-                        pdev->dev.bus_id, dw->dma.chancnt);
+                        dev_name(&pdev->dev), dw->dma.chancnt);
        dma_async_device_register(&dw->dma);
diff --git a/drivers/edac/cell_edac.c b/drivers/edac/cell_edac.c
index 24f3ca851523..cb0f639f049d 100644
--- a/drivers/edac/cell_edac.c
+++ b/drivers/edac/cell_edac.c
@@ -198,7 +198,7 @@ static int __devinit cell_edac_probe(struct platform_device *pdev)
        mci->edac_cap = EDAC_FLAG_EC | EDAC_FLAG_SECDED;
        mci->mod_name = "cell_edac";
        mci->ctl_name = "MIC";
-        mci->dev_name = pdev->dev.bus_id;
+        mci->dev_name = dev_name(&pdev->dev);
        mci->edac_check = cell_edac_check;
        cell_edac_init_csrows(mci);
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index 853ef37ec006..4637a4a757df 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -218,7 +218,7 @@ static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
        pci->dev = &op->dev;
        pci->mod_name = EDAC_MOD_STR;
        pci->ctl_name = pdata->name;
-        pci->dev_name = op->dev.bus_id;
+        pci->dev_name = dev_name(&op->dev);
        if (edac_op_state == EDAC_OPSTATE_POLL)
                pci->edac_check = mpc85xx_pci_check;
diff --git a/drivers/edac/mv64x60_edac.c b/drivers/edac/mv64x60_edac.c
index 083ce8d0c63d..5131aaae8e03 100644
--- a/drivers/edac/mv64x60_edac.c
+++ b/drivers/edac/mv64x60_edac.c
@@ -121,7 +121,7 @@ static int __devinit mv64x60_pci_err_probe(struct platform_device *pdev)
        pdata->irq = NO_IRQ;
        platform_set_drvdata(pdev, pci);
        pci->dev = &pdev->dev;
-        pci->dev_name = pdev->dev.bus_id;
+        pci->dev_name = dev_name(&pdev->dev);
        pci->mod_name = EDAC_MOD_STR;
        pci->ctl_name = pdata->name;
@@ -294,7 +294,7 @@ static int __devinit mv64x60_sram_err_probe(struct platform_device *pdev)
        pdata->irq = NO_IRQ;
        edac_dev->dev = &pdev->dev;
        platform_set_drvdata(pdev, edac_dev);
-        edac_dev->dev_name = pdev->dev.bus_id;
+        edac_dev->dev_name = dev_name(&pdev->dev);
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!r) {
@@ -462,7 +462,7 @@ static int __devinit mv64x60_cpu_err_probe(struct platform_device *pdev)
        pdata->irq = NO_IRQ;
        edac_dev->dev = &pdev->dev;
        platform_set_drvdata(pdev, edac_dev);
-        edac_dev->dev_name = pdev->dev.bus_id;
+        edac_dev->dev_name = dev_name(&pdev->dev);
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!r) {
@@ -713,7 +713,7 @@ static int __devinit mv64x60_mc_err_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, mci);
        pdata->name = "mv64x60_mc_err";
        pdata->irq = NO_IRQ;
-        mci->dev_name = pdev->dev.bus_id;
+        mci->dev_name = dev_name(&pdev->dev);
        pdata->edac_idx = edac_mc_idx++;
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index c950bf8606d9..66958b3f10b4 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -200,7 +200,7 @@ static int __init eisa_init_device (struct eisa_root_device *root,
        edev->dev.bus = &eisa_bus_type;
        edev->dev.dma_mask = &edev->dma_mask;
        edev->dev.coherent_dma_mask = edev->dma_mask;
-        sprintf (edev->dev.bus_id, "%02X:%02X", root->bus_nr, slot);
+        dev_set_name(&edev->dev, "%02X:%02X", root->bus_nr, slot);
        for (i = 0; i < EISA_MAX_RESOURCES; i++) {
 #ifdef CONFIG_EISA_NAMES
@@ -301,7 +301,7 @@ static int __init eisa_probe (struct eisa_root_device *root)
        struct eisa_device *edev;
        printk (KERN_INFO "EISA: Probing bus %d at %s\n",
-                root->bus_nr, root->dev->bus_id);
+                root->bus_nr, dev_name(root->dev));
        /* First try to get hold of slot 0. If there is no device
         * here, simply fail, unless root->force_probe is set. */
diff --git a/drivers/gpio/bt8xxgpio.c b/drivers/gpio/bt8xxgpio.c
index 7a1168249dd5..984b587f0f96 100644
--- a/drivers/gpio/bt8xxgpio.c
+++ b/drivers/gpio/bt8xxgpio.c
@@ -160,7 +160,7 @@ static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
 {
        struct gpio_chip *c = &bg->gpio;
-        c->label = bg->pdev->dev.bus_id;
+        c->label = dev_name(&bg->pdev->dev);
        c->owner = THIS_MODULE;
        c->direction_input = bt8xxgpio_gpio_direction_input;
        c->get = bt8xxgpio_gpio_get;
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 5aa6780652aa..186d08159d48 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -359,8 +359,8 @@ int drm_sysfs_connector_add(struct drm_connector *connector)
        DRM_DEBUG("adding \"%s\" to sysfs\n",
                  drm_get_connector_name(connector));
-        snprintf(connector->kdev.bus_id, BUS_ID_SIZE, "card%d-%s",
+        dev_set_name(&connector->kdev, "card%d-%s",
-                 dev->primary->index, drm_get_connector_name(connector));
+                     dev->primary->index, drm_get_connector_name(connector));
        ret = device_register(&connector->kdev);
        if (ret) {
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index e7d984866de0..fbb9030b68a5 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -841,7 +841,7 @@ int i2c_attach_client(struct i2c_client *client)
        if (client->driver && !is_newstyle_driver(client->driver)) {
                client->dev.release = i2c_client_release;
-                client->dev.uevent_suppress = 1;
+                dev_set_uevent_suppress(&client->dev, 1);
        } else
                client->dev.release = i2c_client_dev_release;
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 5ea3bfad172a..640c99207242 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -56,8 +56,12 @@ if IDE
 comment "Please see Documentation/ide/ide.txt for help/info on IDE drives"
+config IDE_XFER_MODE
+        bool
 config IDE_TIMINGS
        bool
+        select IDE_XFER_MODE
 config IDE_ATAPI
        bool
@@ -698,6 +702,7 @@ config BLK_DEV_IDE_PMAC_ATA100FIRST
 config BLK_DEV_IDE_AU1XXX
       bool "IDE for AMD Alchemy Au1200"
       depends on SOC_AU1200
+       select IDE_XFER_MODE
 choice
       prompt "IDE Mode for AMD Alchemy Au1200"
       default CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA
@@ -871,6 +876,7 @@ config BLK_DEV_ALI14XX
 config BLK_DEV_DTC2278
        tristate "DTC-2278 support"
+        select IDE_XFER_MODE
        select IDE_LEGACY
        help
          This driver is enabled at runtime using the "dtc2278.probe" kernel
@@ -902,6 +908,7 @@ config BLK_DEV_QD65XX
 config BLK_DEV_UMC8672
        tristate "UMC-8672 support"
+        select IDE_XFER_MODE
        select IDE_LEGACY
        help
          This driver is enabled at runtime using the "umc8672.probe" kernel
@@ -915,5 +922,6 @@ endif
 config BLK_DEV_IDEDMA
        def_bool BLK_DEV_IDEDMA_SFF || \
                 BLK_DEV_IDEDMA_ICS || BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        select IDE_XFER_MODE
 endif # IDE
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index 1c326d94aa6d..9b4bbe1cdc1a 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -5,9 +5,11 @@
 EXTRA_CFLAGS                            += -Idrivers/ide
 ide-core-y += ide.o ide-ioctls.o ide-io.o ide-iops.o ide-lib.o ide-probe.o \
-              ide-taskfile.o ide-pm.o ide-park.o ide-pio-blacklist.o ide-sysfs.o
+              ide-taskfile.o ide-pm.o ide-park.o ide-sysfs.o ide-devsets.o \
+              ide-io-std.o ide-eh.o
 # core IDE code
+ide-core-$(CONFIG_IDE_XFER_MODE)        += ide-pio-blacklist.o ide-xfer-mode.o
 ide-core-$(CONFIG_IDE_TIMINGS)          += ide-timings.o
 ide-core-$(CONFIG_IDE_ATAPI)            += ide-atapi.o
 ide-core-$(CONFIG_BLK_DEV_IDEPCI)       += setup-pci.o
diff --git a/drivers/ide/aec62xx.c b/drivers/ide/aec62xx.c
index 4485b9c6f0e6..878f8ec6dbe1 100644
--- a/drivers/ide/aec62xx.c
+++ b/drivers/ide/aec62xx.c
@@ -139,7 +139,7 @@ static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio)
        drive->hwif->port_ops->set_dma_mode(drive, pio + XFER_PIO_0);
 }
-static unsigned int init_chipset_aec62xx(struct pci_dev *dev)
+static int init_chipset_aec62xx(struct pci_dev *dev)
 {
        /* These are necessary to get AEC6280 Macintosh cards to work */
        if ((dev->device == PCI_DEVICE_ID_ARTOP_ATP865) ||
@@ -156,7 +156,7 @@ static unsigned int init_chipset_aec62xx(struct pci_dev *dev)
                pci_write_config_byte(dev, 0x4a, reg4ah | 0x80);
        }
-        return dev->irq;
+        return 0;
 }
 static u8 atp86x_cable_detect(ide_hwif_t *hwif)
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 66f43083408b..d3513b6b8530 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -212,7 +212,7 @@ static int ali15x3_dma_setup(ide_drive_t *drive)
 *      appropriate also sets up the 1533 southbridge.
 */
-static unsigned int init_chipset_ali15x3(struct pci_dev *dev)
+static int init_chipset_ali15x3(struct pci_dev *dev)
 {
        unsigned long flags;
        u8 tmpbyte;
diff --git a/drivers/ide/amd74xx.c b/drivers/ide/amd74xx.c
index 77267c859965..628cd2e5fed8 100644
--- a/drivers/ide/amd74xx.c
+++ b/drivers/ide/amd74xx.c
@@ -140,7 +140,7 @@ static void amd7411_cable_detect(struct pci_dev *dev)
 * The initialization callback.  Initialize drive independent registers.
 */
-static unsigned int init_chipset_amd74xx(struct pci_dev *dev)
+static int init_chipset_amd74xx(struct pci_dev *dev)
 {
        u8 t = 0, offset = amd_offset(dev);
@@ -172,7 +172,7 @@ static unsigned int init_chipset_amd74xx(struct pci_dev *dev)
                t |= 0xf0;
        pci_write_config_byte(dev, AMD_IDE_CONFIG + offset, t);
-        return dev->irq;
+        return 0;
 }
 static u8 amd_cable_detect(ide_hwif_t *hwif)
@@ -183,14 +183,6 @@ static u8 amd_cable_detect(ide_hwif_t *hwif)
                return ATA_CBL_PATA40;
 }
-static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
-{
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-        if (hwif->irq == 0) /* 0 is bogus but will do for now */
-                hwif->irq = pci_get_legacy_ide_irq(dev, hwif->channel);
-}
 static const struct ide_port_ops amd_port_ops = {
        .set_pio_mode           = amd_set_pio_mode,
        .set_dma_mode           = amd_set_drive,
@@ -207,7 +199,6 @@ static const struct ide_port_ops amd_port_ops = {
        {                                                               \
                .name           = DRV_NAME,                             \
                .init_chipset   = init_chipset_amd74xx,                 \
-                .init_hwif      = init_hwif_amd74xx,                    \
                .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \
                .port_ops       = &amd_port_ops,                        \
                .host_flags     = IDE_HFLAGS_AMD,                       \
@@ -221,7 +212,6 @@ static const struct ide_port_ops amd_port_ops = {
        {                                                               \
                .name           = DRV_NAME,                             \
                .init_chipset   = init_chipset_amd74xx,                 \
-                .init_hwif      = init_hwif_amd74xx,                    \
                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \
                .port_ops       = &amd_port_ops,                        \
                .host_flags     = IDE_HFLAGS_AMD,                       \
diff --git a/drivers/ide/atiixp.c b/drivers/ide/atiixp.c
index ecd1e62ca91a..923cbfe259d3 100644
--- a/drivers/ide/atiixp.c
+++ b/drivers/ide/atiixp.c
@@ -142,7 +142,6 @@ static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
                .name           = DRV_NAME,
                .enablebits     = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
                .port_ops       = &atiixp_port_ops,
-                .host_flags     = IDE_HFLAG_LEGACY_IRQS,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
@@ -151,7 +150,7 @@ static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
                .name           = DRV_NAME,
                .enablebits     = {{0x48,0x01,0x00}, {0x00,0x00,0x00}},
                .port_ops       = &atiixp_port_ops,
-                .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS,
+                .host_flags     = IDE_HFLAG_SINGLE,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
diff --git a/drivers/ide/au1xxx-ide.c b/drivers/ide/au1xxx-ide.c
index 79a2dfed8eb7..154ec2cf734f 100644
--- a/drivers/ide/au1xxx-ide.c
+++ b/drivers/ide/au1xxx-ide.c
@@ -536,9 +536,8 @@ static const struct ide_port_info au1xxx_port_info = {
 #endif
 };
-static int au_ide_probe(struct device *dev)
+static int au_ide_probe(struct platform_device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
        _auide_hwif *ahwif = &auide_hwif;
        struct resource *res;
        struct ide_host *host;
@@ -552,23 +551,23 @@ static int au_ide_probe(struct device *dev)
 #endif
        memset(&auide_hwif, 0, sizeof(_auide_hwif));
-        ahwif->irq = platform_get_irq(pdev, 0);
+        ahwif->irq = platform_get_irq(dev, 0);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
        if (res == NULL) {
-                pr_debug("%s %d: no base address\n", DRV_NAME, pdev->id);
+                pr_debug("%s %d: no base address\n", DRV_NAME, dev->id);
                ret = -ENODEV;
                goto out;
        }
        if (ahwif->irq < 0) {
-                pr_debug("%s %d: no IRQ\n", DRV_NAME, pdev->id);
+                pr_debug("%s %d: no IRQ\n", DRV_NAME, dev->id);
                ret = -ENODEV;
                goto out;
        }
        if (!request_mem_region(res->start, res->end - res->start + 1,
-                                pdev->name)) {
+                                dev->name)) {
                pr_debug("%s: request_mem_region failed\n", DRV_NAME);
                ret =  -EBUSY;
                goto out;
@@ -583,7 +582,7 @@ static int au_ide_probe(struct device *dev)
        memset(&hw, 0, sizeof(hw));
        auide_setup_ports(&hw, ahwif);
        hw.irq = ahwif->irq;
-        hw.dev = dev;
+        hw.dev = &dev->dev;
        hw.chipset = ide_au1xxx;
        ret = ide_host_add(&au1xxx_port_info, hws, &host);
@@ -592,7 +591,7 @@ static int au_ide_probe(struct device *dev)
        auide_hwif.hwif = host->ports[0];
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
        printk(KERN_INFO "Au1xxx IDE(builtin) configured for %s\n", mode );
@@ -600,38 +599,39 @@ static int au_ide_probe(struct device *dev)
        return ret;
 }
-static int au_ide_remove(struct device *dev)
+static int au_ide_remove(struct platform_device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
        struct resource *res;
-        struct ide_host *host = dev_get_drvdata(dev);
+        struct ide_host *host = platform_get_drvdata(dev);
        _auide_hwif *ahwif = &auide_hwif;
        ide_host_remove(host);
        iounmap((void *)ahwif->regbase);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
        release_mem_region(res->start, res->end - res->start + 1);
        return 0;
 }
-static struct device_driver au1200_ide_driver = {
+static struct platform_driver au1200_ide_driver = {
-        .name           = "au1200-ide",
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = "au1200-ide",
+                .owner          = THIS_MODULE,
+        },
        .probe          = au_ide_probe,
        .remove         = au_ide_remove,
 };
 static int __init au_ide_init(void)
 {
-        return driver_register(&au1200_ide_driver);
+        return platform_driver_register(&au1200_ide_driver);
 }
 static void __exit au_ide_exit(void)
 {
-        driver_unregister(&au1200_ide_driver);
+        platform_driver_unregister(&au1200_ide_driver);
 }
 MODULE_LICENSE("GPL");
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index 2f9688d87ecd..aeee036b1503 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -333,7 +333,7 @@ static int cmd646_1_dma_end(ide_drive_t *drive)
        return (dma_stat & 7) != 4;
 }
-static unsigned int init_chipset_cmd64x(struct pci_dev *dev)
+static int init_chipset_cmd64x(struct pci_dev *dev)
 {
        u8 mrdmode = 0;
diff --git a/drivers/ide/cs5520.c b/drivers/ide/cs5520.c
index d003bec56ff9..58fb90e5b763 100644
--- a/drivers/ide/cs5520.c
+++ b/drivers/ide/cs5520.c
@@ -133,7 +133,8 @@ static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_devic
         *      do all the device setup for us
         */
-        ide_pci_setup_ports(dev, d, 14, &hw[0], &hws[0]);
+        ide_pci_setup_ports(dev, d, &hw[0], &hws[0]);
+        hw[0].irq = 14;
        return ide_host_add(d, hws, NULL);
 }
diff --git a/drivers/ide/cs5530.c b/drivers/ide/cs5530.c
index d8ede85fe17f..8e8b35a89901 100644
--- a/drivers/ide/cs5530.c
+++ b/drivers/ide/cs5530.c
@@ -135,7 +135,7 @@ static void cs5530_set_dma_mode(ide_drive_t *drive, const u8 mode)
 *      Initialize the cs5530 bridge for reliable IDE DMA operation.
 */
-static unsigned int init_chipset_cs5530(struct pci_dev *dev)
+static int init_chipset_cs5530(struct pci_dev *dev)
 {
        struct pci_dev *master_0 = NULL, *cs5530_0 = NULL;
diff --git a/drivers/ide/delkin_cb.c b/drivers/ide/delkin_cb.c
index 8f1b2d9f0513..bacb1194c9c9 100644
--- a/drivers/ide/delkin_cb.c
+++ b/drivers/ide/delkin_cb.c
@@ -46,7 +46,7 @@ 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)
+static int delkin_cb_init_chipset(struct pci_dev *dev)
 {
        unsigned long base = pci_resource_start(dev, 0);
        int i;
diff --git a/drivers/ide/hpt366.c b/drivers/ide/hpt366.c
index 3eb9b5c63a0f..d3b3e824f445 100644
--- a/drivers/ide/hpt366.c
+++ b/drivers/ide/hpt366.c
@@ -995,7 +995,7 @@ static void hpt3xx_disable_fast_irq(struct pci_dev *dev, u8 mcr_addr)
                pci_write_config_byte(dev, mcr_addr + 1, new_mcr);
 }
-static unsigned int init_chipset_hpt366(struct pci_dev *dev)
+static int init_chipset_hpt366(struct pci_dev *dev)
 {
        unsigned long io_base   = pci_resource_start(dev, 4);
        struct hpt_info *info   = hpt3xx_get_info(&dev->dev);
@@ -1237,7 +1237,7 @@ static unsigned int init_chipset_hpt366(struct pci_dev *dev)
        hpt3xx_disable_fast_irq(dev, 0x50);
        hpt3xx_disable_fast_irq(dev, 0x54);
-        return dev->irq;
+        return 0;
 }
 static u8 hpt3xx_cable_detect(ide_hwif_t *hwif)
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index ec7d07fa570a..5b704f1ea90c 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -20,9 +20,6 @@
 #include <acpi/acpi_bus.h>
 #define REGS_PER_GTF            7
-struct taskfile_array {
-        u8      tfa[REGS_PER_GTF];      /* regs. 0x1f1 - 0x1f7 */
-};
 struct GTM_buffer {
        u32     PIO_speed0;
@@ -89,12 +86,8 @@ static const struct dmi_system_id ide_acpi_dmi_table[] = {
        { }     /* terminate list */
 };
-static int ide_acpi_blacklist(void)
+int ide_acpi_init(void)
 {
-        static int done;
-        if (done)
-                return 0;
-        done = 1;
        dmi_check_system(ide_acpi_dmi_table);
        return 0;
 }
@@ -202,40 +195,6 @@ static acpi_handle ide_acpi_hwif_get_handle(ide_hwif_t *hwif)
 }
 /**
- * ide_acpi_drive_get_handle - Get ACPI object handle for a given drive
- * @drive: device to locate
- *
- * Retrieves the object handle of a given drive. According to the ACPI
- * spec the drive is a child of the hwif.
- *
- * Returns handle on success, 0 on error.
- */
-static acpi_handle ide_acpi_drive_get_handle(ide_drive_t *drive)
-{
-        ide_hwif_t      *hwif = drive->hwif;
-        int              port;
-        acpi_handle      drive_handle;
-        if (!hwif->acpidata)
-                return NULL;
-        if (!hwif->acpidata->obj_handle)
-                return NULL;
-        port = hwif->channel ? drive->dn - 2: drive->dn;
-        DEBPRINT("ENTER: %s at channel#: %d port#: %d\n",
-                 drive->name, hwif->channel, port);
-        /* TBD: could also check ACPI object VALID bits */
-        drive_handle = acpi_get_child(hwif->acpidata->obj_handle, port);
-        DEBPRINT("drive %s handle 0x%p\n", drive->name, drive_handle);
-        return drive_handle;
-}
-/**
 * do_drive_get_GTF - get the drive bootup default taskfile settings
 * @drive: the drive for which the taskfile settings should be retrieved
 * @gtf_length: number of bytes of _GTF data returned at @gtf_address
@@ -257,47 +216,15 @@ static int do_drive_get_GTF(ide_drive_t *drive,
        acpi_status                     status;
        struct acpi_buffer              output;
        union acpi_object               *out_obj;
-        ide_hwif_t                      *hwif = drive->hwif;
-        struct device                   *dev = hwif->gendev.parent;
        int                             err = -ENODEV;
-        int                             port;
        *gtf_length = 0;
        *gtf_address = 0UL;
        *obj_loc = 0UL;
-        if (ide_noacpi)
-                return 0;
-        if (!dev) {
-                DEBPRINT("no PCI device for %s\n", hwif->name);
-                goto out;
-        }
-        if (!hwif->acpidata) {
-                DEBPRINT("no ACPI data for %s\n", hwif->name);
-                goto out;
-        }
-        port = hwif->channel ? drive->dn - 2: drive->dn;
-        DEBPRINT("ENTER: %s at %s, port#: %d, hard_port#: %d\n",
-                 hwif->name, dev_name(dev), port, hwif->channel);
-        if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0) {
-                DEBPRINT("%s drive %d:%d not present\n",
-                         hwif->name, hwif->channel, port);
-                goto out;
-        }
-        /* Get this drive's _ADR info. if not already known. */
        if (!drive->acpidata->obj_handle) {
-                drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive);
+                DEBPRINT("No ACPI object found for %s\n", drive->name);
-                if (!drive->acpidata->obj_handle) {
+                goto out;
-                        DEBPRINT("No ACPI object found for %s\n",
-                                 drive->name);
-                        goto out;
-                }
        }
        /* Setting up output buffer */
@@ -355,43 +282,6 @@ out:
 }
 /**
- * taskfile_load_raw - send taskfile registers to drive
- * @drive: drive to which output is sent
- * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
- *
- * Outputs IDE taskfile to the drive.
- */
-static int taskfile_load_raw(ide_drive_t *drive,
-                              const struct taskfile_array *gtf)
-{
-        ide_task_t args;
-        int err = 0;
-        DEBPRINT("(0x1f1-1f7): hex: "
-               "%02x %02x %02x %02x %02x %02x %02x\n",
-               gtf->tfa[0], gtf->tfa[1], gtf->tfa[2],
-               gtf->tfa[3], gtf->tfa[4], gtf->tfa[5], gtf->tfa[6]);
-        memset(&args, 0, sizeof(ide_task_t));
-        /* convert gtf to IDE Taskfile */
-        memcpy(&args.tf_array[7], &gtf->tfa, 7);
-        args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-        if (!ide_acpigtf) {
-                DEBPRINT("_GTF execution disabled\n");
-                return err;
-        }
-        err = ide_no_data_taskfile(drive, &args);
-        if (err)
-                printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
-                       __func__, err);
-        return err;
-}
-/**
 * do_drive_set_taskfiles - write the drive taskfile settings from _GTF
 * @drive: the drive to which the taskfile command should be sent
 * @gtf_length: total number of bytes of _GTF taskfiles
@@ -404,43 +294,41 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
                                  unsigned int gtf_length,
                                  unsigned long gtf_address)
 {
-        int                     rc = -ENODEV, err;
+        int                     rc = 0, err;
        int                     gtf_count = gtf_length / REGS_PER_GTF;
        int                     ix;
-        struct taskfile_array   *gtf;
-        if (ide_noacpi)
-                return 0;
-        DEBPRINT("ENTER: %s, hard_port#: %d\n", drive->name, drive->dn);
-        if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
-                goto out;
-        if (!gtf_count)         /* shouldn't be here */
-                goto out;
        DEBPRINT("total GTF bytes=%u (0x%x), gtf_count=%d, addr=0x%lx\n",
                 gtf_length, gtf_length, gtf_count, gtf_address);
-        if (gtf_length % REGS_PER_GTF) {
+        /* send all taskfile registers (0x1f1-0x1f7) *in*that*order* */
-                printk(KERN_ERR "%s: unexpected GTF length (%d)\n",
-                       __func__, gtf_length);
-                goto out;
-        }
-        rc = 0;
        for (ix = 0; ix < gtf_count; ix++) {
-                gtf = (struct taskfile_array *)
+                u8 *gtf = (u8 *)(gtf_address + ix * REGS_PER_GTF);
-                        (gtf_address + ix * REGS_PER_GTF);
+                ide_task_t task;
-                /* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
+                DEBPRINT("(0x1f1-1f7): "
-                err = taskfile_load_raw(drive, gtf);
+                         "hex: %02x %02x %02x %02x %02x %02x %02x\n",
-                if (err)
+                         gtf[0], gtf[1], gtf[2],
+                         gtf[3], gtf[4], gtf[5], gtf[6]);
+                if (!ide_acpigtf) {
+                        DEBPRINT("_GTF execution disabled\n");
+                        continue;
+                }
+                /* convert GTF to taskfile */
+                memset(&task, 0, sizeof(ide_task_t));
+                memcpy(&task.tf_array[7], gtf, REGS_PER_GTF);
+                task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+                err = ide_no_data_taskfile(drive, &task);
+                if (err) {
+                        printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
+                                        __func__, err);
                        rc = err;
+                }
        }
-out:
        return rc;
 }
@@ -647,26 +535,23 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
                DEBPRINT("no ACPI data for %s\n", hwif->name);
                return;
        }
        /* channel first and then drives for power on and verse versa for power off */
        if (on)
                acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0);
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if (!drive->acpidata->obj_handle)
+                if (drive->acpidata->obj_handle)
-                        drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive);
-                if (drive->acpidata->obj_handle &&
-                    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
                        acpi_bus_set_power(drive->acpidata->obj_handle,
-                                on? ACPI_STATE_D0: ACPI_STATE_D3);
+                                           on ? ACPI_STATE_D0 : ACPI_STATE_D3);
-                }
        }
        if (!on)
                acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D3);
 }
 /**
- * ide_acpi_init - initialize the ACPI link for an IDE interface
+ * ide_acpi_init_port - initialize the ACPI link for an IDE interface
 * @hwif: target IDE interface (channel)
 *
 * The ACPI spec is not quite clear when the drive identify buffer
@@ -676,10 +561,8 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
 * So we get the information during startup; but this means that
 * any changes during run-time will be lost after resume.
 */
-void ide_acpi_init(ide_hwif_t *hwif)
+void ide_acpi_init_port(ide_hwif_t *hwif)
 {
-        ide_acpi_blacklist();
        hwif->acpidata = kzalloc(sizeof(struct ide_acpi_hwif_link), GFP_KERNEL);
        if (!hwif->acpidata)
                return;
@@ -708,15 +591,24 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
        hwif->devices[0]->acpidata = &hwif->acpidata->master;
        hwif->devices[1]->acpidata = &hwif->acpidata->slave;
-        /*
+        /* get _ADR info for each device */
-         * Send IDENTIFY for each drive
+        ide_port_for_each_present_dev(i, drive, hwif) {
-         */
+                acpi_handle dev_handle;
-        ide_port_for_each_dev(i, drive, hwif) {
-                memset(drive->acpidata, 0, sizeof(*drive->acpidata));
-                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
+                DEBPRINT("ENTER: %s at channel#: %d port#: %d\n",
-                        continue;
+                         drive->name, hwif->channel, drive->dn & 1);
+                /* TBD: could also check ACPI object VALID bits */
+                dev_handle = acpi_get_child(hwif->acpidata->obj_handle,
+                                            drive->dn & 1);
+                DEBPRINT("drive %s handle 0x%p\n", drive->name, dev_handle);
+                drive->acpidata->obj_handle = dev_handle;
+        }
+        /* send IDENTIFY for each device */
+        ide_port_for_each_present_dev(i, drive, hwif) {
                err = taskfile_lib_get_identify(drive, drive->acpidata->idbuff);
                if (err)
                        DEBPRINT("identify device %s failed (%d)\n",
@@ -736,9 +628,7 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
        ide_acpi_get_timing(hwif);
        ide_acpi_push_timing(hwif);
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if (drive->dev_flags & IDE_DFLAG_PRESENT)
+                ide_acpi_exec_tfs(drive);
-                        /* Execute ACPI startup code */
-                        ide_acpi_exec_tfs(drive);
        }
 }
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index e9d042dba0e0..6adc5b4a4406 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -149,7 +149,10 @@ static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
        memcpy(rq->cmd, pc->c, 12);
        if (drive->media == ide_tape)
                rq->cmd[13] = REQ_IDETAPE_PC1;
-        ide_do_drive_cmd(drive, rq);
+        drive->hwif->rq = NULL;
+        elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
 }
 /*
@@ -297,6 +300,21 @@ int ide_cd_get_xferlen(struct request *rq)
 }
 EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
+void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
+{
+        ide_task_t task;
+        memset(&task, 0, sizeof(task));
+        task.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
+                        IDE_TFLAG_IN_NSECT;
+        drive->hwif->tp_ops->tf_read(drive, &task);
+        *bcount = (task.tf.lbah << 8) | task.tf.lbam;
+        *ireason = task.tf.nsect & 3;
+}
+EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
 /*
 * This is the usual interrupt handler which will be called during a packet
 * command.  We will transfer some of the data (as requested by the drive)
@@ -456,6 +474,25 @@ next_irq:
        return ide_started;
 }
+static void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        ide_task_t task;
+        u8 dma = drive->dma;
+        memset(&task, 0, sizeof(task));
+        task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
+                        IDE_TFLAG_OUT_FEATURE | tf_flags;
+        task.tf.feature = dma;          /* Use PIO/DMA */
+        task.tf.lbam    = bcount & 0xff;
+        task.tf.lbah    = (bcount >> 8) & 0xff;
+        ide_tf_dump(drive->name, &task.tf);
+        hwif->tp_ops->set_irq(hwif, 1);
+        SELECT_MASK(drive, 0);
+        hwif->tp_ops->tf_load(drive, &task);
+}
 static u8 ide_read_ireason(ide_drive_t *drive)
 {
        ide_task_t task;
@@ -629,7 +666,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive)
                                                       : WAIT_TAPE_CMD;
        }
-        ide_pktcmd_tf_load(drive, tf_flags, bcount, drive->dma);
+        ide_pktcmd_tf_load(drive, tf_flags, bcount);
        /* Issue the packet command */
        if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index ddfbea41d296..2177cd11664c 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -242,7 +242,9 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
                ide_debug_log(IDE_DBG_SENSE, "failed_cmd: 0x%x\n",
                              failed_command->cmd[0]);
-        ide_do_drive_cmd(drive, rq);
+        drive->hwif->rq = NULL;
+        elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
 }
 static void cdrom_end_request(ide_drive_t *drive, int uptodate)
diff --git a/drivers/ide/ide-devsets.c b/drivers/ide/ide-devsets.c
new file mode 100644
index 000000000000..7c3953414d47
--- /dev/null
+++ b/drivers/ide/ide-devsets.c
@@ -0,0 +1,190 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+DEFINE_MUTEX(ide_setting_mtx);
+ide_devset_get(io_32bit, io_32bit);
+static int set_io_32bit(ide_drive_t *drive, int arg)
+{
+        if (drive->dev_flags & IDE_DFLAG_NO_IO_32BIT)
+                return -EPERM;
+        if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
+                return -EINVAL;
+        drive->io_32bit = arg;
+        return 0;
+}
+ide_devset_get_flag(ksettings, IDE_DFLAG_KEEP_SETTINGS);
+static int set_ksettings(ide_drive_t *drive, int arg)
+{
+        if (arg < 0 || arg > 1)
+                return -EINVAL;
+        if (arg)
+                drive->dev_flags |= IDE_DFLAG_KEEP_SETTINGS;
+        else
+                drive->dev_flags &= ~IDE_DFLAG_KEEP_SETTINGS;
+        return 0;
+}
+ide_devset_get_flag(using_dma, IDE_DFLAG_USING_DMA);
+static int set_using_dma(ide_drive_t *drive, int arg)
+{
+#ifdef CONFIG_BLK_DEV_IDEDMA
+        int err = -EPERM;
+        if (arg < 0 || arg > 1)
+                return -EINVAL;
+        if (ata_id_has_dma(drive->id) == 0)
+                goto out;
+        if (drive->hwif->dma_ops == NULL)
+                goto out;
+        err = 0;
+        if (arg) {
+                if (ide_set_dma(drive))
+                        err = -EIO;
+        } else
+                ide_dma_off(drive);
+out:
+        return err;
+#else
+        if (arg < 0 || arg > 1)
+                return -EINVAL;
+        return -EPERM;
+#endif
+}
+/*
+ * handle HDIO_SET_PIO_MODE ioctl abusers here, eventually it will go away
+ */
+static int set_pio_mode_abuse(ide_hwif_t *hwif, u8 req_pio)
+{
+        switch (req_pio) {
+        case 202:
+        case 201:
+        case 200:
+        case 102:
+        case 101:
+        case 100:
+                return (hwif->host_flags & IDE_HFLAG_ABUSE_DMA_MODES) ? 1 : 0;
+        case 9:
+        case 8:
+                return (hwif->host_flags & IDE_HFLAG_ABUSE_PREFETCH) ? 1 : 0;
+        case 7:
+        case 6:
+                return (hwif->host_flags & IDE_HFLAG_ABUSE_FAST_DEVSEL) ? 1 : 0;
+        default:
+                return 0;
+        }
+}
+static int set_pio_mode(ide_drive_t *drive, int arg)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        if (arg < 0 || arg > 255)
+                return -EINVAL;
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
+                return -ENOSYS;
+        if (set_pio_mode_abuse(drive->hwif, arg)) {
+                if (arg == 8 || arg == 9) {
+                        unsigned long flags;
+                        /* take lock for IDE_DFLAG_[NO_]UNMASK/[NO_]IO_32BIT */
+                        spin_lock_irqsave(&hwif->lock, flags);
+                        port_ops->set_pio_mode(drive, arg);
+                        spin_unlock_irqrestore(&hwif->lock, flags);
+                } else
+                        port_ops->set_pio_mode(drive, arg);
+        } else {
+                int keep_dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
+                ide_set_pio(drive, arg);
+                if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) {
+                        if (keep_dma)
+                                ide_dma_on(drive);
+                }
+        }
+        return 0;
+}
+ide_devset_get_flag(unmaskirq, IDE_DFLAG_UNMASK);
+static int set_unmaskirq(ide_drive_t *drive, int arg)
+{
+        if (drive->dev_flags & IDE_DFLAG_NO_UNMASK)
+                return -EPERM;
+        if (arg < 0 || arg > 1)
+                return -EINVAL;
+        if (arg)
+                drive->dev_flags |= IDE_DFLAG_UNMASK;
+        else
+                drive->dev_flags &= ~IDE_DFLAG_UNMASK;
+        return 0;
+}
+ide_ext_devset_rw_sync(io_32bit, io_32bit);
+ide_ext_devset_rw_sync(keepsettings, ksettings);
+ide_ext_devset_rw_sync(unmaskirq, unmaskirq);
+ide_ext_devset_rw_sync(using_dma, using_dma);
+__IDE_DEVSET(pio_mode, DS_SYNC, NULL, set_pio_mode);
+int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
+                       int arg)
+{
+        struct request_queue *q = drive->queue;
+        struct request *rq;
+        int ret = 0;
+        if (!(setting->flags & DS_SYNC))
+                return setting->set(drive, arg);
+        rq = blk_get_request(q, READ, __GFP_WAIT);
+        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_len = 5;
+        rq->cmd[0] = REQ_DEVSET_EXEC;
+        *(int *)&rq->cmd[1] = arg;
+        rq->special = setting->set;
+        if (blk_execute_rq(q, NULL, rq, 0))
+                ret = rq->errors;
+        blk_put_request(rq);
+        return ret;
+}
+ide_startstop_t ide_do_devset(ide_drive_t *drive, struct request *rq)
+{
+        int err, (*setfunc)(ide_drive_t *, int) = rq->special;
+        err = setfunc(drive, *(int *)&rq->cmd[1]);
+        if (err)
+                rq->errors = err;
+        else
+                err = 1;
+        ide_end_request(drive, err, 0);
+        return ide_stopped;
+}
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 059c90bb5ad2..a878f4734f81 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -470,6 +470,63 @@ void ide_dma_timeout(ide_drive_t *drive)
 }
 EXPORT_SYMBOL_GPL(ide_dma_timeout);
+/*
+ * un-busy the port etc, and clear any pending DMA status. we want to
+ * retry the current request in pio mode instead of risking tossing it
+ * all away
+ */
+ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct request *rq;
+        ide_startstop_t ret = ide_stopped;
+        /*
+         * end current dma transaction
+         */
+        if (error < 0) {
+                printk(KERN_WARNING "%s: DMA timeout error\n", drive->name);
+                (void)hwif->dma_ops->dma_end(drive);
+                ret = ide_error(drive, "dma timeout error",
+                                hwif->tp_ops->read_status(hwif));
+        } else {
+                printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name);
+                hwif->dma_ops->dma_timeout(drive);
+        }
+        /*
+         * disable dma for now, but remember that we did so because of
+         * a timeout -- we'll reenable after we finish this next request
+         * (or rather the first chunk of it) in pio.
+         */
+        drive->dev_flags |= IDE_DFLAG_DMA_PIO_RETRY;
+        drive->retry_pio++;
+        ide_dma_off_quietly(drive);
+        /*
+         * un-busy drive etc and make sure request is sane
+         */
+        rq = hwif->rq;
+        if (!rq)
+                goto out;
+        hwif->rq = NULL;
+        rq->errors = 0;
+        if (!rq->bio)
+                goto out;
+        rq->sector = rq->bio->bi_sector;
+        rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9;
+        rq->hard_cur_sectors = rq->current_nr_sectors;
+        rq->buffer = bio_data(rq->bio);
+out:
+        return ret;
+}
 void ide_release_dma_engine(ide_hwif_t *hwif)
 {
        if (hwif->dmatable_cpu) {
diff --git a/drivers/ide/ide-eh.c b/drivers/ide/ide-eh.c
new file mode 100644
index 000000000000..1231b5e486f2
--- /dev/null
+++ b/drivers/ide/ide-eh.c
@@ -0,0 +1,428 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+#include <linux/delay.h>
+static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq,
+                                     u8 stat, u8 err)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        if ((stat & ATA_BUSY) ||
+            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
+                /* other bits are useless when BUSY */
+                rq->errors |= ERROR_RESET;
+        } else if (stat & ATA_ERR) {
+                /* err has different meaning on cdrom and tape */
+                if (err == ATA_ABORTED) {
+                        if ((drive->dev_flags & IDE_DFLAG_LBA) &&
+                            /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */
+                            hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS)
+                                return ide_stopped;
+                } else if ((err & BAD_CRC) == BAD_CRC) {
+                        /* UDMA crc error, just retry the operation */
+                        drive->crc_count++;
+                } else if (err & (ATA_BBK | ATA_UNC)) {
+                        /* retries won't help these */
+                        rq->errors = ERROR_MAX;
+                } else if (err & ATA_TRK0NF) {
+                        /* help it find track zero */
+                        rq->errors |= ERROR_RECAL;
+                }
+        }
+        if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ &&
+            (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) {
+                int nsect = drive->mult_count ? drive->mult_count : 1;
+                ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE);
+        }
+        if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) {
+                ide_kill_rq(drive, rq);
+                return ide_stopped;
+        }
+        if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
+                rq->errors |= ERROR_RESET;
+        if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
+                ++rq->errors;
+                return ide_do_reset(drive);
+        }
+        if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
+                drive->special.b.recalibrate = 1;
+        ++rq->errors;
+        return ide_stopped;
+}
+static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq,
+                                       u8 stat, u8 err)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        if ((stat & ATA_BUSY) ||
+            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
+                /* other bits are useless when BUSY */
+                rq->errors |= ERROR_RESET;
+        } else {
+                /* add decoding error stuff */
+        }
+        if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
+                /* force an abort */
+                hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE);
+        if (rq->errors >= ERROR_MAX) {
+                ide_kill_rq(drive, rq);
+        } else {
+                if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
+                        ++rq->errors;
+                        return ide_do_reset(drive);
+                }
+                ++rq->errors;
+        }
+        return ide_stopped;
+}
+static ide_startstop_t __ide_error(ide_drive_t *drive, struct request *rq,
+                                   u8 stat, u8 err)
+{
+        if (drive->media == ide_disk)
+                return ide_ata_error(drive, rq, stat, err);
+        return ide_atapi_error(drive, rq, stat, err);
+}
+/**
+ *      ide_error       -       handle an error on the IDE
+ *      @drive: drive the error occurred on
+ *      @msg: message to report
+ *      @stat: status bits
+ *
+ *      ide_error() takes action based on the error returned by the drive.
+ *      For normal I/O that may well include retries. We deal with
+ *      both new-style (taskfile) and old style command handling here.
+ *      In the case of taskfile command handling there is work left to
+ *      do
+ */
+ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, u8 stat)
+{
+        struct request *rq;
+        u8 err;
+        err = ide_dump_status(drive, msg, stat);
+        rq = drive->hwif->rq;
+        if (rq == NULL)
+                return ide_stopped;
+        /* retry only "normal" I/O: */
+        if (!blk_fs_request(rq)) {
+                rq->errors = 1;
+                ide_end_drive_cmd(drive, stat, err);
+                return ide_stopped;
+        }
+        return __ide_error(drive, rq, stat, err);
+}
+EXPORT_SYMBOL_GPL(ide_error);
+static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
+{
+        struct request *rq = drive->hwif->rq;
+        if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET)
+                ide_end_request(drive, err ? err : 1, 0);
+}
+/* needed below */
+static ide_startstop_t do_reset1(ide_drive_t *, int);
+/*
+ * atapi_reset_pollfunc() gets invoked to poll the interface for completion
+ * every 50ms during an atapi drive reset operation.  If the drive has not yet
+ * responded, and we have not yet hit our maximum waiting time, then the timer
+ * is restarted for another 50ms.
+ */
+static ide_startstop_t atapi_reset_pollfunc(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        u8 stat;
+        SELECT_DRIVE(drive);
+        udelay(10);
+        stat = hwif->tp_ops->read_status(hwif);
+        if (OK_STAT(stat, 0, ATA_BUSY))
+                printk(KERN_INFO "%s: ATAPI reset complete\n", drive->name);
+        else {
+                if (time_before(jiffies, hwif->poll_timeout)) {
+                        ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20,
+                                        NULL);
+                        /* continue polling */
+                        return ide_started;
+                }
+                /* end of polling */
+                hwif->polling = 0;
+                printk(KERN_ERR "%s: ATAPI reset timed-out, status=0x%02x\n",
+                        drive->name, stat);
+                /* do it the old fashioned way */
+                return do_reset1(drive, 1);
+        }
+        /* done polling */
+        hwif->polling = 0;
+        ide_complete_drive_reset(drive, 0);
+        return ide_stopped;
+}
+static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
+{
+        static const char *err_master_vals[] =
+                { NULL, "passed", "formatter device error",
+                  "sector buffer error", "ECC circuitry error",
+                  "controlling MPU error" };
+        u8 err_master = err & 0x7f;
+        printk(KERN_ERR "%s: reset: master: ", hwif->name);
+        if (err_master && err_master < 6)
+                printk(KERN_CONT "%s", err_master_vals[err_master]);
+        else
+                printk(KERN_CONT "error (0x%02x?)", err);
+        if (err & 0x80)
+                printk(KERN_CONT "; slave: failed");
+        printk(KERN_CONT "\n");
+}
+/*
+ * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
+ * during an ide reset operation. If the drives have not yet responded,
+ * and we have not yet hit our maximum waiting time, then the timer is restarted
+ * for another 50ms.
+ */
+static ide_startstop_t reset_pollfunc(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        u8 tmp;
+        int err = 0;
+        if (port_ops && port_ops->reset_poll) {
+                err = port_ops->reset_poll(drive);
+                if (err) {
+                        printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
+                                hwif->name, drive->name);
+                        goto out;
+                }
+        }
+        tmp = hwif->tp_ops->read_status(hwif);
+        if (!OK_STAT(tmp, 0, ATA_BUSY)) {
+                if (time_before(jiffies, hwif->poll_timeout)) {
+                        ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
+                        /* continue polling */
+                        return ide_started;
+                }
+                printk(KERN_ERR "%s: reset timed-out, status=0x%02x\n",
+                        hwif->name, tmp);
+                drive->failures++;
+                err = -EIO;
+        } else  {
+                tmp = ide_read_error(drive);
+                if (tmp == 1) {
+                        printk(KERN_INFO "%s: reset: success\n", hwif->name);
+                        drive->failures = 0;
+                } else {
+                        ide_reset_report_error(hwif, tmp);
+                        drive->failures++;
+                        err = -EIO;
+                }
+        }
+out:
+        hwif->polling = 0;      /* done polling */
+        ide_complete_drive_reset(drive, err);
+        return ide_stopped;
+}
+static void ide_disk_pre_reset(ide_drive_t *drive)
+{
+        int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1;
+        drive->special.all = 0;
+        drive->special.b.set_geometry = legacy;
+        drive->special.b.recalibrate  = legacy;
+        drive->mult_count = 0;
+        drive->dev_flags &= ~IDE_DFLAG_PARKED;
+        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 &&
+            (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0)
+                drive->mult_req = 0;
+        if (drive->mult_req != drive->mult_count)
+                drive->special.b.set_multmode = 1;
+}
+static void pre_reset(ide_drive_t *drive)
+{
+        const struct ide_port_ops *port_ops = drive->hwif->port_ops;
+        if (drive->media == ide_disk)
+                ide_disk_pre_reset(drive);
+        else
+                drive->dev_flags |= IDE_DFLAG_POST_RESET;
+        if (drive->dev_flags & IDE_DFLAG_USING_DMA) {
+                if (drive->crc_count)
+                        ide_check_dma_crc(drive);
+                else
+                        ide_dma_off(drive);
+        }
+        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) {
+                if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) {
+                        drive->dev_flags &= ~IDE_DFLAG_UNMASK;
+                        drive->io_32bit = 0;
+                }
+                return;
+        }
+        if (port_ops && port_ops->pre_reset)
+                port_ops->pre_reset(drive);
+        if (drive->current_speed != 0xff)
+                drive->desired_speed = drive->current_speed;
+        drive->current_speed = 0xff;
+}
+/*
+ * do_reset1() attempts to recover a confused drive by resetting it.
+ * Unfortunately, resetting a disk drive actually resets all devices on
+ * the same interface, so it can really be thought of as resetting the
+ * interface rather than resetting the drive.
+ *
+ * ATAPI devices have their own reset mechanism which allows them to be
+ * individually reset without clobbering other devices on the same interface.
+ *
+ * Unfortunately, the IDE interface does not generate an interrupt to let
+ * us know when the reset operation has finished, so we must poll for this.
+ * Equally poor, though, is the fact that this may a very long time to complete,
+ * (up to 30 seconds worstcase).  So, instead of busy-waiting here for it,
+ * we set a timer to poll at 50ms intervals.
+ */
+static ide_startstop_t do_reset1(ide_drive_t *drive, int do_not_try_atapi)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
+        const struct ide_port_ops *port_ops;
+        ide_drive_t *tdrive;
+        unsigned long flags, timeout;
+        int i;
+        DEFINE_WAIT(wait);
+        spin_lock_irqsave(&hwif->lock, flags);
+        /* We must not reset with running handlers */
+        BUG_ON(hwif->handler != NULL);
+        /* For an ATAPI device, first try an ATAPI SRST. */
+        if (drive->media != ide_disk && !do_not_try_atapi) {
+                pre_reset(drive);
+                SELECT_DRIVE(drive);
+                udelay(20);
+                tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
+                ndelay(400);
+                hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
+                hwif->polling = 1;
+                __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
+                spin_unlock_irqrestore(&hwif->lock, flags);
+                return ide_started;
+        }
+        /* We must not disturb devices in the IDE_DFLAG_PARKED state. */
+        do {
+                unsigned long now;
+                prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
+                timeout = jiffies;
+                ide_port_for_each_present_dev(i, tdrive, hwif) {
+                        if ((tdrive->dev_flags & IDE_DFLAG_PARKED) &&
+                            time_after(tdrive->sleep, timeout))
+                                timeout = tdrive->sleep;
+                }
+                now = jiffies;
+                if (time_before_eq(timeout, now))
+                        break;
+                spin_unlock_irqrestore(&hwif->lock, flags);
+                timeout = schedule_timeout_uninterruptible(timeout - now);
+                spin_lock_irqsave(&hwif->lock, flags);
+        } while (timeout);
+        finish_wait(&ide_park_wq, &wait);
+        /*
+         * First, reset any device state data we were maintaining
+         * for any of the drives on this interface.
+         */
+        ide_port_for_each_dev(i, tdrive, hwif)
+                pre_reset(tdrive);
+        if (io_ports->ctl_addr == 0) {
+                spin_unlock_irqrestore(&hwif->lock, flags);
+                ide_complete_drive_reset(drive, -ENXIO);
+                return ide_stopped;
+        }
+        /*
+         * Note that we also set nIEN while resetting the device,
+         * to mask unwanted interrupts from the interface during the reset.
+         * However, due to the design of PC hardware, this will cause an
+         * immediate interrupt due to the edge transition it produces.
+         * This single interrupt gives us a "fast poll" for drives that
+         * recover from reset very quickly, saving us the first 50ms wait time.
+         *
+         * TODO: add ->softreset method and stop abusing ->set_irq
+         */
+        /* set SRST and nIEN */
+        tp_ops->set_irq(hwif, 4);
+        /* more than enough time */
+        udelay(10);
+        /* clear SRST, leave nIEN (unless device is on the quirk list) */
+        tp_ops->set_irq(hwif, drive->quirk_list == 2);
+        /* more than enough time */
+        udelay(10);
+        hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
+        hwif->polling = 1;
+        __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
+        /*
+         * Some weird controller like resetting themselves to a strange
+         * state when the disks are reset this way. At least, the Winbond
+         * 553 documentation says that
+         */
+        port_ops = hwif->port_ops;
+        if (port_ops && port_ops->resetproc)
+                port_ops->resetproc(drive);
+        spin_unlock_irqrestore(&hwif->lock, flags);
+        return ide_started;
+}
+/*
+ * ide_do_reset() is the entry point to the drive/interface reset code.
+ */
+ide_startstop_t ide_do_reset(ide_drive_t *drive)
+{
+        return do_reset1(drive, 0);
+}
+EXPORT_SYMBOL(ide_do_reset);
diff --git a/drivers/ide/ide-io-std.c b/drivers/ide/ide-io-std.c
new file mode 100644
index 000000000000..45b43dd49cda
--- /dev/null
+++ b/drivers/ide/ide-io-std.c
@@ -0,0 +1,316 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+/*
+ *      Conventional PIO operations for ATA devices
+ */
+static u8 ide_inb(unsigned long port)
+{
+        return (u8) inb(port);
+}
+static void ide_outb(u8 val, unsigned long port)
+{
+        outb(val, port);
+}
+/*
+ *      MMIO operations, typically used for SATA controllers
+ */
+static u8 ide_mm_inb(unsigned long port)
+{
+        return (u8) readb((void __iomem *) port);
+}
+static void ide_mm_outb(u8 value, unsigned long port)
+{
+        writeb(value, (void __iomem *) port);
+}
+void ide_exec_command(ide_hwif_t *hwif, u8 cmd)
+{
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
+        else
+                outb(cmd, hwif->io_ports.command_addr);
+}
+EXPORT_SYMBOL_GPL(ide_exec_command);
+u8 ide_read_status(ide_hwif_t *hwif)
+{
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                return readb((void __iomem *)hwif->io_ports.status_addr);
+        else
+                return inb(hwif->io_ports.status_addr);
+}
+EXPORT_SYMBOL_GPL(ide_read_status);
+u8 ide_read_altstatus(ide_hwif_t *hwif)
+{
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                return readb((void __iomem *)hwif->io_ports.ctl_addr);
+        else
+                return inb(hwif->io_ports.ctl_addr);
+}
+EXPORT_SYMBOL_GPL(ide_read_altstatus);
+void ide_set_irq(ide_hwif_t *hwif, int on)
+{
+        u8 ctl = ATA_DEVCTL_OBS;
+        if (on == 4) { /* hack for SRST */
+                ctl |= 4;
+                on &= ~4;
+        }
+        ctl |= on ? 0 : 2;
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                writeb(ctl, (void __iomem *)hwif->io_ports.ctl_addr);
+        else
+                outb(ctl, hwif->io_ports.ctl_addr);
+}
+EXPORT_SYMBOL_GPL(ide_set_irq);
+void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        struct ide_taskfile *tf = &task->tf;
+        void (*tf_outb)(u8 addr, unsigned long port);
+        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
+        u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+        if (mmio)
+                tf_outb = ide_mm_outb;
+        else
+                tf_outb = ide_outb;
+        if (task->tf_flags & IDE_TFLAG_FLAGGED)
+                HIHI = 0xFF;
+        if (task->tf_flags & IDE_TFLAG_OUT_DATA) {
+                u16 data = (tf->hob_data << 8) | tf->data;
+                if (mmio)
+                        writew(data, (void __iomem *)io_ports->data_addr);
+                else
+                        outw(data, io_ports->data_addr);
+        }
+        if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
+                tf_outb(tf->hob_feature, io_ports->feature_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
+                tf_outb(tf->hob_nsect, io_ports->nsect_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
+                tf_outb(tf->hob_lbal, io_ports->lbal_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
+                tf_outb(tf->hob_lbam, io_ports->lbam_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
+                tf_outb(tf->hob_lbah, io_ports->lbah_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
+                tf_outb(tf->feature, io_ports->feature_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
+                tf_outb(tf->nsect, io_ports->nsect_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
+                tf_outb(tf->lbal, io_ports->lbal_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
+                tf_outb(tf->lbam, io_ports->lbam_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
+                tf_outb(tf->lbah, io_ports->lbah_addr);
+        if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
+                tf_outb((tf->device & HIHI) | drive->select,
+                         io_ports->device_addr);
+}
+EXPORT_SYMBOL_GPL(ide_tf_load);
+void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        struct ide_taskfile *tf = &task->tf;
+        void (*tf_outb)(u8 addr, unsigned long port);
+        u8 (*tf_inb)(unsigned long port);
+        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
+        if (mmio) {
+                tf_outb = ide_mm_outb;
+                tf_inb  = ide_mm_inb;
+        } else {
+                tf_outb = ide_outb;
+                tf_inb  = ide_inb;
+        }
+        if (task->tf_flags & IDE_TFLAG_IN_DATA) {
+                u16 data;
+                if (mmio)
+                        data = readw((void __iomem *)io_ports->data_addr);
+                else
+                        data = inw(io_ports->data_addr);
+                tf->data = data & 0xff;
+                tf->hob_data = (data >> 8) & 0xff;
+        }
+        /* be sure we're looking at the low order bits */
+        tf_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
+                tf->feature = tf_inb(io_ports->feature_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_NSECT)
+                tf->nsect  = tf_inb(io_ports->nsect_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_LBAL)
+                tf->lbal   = tf_inb(io_ports->lbal_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_LBAM)
+                tf->lbam   = tf_inb(io_ports->lbam_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_LBAH)
+                tf->lbah   = tf_inb(io_ports->lbah_addr);
+        if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
+                tf->device = tf_inb(io_ports->device_addr);
+        if (task->tf_flags & IDE_TFLAG_LBA48) {
+                tf_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
+                if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
+                        tf->hob_feature = tf_inb(io_ports->feature_addr);
+                if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
+                        tf->hob_nsect   = tf_inb(io_ports->nsect_addr);
+                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
+                        tf->hob_lbal    = tf_inb(io_ports->lbal_addr);
+                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
+                        tf->hob_lbam    = tf_inb(io_ports->lbam_addr);
+                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
+                        tf->hob_lbah    = tf_inb(io_ports->lbah_addr);
+        }
+}
+EXPORT_SYMBOL_GPL(ide_tf_read);
+/*
+ * Some localbus EIDE interfaces require a special access sequence
+ * when using 32-bit I/O instructions to transfer data.  We call this
+ * the "vlb_sync" sequence, which consists of three successive reads
+ * of the sector count register location, with interrupts disabled
+ * to ensure that the reads all happen together.
+ */
+static void ata_vlb_sync(unsigned long port)
+{
+        (void)inb(port);
+        (void)inb(port);
+        (void)inb(port);
+}
+/*
+ * This is used for most PIO data transfers *from* the IDE interface
+ *
+ * These routines will round up any request for an odd number of bytes,
+ * so if an odd len is specified, be sure that there's at least one
+ * extra byte allocated for the buffer.
+ */
+void ide_input_data(ide_drive_t *drive, struct request *rq, void *buf,
+                    unsigned int len)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        unsigned long data_addr = io_ports->data_addr;
+        u8 io_32bit = drive->io_32bit;
+        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
+        len++;
+        if (io_32bit) {
+                unsigned long uninitialized_var(flags);
+                if ((io_32bit & 2) && !mmio) {
+                        local_irq_save(flags);
+                        ata_vlb_sync(io_ports->nsect_addr);
+                }
+                if (mmio)
+                        __ide_mm_insl((void __iomem *)data_addr, buf, len / 4);
+                else
+                        insl(data_addr, buf, len / 4);
+                if ((io_32bit & 2) && !mmio)
+                        local_irq_restore(flags);
+                if ((len & 3) >= 2) {
+                        if (mmio)
+                                __ide_mm_insw((void __iomem *)data_addr,
+                                                (u8 *)buf + (len & ~3), 1);
+                        else
+                                insw(data_addr, (u8 *)buf + (len & ~3), 1);
+                }
+        } else {
+                if (mmio)
+                        __ide_mm_insw((void __iomem *)data_addr, buf, len / 2);
+                else
+                        insw(data_addr, buf, len / 2);
+        }
+}
+EXPORT_SYMBOL_GPL(ide_input_data);
+/*
+ * This is used for most PIO data transfers *to* the IDE interface
+ */
+void ide_output_data(ide_drive_t *drive, struct request *rq, void *buf,
+                     unsigned int len)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        unsigned long data_addr = io_ports->data_addr;
+        u8 io_32bit = drive->io_32bit;
+        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
+        len++;
+        if (io_32bit) {
+                unsigned long uninitialized_var(flags);
+                if ((io_32bit & 2) && !mmio) {
+                        local_irq_save(flags);
+                        ata_vlb_sync(io_ports->nsect_addr);
+                }
+                if (mmio)
+                        __ide_mm_outsl((void __iomem *)data_addr, buf, len / 4);
+                else
+                        outsl(data_addr, buf, len / 4);
+                if ((io_32bit & 2) && !mmio)
+                        local_irq_restore(flags);
+                if ((len & 3) >= 2) {
+                        if (mmio)
+                                __ide_mm_outsw((void __iomem *)data_addr,
+                                                 (u8 *)buf + (len & ~3), 1);
+                        else
+                                outsw(data_addr, (u8 *)buf + (len & ~3), 1);
+                }
+        } else {
+                if (mmio)
+                        __ide_mm_outsw((void __iomem *)data_addr, buf, len / 2);
+                else
+                        outsw(data_addr, buf, len / 2);
+        }
+}
+EXPORT_SYMBOL_GPL(ide_output_data);
+const struct ide_tp_ops default_tp_ops = {
+        .exec_command           = ide_exec_command,
+        .read_status            = ide_read_status,
+        .read_altstatus         = ide_read_altstatus,
+        .set_irq                = ide_set_irq,
+        .tf_load                = ide_tf_load,
+        .tf_read                = ide_tf_read,
+        .input_data             = ide_input_data,
+        .output_data            = ide_output_data,
+};
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index a9a6c208288a..2e92497b58aa 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -196,7 +196,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
 }
 EXPORT_SYMBOL(ide_end_drive_cmd);
-static void ide_kill_rq(ide_drive_t *drive, struct request *rq)
+void ide_kill_rq(ide_drive_t *drive, struct request *rq)
 {
        if (rq->rq_disk) {
                struct ide_driver *drv;
@@ -207,133 +207,6 @@ static void ide_kill_rq(ide_drive_t *drive, struct request *rq)
                ide_end_request(drive, 0, 0);
 }
-static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        if ((stat & ATA_BUSY) ||
-            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
-                /* other bits are useless when BUSY */
-                rq->errors |= ERROR_RESET;
-        } else if (stat & ATA_ERR) {
-                /* err has different meaning on cdrom and tape */
-                if (err == ATA_ABORTED) {
-                        if ((drive->dev_flags & IDE_DFLAG_LBA) &&
-                            /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */
-                            hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS)
-                                return ide_stopped;
-                } else if ((err & BAD_CRC) == BAD_CRC) {
-                        /* UDMA crc error, just retry the operation */
-                        drive->crc_count++;
-                } else if (err & (ATA_BBK | ATA_UNC)) {
-                        /* retries won't help these */
-                        rq->errors = ERROR_MAX;
-                } else if (err & ATA_TRK0NF) {
-                        /* help it find track zero */
-                        rq->errors |= ERROR_RECAL;
-                }
-        }
-        if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ &&
-            (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) {
-                int nsect = drive->mult_count ? drive->mult_count : 1;
-                ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE);
-        }
-        if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) {
-                ide_kill_rq(drive, rq);
-                return ide_stopped;
-        }
-        if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
-                rq->errors |= ERROR_RESET;
-        if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
-                ++rq->errors;
-                return ide_do_reset(drive);
-        }
-        if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
-                drive->special.b.recalibrate = 1;
-        ++rq->errors;
-        return ide_stopped;
-}
-static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        if ((stat & ATA_BUSY) ||
-            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
-                /* other bits are useless when BUSY */
-                rq->errors |= ERROR_RESET;
-        } else {
-                /* add decoding error stuff */
-        }
-        if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
-                /* force an abort */
-                hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE);
-        if (rq->errors >= ERROR_MAX) {
-                ide_kill_rq(drive, rq);
-        } else {
-                if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
-                        ++rq->errors;
-                        return ide_do_reset(drive);
-                }
-                ++rq->errors;
-        }
-        return ide_stopped;
-}
-static ide_startstop_t
-__ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
-{
-        if (drive->media == ide_disk)
-                return ide_ata_error(drive, rq, stat, err);
-        return ide_atapi_error(drive, rq, stat, err);
-}
-/**
- *      ide_error       -       handle an error on the IDE
- *      @drive: drive the error occurred on
- *      @msg: message to report
- *      @stat: status bits
- *
- *      ide_error() takes action based on the error returned by the drive.
- *      For normal I/O that may well include retries. We deal with
- *      both new-style (taskfile) and old style command handling here.
- *      In the case of taskfile command handling there is work left to
- *      do
- */
- 
-ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
-{
-        struct request *rq;
-        u8 err;
-        err = ide_dump_status(drive, msg, stat);
-        rq = drive->hwif->rq;
-        if (rq == NULL)
-                return ide_stopped;
-        /* retry only "normal" I/O: */
-        if (!blk_fs_request(rq)) {
-                rq->errors = 1;
-                ide_end_drive_cmd(drive, stat, err);
-                return ide_stopped;
-        }
-        return __ide_error(drive, rq, stat, err);
-}
-EXPORT_SYMBOL_GPL(ide_error);
 static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
 {
        tf->nsect   = drive->sect;
@@ -490,71 +363,16 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
        return ide_stopped;
 }
-int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
-                       int arg)
-{
-        struct request_queue *q = drive->queue;
-        struct request *rq;
-        int ret = 0;
-        if (!(setting->flags & DS_SYNC))
-                return setting->set(drive, arg);
-        rq = blk_get_request(q, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->cmd_len = 5;
-        rq->cmd[0] = REQ_DEVSET_EXEC;
-        *(int *)&rq->cmd[1] = arg;
-        rq->special = setting->set;
-        if (blk_execute_rq(q, NULL, rq, 0))
-                ret = rq->errors;
-        blk_put_request(rq);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(ide_devset_execute);
 static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
 {
        u8 cmd = rq->cmd[0];
-        if (cmd == REQ_PARK_HEADS || cmd == REQ_UNPARK_HEADS) {
-                ide_task_t task;
-                struct ide_taskfile *tf = &task.tf;
-                memset(&task, 0, sizeof(task));
-                if (cmd == REQ_PARK_HEADS) {
-                        drive->sleep = *(unsigned long *)rq->special;
-                        drive->dev_flags |= IDE_DFLAG_SLEEPING;
-                        tf->command = ATA_CMD_IDLEIMMEDIATE;
-                        tf->feature = 0x44;
-                        tf->lbal = 0x4c;
-                        tf->lbam = 0x4e;
-                        tf->lbah = 0x55;
-                        task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER;
-                } else          /* cmd == REQ_UNPARK_HEADS */
-                        tf->command = ATA_CMD_CHK_POWER;
-                task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-                task.rq = rq;
-                drive->hwif->data_phase = task.data_phase = TASKFILE_NO_DATA;
-                return do_rw_taskfile(drive, &task);
-        }
        switch (cmd) {
+        case REQ_PARK_HEADS:
+        case REQ_UNPARK_HEADS:
+                return ide_do_park_unpark(drive, rq);
        case REQ_DEVSET_EXEC:
-        {
+                return ide_do_devset(drive, rq);
-                int err, (*setfunc)(ide_drive_t *, int) = rq->special;
-                err = setfunc(drive, *(int *)&rq->cmd[1]);
-                if (err)
-                        rq->errors = err;
-                else
-                        err = 1;
-                ide_end_request(drive, err, 0);
-                return ide_stopped;
-        }
        case REQ_DRIVE_RESET:
                return ide_do_reset(drive);
        default:
@@ -820,63 +638,6 @@ plug_device_2:
                blk_plug_device(q);
 }
-/*
- * un-busy the port etc, and clear any pending DMA status. we want to
- * retry the current request in pio mode instead of risking tossing it
- * all away
- */
-static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct request *rq;
-        ide_startstop_t ret = ide_stopped;
-        /*
-         * end current dma transaction
-         */
-        if (error < 0) {
-                printk(KERN_WARNING "%s: DMA timeout error\n", drive->name);
-                (void)hwif->dma_ops->dma_end(drive);
-                ret = ide_error(drive, "dma timeout error",
-                                hwif->tp_ops->read_status(hwif));
-        } else {
-                printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name);
-                hwif->dma_ops->dma_timeout(drive);
-        }
-        /*
-         * disable dma for now, but remember that we did so because of
-         * a timeout -- we'll reenable after we finish this next request
-         * (or rather the first chunk of it) in pio.
-         */
-        drive->dev_flags |= IDE_DFLAG_DMA_PIO_RETRY;
-        drive->retry_pio++;
-        ide_dma_off_quietly(drive);
-        /*
-         * un-busy drive etc and make sure request is sane
-         */
-        rq = hwif->rq;
-        if (!rq)
-                goto out;
-        hwif->rq = NULL;
-        rq->errors = 0;
-        if (!rq->bio)
-                goto out;
-        rq->sector = rq->bio->bi_sector;
-        rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9;
-        rq->hard_cur_sectors = rq->current_nr_sectors;
-        rq->buffer = bio_data(rq->bio);
-out:
-        return ret;
-}
 static void ide_plug_device(ide_drive_t *drive)
 {
        struct request_queue *q = drive->queue;
@@ -888,6 +649,29 @@ static void ide_plug_device(ide_drive_t *drive)
        spin_unlock_irqrestore(q->queue_lock, flags);
 }
+static int drive_is_ready(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        u8 stat = 0;
+        if (drive->waiting_for_dma)
+                return hwif->dma_ops->dma_test_irq(drive);
+        if (hwif->io_ports.ctl_addr &&
+            (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0)
+                stat = hwif->tp_ops->read_altstatus(hwif);
+        else
+                /* Note: this may clear a pending IRQ!! */
+                stat = hwif->tp_ops->read_status(hwif);
+        if (stat & ATA_BUSY)
+                /* drive busy: definitely not interrupting */
+                return 0;
+        /* drive ready: *might* be interrupting */
+        return 1;
+}
 /**
 *      ide_timer_expiry        -       handle lack of an IDE interrupt
 *      @data: timer callback magic (hwif)
@@ -1164,54 +948,6 @@ out_early:
 }
 EXPORT_SYMBOL_GPL(ide_intr);
-/**
- *      ide_do_drive_cmd        -       issue IDE special command
- *      @drive: device to issue command
- *      @rq: request to issue
- *
- *      This function issues a special IDE device request
- *      onto the request queue.
- *
- *      the rq is queued at the head of the request queue, displacing
- *      the currently-being-processed request and this function
- *      returns immediately without waiting for the new rq to be
- *      completed.  This is VERY DANGEROUS, and is intended for
- *      careful use by the ATAPI tape/cdrom driver code.
- */
-void ide_do_drive_cmd(ide_drive_t *drive, struct request *rq)
-{
-        struct request_queue *q = drive->queue;
-        unsigned long flags;
-        drive->hwif->rq = NULL;
-        spin_lock_irqsave(q->queue_lock, flags);
-        __elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 0);
-        spin_unlock_irqrestore(q->queue_lock, flags);
-}
-EXPORT_SYMBOL(ide_do_drive_cmd);
-void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount, u8 dma)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        ide_task_t task;
-        memset(&task, 0, sizeof(task));
-        task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
-                        IDE_TFLAG_OUT_FEATURE | tf_flags;
-        task.tf.feature = dma;          /* Use PIO/DMA */
-        task.tf.lbam    = bcount & 0xff;
-        task.tf.lbah    = (bcount >> 8) & 0xff;
-        ide_tf_dump(drive->name, &task.tf);
-        hwif->tp_ops->set_irq(hwif, 1);
-        SELECT_MASK(drive, 0);
-        hwif->tp_ops->tf_load(drive, &task);
-}
-EXPORT_SYMBOL_GPL(ide_pktcmd_tf_load);
 void ide_pad_transfer(ide_drive_t *drive, int write, int len)
 {
        ide_hwif_t *hwif = drive->hwif;
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index b1892bd95c6f..317c5dadd7c0 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -27,35 +27,7 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
-/*
+void SELECT_DRIVE(ide_drive_t *drive)
- *      Conventional PIO operations for ATA devices
- */
-static u8 ide_inb (unsigned long port)
-{
-        return (u8) inb(port);
-}
-static void ide_outb (u8 val, unsigned long port)
-{
-        outb(val, port);
-}
-/*
- *      MMIO operations, typically used for SATA controllers
- */
-static u8 ide_mm_inb (unsigned long port)
-{
-        return (u8) readb((void __iomem *) port);
-}
-static void ide_mm_outb (u8 value, unsigned long port)
-{
-        writeb(value, (void __iomem *) port);
-}
-void SELECT_DRIVE (ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
        const struct ide_port_ops *port_ops = hwif->port_ops;
@@ -78,277 +50,6 @@ void SELECT_MASK(ide_drive_t *drive, int mask)
                port_ops->maskproc(drive, mask);
 }
-void ide_exec_command(ide_hwif_t *hwif, u8 cmd)
-{
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
-        else
-                outb(cmd, hwif->io_ports.command_addr);
-}
-EXPORT_SYMBOL_GPL(ide_exec_command);
-u8 ide_read_status(ide_hwif_t *hwif)
-{
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                return readb((void __iomem *)hwif->io_ports.status_addr);
-        else
-                return inb(hwif->io_ports.status_addr);
-}
-EXPORT_SYMBOL_GPL(ide_read_status);
-u8 ide_read_altstatus(ide_hwif_t *hwif)
-{
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                return readb((void __iomem *)hwif->io_ports.ctl_addr);
-        else
-                return inb(hwif->io_ports.ctl_addr);
-}
-EXPORT_SYMBOL_GPL(ide_read_altstatus);
-void ide_set_irq(ide_hwif_t *hwif, int on)
-{
-        u8 ctl = ATA_DEVCTL_OBS;
-        if (on == 4) { /* hack for SRST */
-                ctl |= 4;
-                on &= ~4;
-        }
-        ctl |= on ? 0 : 2;
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                writeb(ctl, (void __iomem *)hwif->io_ports.ctl_addr);
-        else
-                outb(ctl, hwif->io_ports.ctl_addr);
-}
-EXPORT_SYMBOL_GPL(ide_set_irq);
-void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &task->tf;
-        void (*tf_outb)(u8 addr, unsigned long port);
-        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
-        if (mmio)
-                tf_outb = ide_mm_outb;
-        else
-                tf_outb = ide_outb;
-        if (task->tf_flags & IDE_TFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (task->tf_flags & IDE_TFLAG_OUT_DATA) {
-                u16 data = (tf->hob_data << 8) | tf->data;
-                if (mmio)
-                        writew(data, (void __iomem *)io_ports->data_addr);
-                else
-                        outw(data, io_ports->data_addr);
-        }
-        if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                tf_outb(tf->hob_feature, io_ports->feature_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                tf_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                tf_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                tf_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                tf_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                tf_outb(tf->feature, io_ports->feature_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
-                tf_outb(tf->nsect, io_ports->nsect_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
-                tf_outb(tf->lbal, io_ports->lbal_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
-                tf_outb(tf->lbam, io_ports->lbam_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
-                tf_outb(tf->lbah, io_ports->lbah_addr);
-        if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                tf_outb((tf->device & HIHI) | drive->select,
-                         io_ports->device_addr);
-}
-EXPORT_SYMBOL_GPL(ide_tf_load);
-void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &task->tf;
-        void (*tf_outb)(u8 addr, unsigned long port);
-        u8 (*tf_inb)(unsigned long port);
-        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        if (mmio) {
-                tf_outb = ide_mm_outb;
-                tf_inb  = ide_mm_inb;
-        } else {
-                tf_outb = ide_outb;
-                tf_inb  = ide_inb;
-        }
-        if (task->tf_flags & IDE_TFLAG_IN_DATA) {
-                u16 data;
-                if (mmio)
-                        data = readw((void __iomem *)io_ports->data_addr);
-                else
-                        data = inw(io_ports->data_addr);
-                tf->data = data & 0xff;
-                tf->hob_data = (data >> 8) & 0xff;
-        }
-        /* be sure we're looking at the low order bits */
-        tf_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_FEATURE)
-                tf->feature = tf_inb(io_ports->feature_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = tf_inb(io_ports->nsect_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = tf_inb(io_ports->lbal_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = tf_inb(io_ports->lbam_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = tf_inb(io_ports->lbah_addr);
-        if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = tf_inb(io_ports->device_addr);
-        if (task->tf_flags & IDE_TFLAG_LBA48) {
-                tf_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);
-                if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
-                        tf->hob_feature = tf_inb(io_ports->feature_addr);
-                if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect   = tf_inb(io_ports->nsect_addr);
-                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal    = tf_inb(io_ports->lbal_addr);
-                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam    = tf_inb(io_ports->lbam_addr);
-                if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah    = tf_inb(io_ports->lbah_addr);
-        }
-}
-EXPORT_SYMBOL_GPL(ide_tf_read);
-/*
- * Some localbus EIDE interfaces require a special access sequence
- * when using 32-bit I/O instructions to transfer data.  We call this
- * the "vlb_sync" sequence, which consists of three successive reads
- * of the sector count register location, with interrupts disabled
- * to ensure that the reads all happen together.
- */
-static void ata_vlb_sync(unsigned long port)
-{
-        (void)inb(port);
-        (void)inb(port);
-        (void)inb(port);
-}
-/*
- * This is used for most PIO data transfers *from* the IDE interface
- *
- * These routines will round up any request for an odd number of bytes,
- * so if an odd len is specified, be sure that there's at least one
- * extra byte allocated for the buffer.
- */
-void ide_input_data(ide_drive_t *drive, struct request *rq, void *buf,
-                    unsigned int len)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        unsigned long data_addr = io_ports->data_addr;
-        u8 io_32bit = drive->io_32bit;
-        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        len++;
-        if (io_32bit) {
-                unsigned long uninitialized_var(flags);
-                if ((io_32bit & 2) && !mmio) {
-                        local_irq_save(flags);
-                        ata_vlb_sync(io_ports->nsect_addr);
-                }
-                if (mmio)
-                        __ide_mm_insl((void __iomem *)data_addr, buf, len / 4);
-                else
-                        insl(data_addr, buf, len / 4);
-                if ((io_32bit & 2) && !mmio)
-                        local_irq_restore(flags);
-                if ((len & 3) >= 2) {
-                        if (mmio)
-                                __ide_mm_insw((void __iomem *)data_addr,
-                                                (u8 *)buf + (len & ~3), 1);
-                        else
-                                insw(data_addr, (u8 *)buf + (len & ~3), 1);
-                }
-        } else {
-                if (mmio)
-                        __ide_mm_insw((void __iomem *)data_addr, buf, len / 2);
-                else
-                        insw(data_addr, buf, len / 2);
-        }
-}
-EXPORT_SYMBOL_GPL(ide_input_data);
-/*
- * This is used for most PIO data transfers *to* the IDE interface
- */
-void ide_output_data(ide_drive_t *drive, struct request *rq, void *buf,
-                     unsigned int len)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        unsigned long data_addr = io_ports->data_addr;
-        u8 io_32bit = drive->io_32bit;
-        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        len++;
-        if (io_32bit) {
-                unsigned long uninitialized_var(flags);
-                if ((io_32bit & 2) && !mmio) {
-                        local_irq_save(flags);
-                        ata_vlb_sync(io_ports->nsect_addr);
-                }
-                if (mmio)
-                        __ide_mm_outsl((void __iomem *)data_addr, buf, len / 4);
-                else
-                        outsl(data_addr, buf, len / 4);
-                if ((io_32bit & 2) && !mmio)
-                        local_irq_restore(flags);
-                if ((len & 3) >= 2) {
-                        if (mmio)
-                                __ide_mm_outsw((void __iomem *)data_addr,
-                                                 (u8 *)buf + (len & ~3), 1);
-                        else
-                                outsw(data_addr, (u8 *)buf + (len & ~3), 1);
-                }
-        } else {
-                if (mmio)
-                        __ide_mm_outsw((void __iomem *)data_addr, buf, len / 2);
-                else
-                        outsw(data_addr, buf, len / 2);
-        }
-}
-EXPORT_SYMBOL_GPL(ide_output_data);
 u8 ide_read_error(ide_drive_t *drive)
 {
        ide_task_t task;
@@ -362,35 +63,6 @@ u8 ide_read_error(ide_drive_t *drive)
 }
 EXPORT_SYMBOL_GPL(ide_read_error);
-void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
-{
-        ide_task_t task;
-        memset(&task, 0, sizeof(task));
-        task.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
-                        IDE_TFLAG_IN_NSECT;
-        drive->hwif->tp_ops->tf_read(drive, &task);
-        *bcount = (task.tf.lbah << 8) | task.tf.lbam;
-        *ireason = task.tf.nsect & 3;
-}
-EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
-const struct ide_tp_ops default_tp_ops = {
-        .exec_command           = ide_exec_command,
-        .read_status            = ide_read_status,
-        .read_altstatus         = ide_read_altstatus,
-        .set_irq                = ide_set_irq,
-        .tf_load                = ide_tf_load,
-        .tf_read                = ide_tf_read,
-        .input_data             = ide_input_data,
-        .output_data            = ide_output_data,
-};
 void ide_fix_driveid(u16 *id)
 {
 #ifndef __LITTLE_ENDIAN
@@ -412,7 +84,7 @@ void ide_fix_driveid(u16 *id)
 * returned by the ATA_CMD_ID_ATA[PI] commands.
 */
-void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
+void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
 {
        u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
@@ -435,44 +107,9 @@ void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
        while (p != end)
                *p++ = '\0';
 }
 EXPORT_SYMBOL(ide_fixstring);
 /*
- * Needed for PCI irq sharing
- */
-int drive_is_ready (ide_drive_t *drive)
-{
-        ide_hwif_t *hwif        = drive->hwif;
-        u8 stat                 = 0;
-        if (drive->waiting_for_dma)
-                return hwif->dma_ops->dma_test_irq(drive);
-        /*
-         * We do a passive status test under shared PCI interrupts on
-         * cards that truly share the ATA side interrupt, but may also share
-         * an interrupt with another pci card/device.  We make no assumptions
-         * about possible isa-pnp and pci-pnp issues yet.
-         */
-        if (hwif->io_ports.ctl_addr &&
-            (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0)
-                stat = hwif->tp_ops->read_altstatus(hwif);
-        else
-                /* Note: this may clear a pending IRQ!! */
-                stat = hwif->tp_ops->read_status(hwif);
-        if (stat & ATA_BUSY)
-                /* drive busy:  definitely not interrupting */
-                return 0;
-        /* drive ready: *might* be interrupting */
-        return 1;
-}
-EXPORT_SYMBOL(drive_is_ready);
-/*
 * This routine busy-waits for the drive status to be not "busy".
 * It then checks the status for all of the "good" bits and none
 * of the "bad" bits, and if all is okay it returns 0.  All other
@@ -483,7 +120,8 @@ EXPORT_SYMBOL(drive_is_ready);
 * setting a timer to wake up at half second intervals thereafter,
 * until timeout is achieved, before timing out.
 */
-static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout, u8 *rstat)
+static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
+                           unsigned long timeout, u8 *rstat)
 {
        ide_hwif_t *hwif = drive->hwif;
        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
@@ -541,7 +179,8 @@ static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long ti
 * The caller should return the updated value of "startstop" in this case,
 * "startstop" is unchanged when the function returns 0.
 */
-int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout)
+int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
+                  u8 bad, unsigned long timeout)
 {
        int err;
        u8 stat;
@@ -561,7 +200,6 @@ int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 ba
        return err;
 }
 EXPORT_SYMBOL(ide_wait_stat);
 /**
@@ -582,7 +220,6 @@ int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
                        return 1;
        return 0;
 }
 EXPORT_SYMBOL_GPL(ide_in_drive_list);
 /*
@@ -607,7 +244,7 @@ static const struct drive_list_entry ivb_list[] = {
 *  All hosts that use the 80c ribbon must use!
 *  The name is derived from upper byte of word 93 and the 80c ribbon.
 */
-u8 eighty_ninty_three (ide_drive_t *drive)
+u8 eighty_ninty_three(ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
        u16 *id = drive->id;
@@ -652,47 +289,19 @@ no_80w:
 int ide_driveid_update(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
        u16 *id;
-        unsigned long flags;
+        int rc;
-        u8 stat;
-        /*
-         * Re-read drive->id for possible DMA mode
-         * change (copied from ide-probe.c)
-         */
-        SELECT_MASK(drive, 1);
-        tp_ops->set_irq(hwif, 0);
-        msleep(50);
-        tp_ops->exec_command(hwif, ATA_CMD_ID_ATA);
-        if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 1)) {
+        id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
-                SELECT_MASK(drive, 0);
+        if (id == NULL)
                return 0;
-        }
-        msleep(50);     /* wait for IRQ and ATA_DRQ */
-        stat = tp_ops->read_status(hwif);
-        if (!OK_STAT(stat, ATA_DRQ, BAD_R_STAT)) {
+        SELECT_MASK(drive, 1);
-                SELECT_MASK(drive, 0);
+        rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id);
-                printk("%s: CHECK for good STATUS\n", drive->name);
-                return 0;
-        }
-        local_irq_save(flags);
        SELECT_MASK(drive, 0);
-        id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
-        if (!id) {
+        if (rc)
-                local_irq_restore(flags);
+                goto out_err;
-                return 0;
-        }
-        tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
-        (void)tp_ops->read_status(hwif);        /* clear drive IRQ */
-        local_irq_enable();
-        local_irq_restore(flags);
-        ide_fix_driveid(id);
        drive->id[ATA_ID_UDMA_MODES]  = id[ATA_ID_UDMA_MODES];
        drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
@@ -705,6 +314,12 @@ int ide_driveid_update(ide_drive_t *drive)
                ide_dma_off(drive);
        return 1;
+out_err:
+        SELECT_MASK(drive, 0);
+        if (rc == 2)
+                printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
+        kfree(id);
+        return 0;
 }
 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
@@ -731,18 +346,15 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
         * but for some reason these don't work at
         * this point (lost interrupt).
         */
-        /*
-         * Select the drive, and issue the SETFEATURES command
-         */
-        disable_irq_nosync(hwif->irq);
-        
        /*
         *      FIXME: we race against the running IRQ here if
         *      this is called from non IRQ context. If we use
         *      disable_irq() we hang on the error path. Work
         *      is needed.
         */
-         
+        disable_irq_nosync(hwif->irq);
        udelay(1);
        SELECT_DRIVE(drive);
        SELECT_MASK(drive, 1);
@@ -812,8 +424,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 *
 * See also ide_execute_command
 */
-static void __ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
+void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
-                      unsigned int timeout, ide_expiry_t *expiry)
+                       unsigned int timeout, ide_expiry_t *expiry)
 {
        ide_hwif_t *hwif = drive->hwif;
@@ -835,9 +447,8 @@ void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
        __ide_set_handler(drive, handler, timeout, expiry);
        spin_unlock_irqrestore(&hwif->lock, flags);
 }
 EXPORT_SYMBOL(ide_set_handler);
- 
 /**
 *      ide_execute_command     -       execute an IDE command
 *      @drive: IDE drive to issue the command against
@@ -847,7 +458,7 @@ EXPORT_SYMBOL(ide_set_handler);
 *      @expiry:  handler to run on timeout
 *
 *      Helper function to issue an IDE command. This handles the
- *      atomicity requirements, command timing and ensures that the 
+ *      atomicity requirements, command timing and ensures that the
 *      handler and IRQ setup do not race. All IDE command kick off
 *      should go via this function or do equivalent locking.
 */
@@ -884,301 +495,6 @@ void ide_execute_pkt_cmd(ide_drive_t *drive)
 }
 EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd);
-static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
-{
-        struct request *rq = drive->hwif->rq;
-        if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET)
-                ide_end_request(drive, err ? err : 1, 0);
-}
-/* needed below */
-static ide_startstop_t do_reset1 (ide_drive_t *, int);
-/*
- * atapi_reset_pollfunc() gets invoked to poll the interface for completion every 50ms
- * during an atapi drive reset operation. If the drive has not yet responded,
- * and we have not yet hit our maximum waiting time, then the timer is restarted
- * for another 50ms.
- */
-static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        u8 stat;
-        SELECT_DRIVE(drive);
-        udelay (10);
-        stat = hwif->tp_ops->read_status(hwif);
-        if (OK_STAT(stat, 0, ATA_BUSY))
-                printk("%s: ATAPI reset complete\n", drive->name);
-        else {
-                if (time_before(jiffies, hwif->poll_timeout)) {
-                        ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
-                        /* continue polling */
-                        return ide_started;
-                }
-                /* end of polling */
-                hwif->polling = 0;
-                printk("%s: ATAPI reset timed-out, status=0x%02x\n",
-                                drive->name, stat);
-                /* do it the old fashioned way */
-                return do_reset1(drive, 1);
-        }
-        /* done polling */
-        hwif->polling = 0;
-        ide_complete_drive_reset(drive, 0);
-        return ide_stopped;
-}
-static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
-{
-        static const char *err_master_vals[] =
-                { NULL, "passed", "formatter device error",
-                  "sector buffer error", "ECC circuitry error",
-                  "controlling MPU error" };
-        u8 err_master = err & 0x7f;
-        printk(KERN_ERR "%s: reset: master: ", hwif->name);
-        if (err_master && err_master < 6)
-                printk(KERN_CONT "%s", err_master_vals[err_master]);
-        else
-                printk(KERN_CONT "error (0x%02x?)", err);
-        if (err & 0x80)
-                printk(KERN_CONT "; slave: failed");
-        printk(KERN_CONT "\n");
-}
-/*
- * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
- * during an ide reset operation. If the drives have not yet responded,
- * and we have not yet hit our maximum waiting time, then the timer is restarted
- * for another 50ms.
- */
-static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        u8 tmp;
-        int err = 0;
-        if (port_ops && port_ops->reset_poll) {
-                err = port_ops->reset_poll(drive);
-                if (err) {
-                        printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
-                                hwif->name, drive->name);
-                        goto out;
-                }
-        }
-        tmp = hwif->tp_ops->read_status(hwif);
-        if (!OK_STAT(tmp, 0, ATA_BUSY)) {
-                if (time_before(jiffies, hwif->poll_timeout)) {
-                        ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
-                        /* continue polling */
-                        return ide_started;
-                }
-                printk("%s: reset timed-out, status=0x%02x\n", hwif->name, tmp);
-                drive->failures++;
-                err = -EIO;
-        } else  {
-                tmp = ide_read_error(drive);
-                if (tmp == 1) {
-                        printk(KERN_INFO "%s: reset: success\n", hwif->name);
-                        drive->failures = 0;
-                } else {
-                        ide_reset_report_error(hwif, tmp);
-                        drive->failures++;
-                        err = -EIO;
-                }
-        }
-out:
-        hwif->polling = 0;      /* done polling */
-        ide_complete_drive_reset(drive, err);
-        return ide_stopped;
-}
-static void ide_disk_pre_reset(ide_drive_t *drive)
-{
-        int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1;
-        drive->special.all = 0;
-        drive->special.b.set_geometry = legacy;
-        drive->special.b.recalibrate  = legacy;
-        drive->mult_count = 0;
-        drive->dev_flags &= ~IDE_DFLAG_PARKED;
-        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 &&
-            (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0)
-                drive->mult_req = 0;
-        if (drive->mult_req != drive->mult_count)
-                drive->special.b.set_multmode = 1;
-}
-static void pre_reset(ide_drive_t *drive)
-{
-        const struct ide_port_ops *port_ops = drive->hwif->port_ops;
-        if (drive->media == ide_disk)
-                ide_disk_pre_reset(drive);
-        else
-                drive->dev_flags |= IDE_DFLAG_POST_RESET;
-        if (drive->dev_flags & IDE_DFLAG_USING_DMA) {
-                if (drive->crc_count)
-                        ide_check_dma_crc(drive);
-                else
-                        ide_dma_off(drive);
-        }
-        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) {
-                if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) {
-                        drive->dev_flags &= ~IDE_DFLAG_UNMASK;
-                        drive->io_32bit = 0;
-                }
-                return;
-        }
-        if (port_ops && port_ops->pre_reset)
-                port_ops->pre_reset(drive);
-        if (drive->current_speed != 0xff)
-                drive->desired_speed = drive->current_speed;
-        drive->current_speed = 0xff;
-}
-/*
- * do_reset1() attempts to recover a confused drive by resetting it.
- * Unfortunately, resetting a disk drive actually resets all devices on
- * the same interface, so it can really be thought of as resetting the
- * interface rather than resetting the drive.
- *
- * ATAPI devices have their own reset mechanism which allows them to be
- * individually reset without clobbering other devices on the same interface.
- *
- * Unfortunately, the IDE interface does not generate an interrupt to let
- * us know when the reset operation has finished, so we must poll for this.
- * Equally poor, though, is the fact that this may a very long time to complete,
- * (up to 30 seconds worstcase).  So, instead of busy-waiting here for it,
- * we set a timer to poll at 50ms intervals.
- */
-static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        const struct ide_port_ops *port_ops;
-        ide_drive_t *tdrive;
-        unsigned long flags, timeout;
-        int i;
-        DEFINE_WAIT(wait);
-        spin_lock_irqsave(&hwif->lock, flags);
-        /* We must not reset with running handlers */
-        BUG_ON(hwif->handler != NULL);
-        /* For an ATAPI device, first try an ATAPI SRST. */
-        if (drive->media != ide_disk && !do_not_try_atapi) {
-                pre_reset(drive);
-                SELECT_DRIVE(drive);
-                udelay (20);
-                tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
-                ndelay(400);
-                hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
-                hwif->polling = 1;
-                __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
-                spin_unlock_irqrestore(&hwif->lock, flags);
-                return ide_started;
-        }
-        /* We must not disturb devices in the IDE_DFLAG_PARKED state. */
-        do {
-                unsigned long now;
-                prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
-                timeout = jiffies;
-                ide_port_for_each_dev(i, tdrive, hwif) {
-                        if (tdrive->dev_flags & IDE_DFLAG_PRESENT &&
-                            tdrive->dev_flags & IDE_DFLAG_PARKED &&
-                            time_after(tdrive->sleep, timeout))
-                                timeout = tdrive->sleep;
-                }
-                now = jiffies;
-                if (time_before_eq(timeout, now))
-                        break;
-                spin_unlock_irqrestore(&hwif->lock, flags);
-                timeout = schedule_timeout_uninterruptible(timeout - now);
-                spin_lock_irqsave(&hwif->lock, flags);
-        } while (timeout);
-        finish_wait(&ide_park_wq, &wait);
-        /*
-         * First, reset any device state data we were maintaining
-         * for any of the drives on this interface.
-         */
-        ide_port_for_each_dev(i, tdrive, hwif)
-                pre_reset(tdrive);
-        if (io_ports->ctl_addr == 0) {
-                spin_unlock_irqrestore(&hwif->lock, flags);
-                ide_complete_drive_reset(drive, -ENXIO);
-                return ide_stopped;
-        }
-        /*
-         * Note that we also set nIEN while resetting the device,
-         * to mask unwanted interrupts from the interface during the reset.
-         * However, due to the design of PC hardware, this will cause an
-         * immediate interrupt due to the edge transition it produces.
-         * This single interrupt gives us a "fast poll" for drives that
-         * recover from reset very quickly, saving us the first 50ms wait time.
-         *
-         * TODO: add ->softreset method and stop abusing ->set_irq
-         */
-        /* set SRST and nIEN */
-        tp_ops->set_irq(hwif, 4);
-        /* more than enough time */
-        udelay(10);
-        /* clear SRST, leave nIEN (unless device is on the quirk list) */
-        tp_ops->set_irq(hwif, drive->quirk_list == 2);
-        /* more than enough time */
-        udelay(10);
-        hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
-        hwif->polling = 1;
-        __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
-        /*
-         * Some weird controller like resetting themselves to a strange
-         * state when the disks are reset this way. At least, the Winbond
-         * 553 documentation says that
-         */
-        port_ops = hwif->port_ops;
-        if (port_ops && port_ops->resetproc)
-                port_ops->resetproc(drive);
-        spin_unlock_irqrestore(&hwif->lock, flags);
-        return ide_started;
-}
-/*
- * ide_do_reset() is the entry point to the drive/interface reset code.
- */
-ide_startstop_t ide_do_reset (ide_drive_t *drive)
-{
-        return do_reset1(drive, 0);
-}
-EXPORT_SYMBOL(ide_do_reset);
 /*
 * ide_wait_not_busy() waits for the currently selected device on the hwif
 * to report a non-busy status, see comments in ide_probe_port().
@@ -1187,7 +503,7 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
 {
        u8 stat = 0;
-        while(timeout--) {
+        while (timeout--) {
                /*
                 * Turn this into a schedule() sleep once I'm sure
                 * about locking issues (2.5 work ?).
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 09526a0de734..f6c683dd2987 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -5,163 +5,6 @@
 #include <linux/ide.h>
 #include <linux/bitops.h>
-static const char *udma_str[] =
-         { "UDMA/16", "UDMA/25",  "UDMA/33",  "UDMA/44",
-           "UDMA/66", "UDMA/100", "UDMA/133", "UDMA7" };
-static const char *mwdma_str[] =
-        { "MWDMA0", "MWDMA1", "MWDMA2" };
-static const char *swdma_str[] =
-        { "SWDMA0", "SWDMA1", "SWDMA2" };
-static const char *pio_str[] =
-        { "PIO0", "PIO1", "PIO2", "PIO3", "PIO4", "PIO5" };
-/**
- *      ide_xfer_verbose        -       return IDE mode names
- *      @mode: transfer mode
- *
- *      Returns a constant string giving the name of the mode
- *      requested.
- */
-const char *ide_xfer_verbose(u8 mode)
-{
-        const char *s;
-        u8 i = mode & 0xf;
-        if (mode >= XFER_UDMA_0 && mode <= XFER_UDMA_7)
-                s = udma_str[i];
-        else if (mode >= XFER_MW_DMA_0 && mode <= XFER_MW_DMA_2)
-                s = mwdma_str[i];
-        else if (mode >= XFER_SW_DMA_0 && mode <= XFER_SW_DMA_2)
-                s = swdma_str[i];
-        else if (mode >= XFER_PIO_0 && mode <= XFER_PIO_5)
-                s = pio_str[i & 0x7];
-        else if (mode == XFER_PIO_SLOW)
-                s = "PIO SLOW";
-        else
-                s = "XFER ERROR";
-        return s;
-}
-EXPORT_SYMBOL(ide_xfer_verbose);
-/**
- *      ide_rate_filter         -       filter transfer mode
- *      @drive: IDE device
- *      @speed: desired speed
- *
- *      Given the available transfer modes this function returns
- *      the best available speed at or below the speed requested.
- *
- *      TODO: check device PIO capabilities
- */
-static u8 ide_rate_filter(ide_drive_t *drive, u8 speed)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        u8 mode = ide_find_dma_mode(drive, speed);
-        if (mode == 0) {
-                if (hwif->pio_mask)
-                        mode = fls(hwif->pio_mask) - 1 + XFER_PIO_0;
-                else
-                        mode = XFER_PIO_4;
-        }
-/*      printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */
-        return min(speed, mode);
-}
-/**
- *      ide_get_best_pio_mode   -       get PIO mode from drive
- *      @drive: drive to consider
- *      @mode_wanted: preferred mode
- *      @max_mode: highest allowed mode
- *
- *      This routine returns the recommended PIO settings for a given drive,
- *      based on the drive->id information and the ide_pio_blacklist[].
- *
- *      Drive PIO mode is auto-selected if 255 is passed as mode_wanted.
- *      This is used by most chipset support modules when "auto-tuning".
- */
-u8 ide_get_best_pio_mode(ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
-{
-        u16 *id = drive->id;
-        int pio_mode = -1, overridden = 0;
-        if (mode_wanted != 255)
-                return min_t(u8, mode_wanted, max_mode);
-        if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_BLACKLIST) == 0)
-                pio_mode = ide_scan_pio_blacklist((char *)&id[ATA_ID_PROD]);
-        if (pio_mode != -1) {
-                printk(KERN_INFO "%s: is on PIO blacklist\n", drive->name);
-        } else {
-                pio_mode = id[ATA_ID_OLD_PIO_MODES] >> 8;
-                if (pio_mode > 2) {     /* 2 is maximum allowed tPIO value */
-                        pio_mode = 2;
-                        overridden = 1;
-                }
-                if (id[ATA_ID_FIELD_VALID] & 2) {             /* ATA2? */
-                        if (ata_id_has_iordy(id)) {
-                                if (id[ATA_ID_PIO_MODES] & 7) {
-                                        overridden = 0;
-                                        if (id[ATA_ID_PIO_MODES] & 4)
-                                                pio_mode = 5;
-                                        else if (id[ATA_ID_PIO_MODES] & 2)
-                                                pio_mode = 4;
-                                        else
-                                                pio_mode = 3;
-                                }
-                        }
-                }
-                if (overridden)
-                        printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n",
-                                         drive->name);
-        }
-        if (pio_mode > max_mode)
-                pio_mode = max_mode;
-        return pio_mode;
-}
-EXPORT_SYMBOL_GPL(ide_get_best_pio_mode);
-/* req_pio == "255" for auto-tune */
-void ide_set_pio(ide_drive_t *drive, u8 req_pio)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        u8 host_pio, pio;
-        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
-            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
-                return;
-        BUG_ON(hwif->pio_mask == 0x00);
-        host_pio = fls(hwif->pio_mask) - 1;
-        pio = ide_get_best_pio_mode(drive, req_pio, host_pio);
-        /*
-         * TODO:
-         * - report device max PIO mode
-         * - check req_pio != 255 against device max PIO mode
-         */
-        printk(KERN_DEBUG "%s: host max PIO%d wanted PIO%d%s selected PIO%d\n",
-                          drive->name, host_pio, req_pio,
-                          req_pio == 255 ? "(auto-tune)" : "", pio);
-        (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio);
-}
-EXPORT_SYMBOL_GPL(ide_set_pio);
 /**
 *      ide_toggle_bounce       -       handle bounce buffering
 *      @drive: drive to update
@@ -188,89 +31,6 @@ void ide_toggle_bounce(ide_drive_t *drive, int on)
                blk_queue_bounce_limit(drive->queue, addr);
 }
-int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
-                return 0;
-        if (port_ops == NULL || port_ops->set_pio_mode == NULL)
-                return -1;
-        /*
-         * TODO: temporary hack for some legacy host drivers that didn't
-         * set transfer mode on the device in ->set_pio_mode method...
-         */
-        if (port_ops->set_dma_mode == NULL) {
-                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
-                return 0;
-        }
-        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
-                if (ide_config_drive_speed(drive, mode))
-                        return -1;
-                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
-                return 0;
-        } else {
-                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
-                return ide_config_drive_speed(drive, mode);
-        }
-}
-int ide_set_dma_mode(ide_drive_t *drive, const u8 mode)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
-                return 0;
-        if (port_ops == NULL || port_ops->set_dma_mode == NULL)
-                return -1;
-        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
-                if (ide_config_drive_speed(drive, mode))
-                        return -1;
-                port_ops->set_dma_mode(drive, mode);
-                return 0;
-        } else {
-                port_ops->set_dma_mode(drive, mode);
-                return ide_config_drive_speed(drive, mode);
-        }
-}
-EXPORT_SYMBOL_GPL(ide_set_dma_mode);
-/**
- *      ide_set_xfer_rate       -       set transfer rate
- *      @drive: drive to set
- *      @rate: speed to attempt to set
- *
- *      General helper for setting the speed of an IDE device. This
- *      function knows about user enforced limits from the configuration
- *      which ->set_pio_mode/->set_dma_mode does not.
- */
-int ide_set_xfer_rate(ide_drive_t *drive, u8 rate)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        if (port_ops == NULL || port_ops->set_dma_mode == NULL ||
-            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
-                return -1;
-        rate = ide_rate_filter(drive, rate);
-        BUG_ON(rate < XFER_PIO_0);
-        if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5)
-                return ide_set_pio_mode(drive, rate);
-        return ide_set_dma_mode(drive, rate);
-}
 static void ide_dump_opcode(ide_drive_t *drive)
 {
        struct request *rq = drive->hwif->rq;
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index c875a957596c..f30e52152fcb 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -1,5 +1,6 @@
 #include <linux/kernel.h>
 #include <linux/ide.h>
+#include <linux/hdreg.h>
 #include <linux/jiffies.h>
 #include <linux/blkdev.h>
@@ -60,6 +61,30 @@ out:
        return;
 }
+ide_startstop_t ide_do_park_unpark(ide_drive_t *drive, struct request *rq)
+{
+        ide_task_t task;
+        struct ide_taskfile *tf = &task.tf;
+        memset(&task, 0, sizeof(task));
+        if (rq->cmd[0] == REQ_PARK_HEADS) {
+                drive->sleep = *(unsigned long *)rq->special;
+                drive->dev_flags |= IDE_DFLAG_SLEEPING;
+                tf->command = ATA_CMD_IDLEIMMEDIATE;
+                tf->feature = 0x44;
+                tf->lbal = 0x4c;
+                tf->lbam = 0x4e;
+                tf->lbah = 0x55;
+                task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER;
+        } else          /* cmd == REQ_UNPARK_HEADS */
+                tf->command = ATA_CMD_CHK_POWER;
+        task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        task.rq = rq;
+        drive->hwif->data_phase = task.data_phase = TASKFILE_NO_DATA;
+        return do_rw_taskfile(drive, &task);
+}
 ssize_t ide_park_show(struct device *dev, struct device_attribute *attr,
                      char *buf)
 {
diff --git a/drivers/ide/ide-pci-generic.c b/drivers/ide/ide-pci-generic.c
index bddae2b329a0..61111fd27130 100644
--- a/drivers/ide/ide-pci-generic.c
+++ b/drivers/ide/ide-pci-generic.c
@@ -33,8 +33,6 @@ static int ide_generic_all;		/* Set to claim all devices */
 module_param_named(all_generic_ide, ide_generic_all, bool, 0444);
 MODULE_PARM_DESC(all_generic_ide, "IDE generic will claim all unknown PCI IDE storage controllers.");
-#define IDE_HFLAGS_UMC (IDE_HFLAG_NO_DMA | IDE_HFLAG_FORCE_LEGACY_IRQS)
 #define DECLARE_GENERIC_PCI_DEV(extra_flags) \
        { \
                .name           = DRV_NAME, \
@@ -61,7 +59,7 @@ static const struct ide_port_info generic_chipsets[] __devinitdata = {
        /*  2: SAMURAI / HT6565 / HINT_IDE */
        DECLARE_GENERIC_PCI_DEV(0),
        /*  3: UM8673F / UM8886A / UM8886BF */
-        DECLARE_GENERIC_PCI_DEV(IDE_HFLAGS_UMC),
+        DECLARE_GENERIC_PCI_DEV(IDE_HFLAG_NO_DMA),
        /*  4: VIA_IDE / OPTI621V / Piccolo010{2,3,5} */
        DECLARE_GENERIC_PCI_DEV(IDE_HFLAG_NO_AUTODMA),
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index ee8e3e7cad51..974067043fba 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -181,16 +181,16 @@ static void ide_classify_atapi_dev(ide_drive_t *drive)
 *      do_identify     -       identify a drive
 *      @drive: drive to identify 
 *      @cmd: command used
+ *      @id: buffer for IDENTIFY data
 *
 *      Called when we have issued a drive identify command to
 *      read and parse the results. This function is run with
 *      interrupts disabled. 
 */
-static void do_identify(ide_drive_t *drive, u8 cmd)
+static void do_identify(ide_drive_t *drive, u8 cmd, u16 *id)
 {
        ide_hwif_t *hwif = drive->hwif;
-        u16 *id = drive->id;
        char *m = (char *)&id[ATA_ID_PROD];
        unsigned long flags;
        int bswap = 1;
@@ -233,16 +233,6 @@ static void do_identify(ide_drive_t *drive, u8 cmd)
        drive->dev_flags |= IDE_DFLAG_PRESENT;
        drive->dev_flags &= ~IDE_DFLAG_DEAD;
-        /*
-         * Check for an ATAPI device
-         */
-        if (cmd == ATA_CMD_ID_ATAPI)
-                ide_classify_atapi_dev(drive);
-        else
-        /*
-         * Not an ATAPI device: looks like a "regular" hard disk
-         */
-                ide_classify_ata_dev(drive);
        return;
 err_misc:
        kfree(id);
@@ -250,21 +240,19 @@ err_misc:
 }
 /**
- *      actual_try_to_identify  -       send ata/atapi identify
+ *      ide_dev_read_id -       send ATA/ATAPI IDENTIFY command
 *      @drive: drive to identify
 *      @cmd: command to use
+ *      @id: buffer for IDENTIFY data
 *
- *      try_to_identify() sends an ATA(PI) IDENTIFY request to a drive
+ *      Sends an ATA(PI) IDENTIFY request to a drive and waits for a response.
- *      and waits for a response.  It also monitors irqs while this is
- *      happening, in hope of automatically determining which one is
- *      being used by the interface.
 *
 *      Returns:        0  device was identified
 *                      1  device timed-out (no response to identify request)
 *                      2  device aborted the command (refused to identify itself)
 */
-static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
+int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
@@ -273,6 +261,13 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
        unsigned long timeout;
        u8 s = 0, a = 0;
+        /*
+         * Disable device IRQ.  Otherwise we'll get spurious interrupts
+         * during the identify phase that the IRQ handler isn't expecting.
+         */
+        if (io_ports->ctl_addr)
+                tp_ops->set_irq(hwif, 0);
        /* take a deep breath */
        msleep(50);
@@ -317,7 +312,7 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
        if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
                /* drive returned ID */
-                do_identify(drive, cmd);
+                do_identify(drive, cmd, id);
                /* drive responded with ID */
                rc = 0;
                /* clear drive IRQ */
@@ -329,63 +324,6 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
        return rc;
 }
-/**
- *      try_to_identify -       try to identify a drive
- *      @drive: drive to probe
- *      @cmd: command to use
- *
- *      Issue the identify command and then do IRQ probing to
- *      complete the identification when needed by finding the
- *      IRQ the drive is attached to
- */
- 
-static int try_to_identify (ide_drive_t *drive, u8 cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        int retval;
-        int autoprobe = 0;
-        unsigned long cookie = 0;
-        /*
-         * Disable device irq unless we need to
-         * probe for it. Otherwise we'll get spurious
-         * interrupts during the identify-phase that
-         * the irq handler isn't expecting.
-         */
-        if (hwif->io_ports.ctl_addr) {
-                if (!hwif->irq) {
-                        autoprobe = 1;
-                        cookie = probe_irq_on();
-                }
-                tp_ops->set_irq(hwif, autoprobe);
-        }
-        retval = actual_try_to_identify(drive, cmd);
-        if (autoprobe) {
-                int irq;
-                tp_ops->set_irq(hwif, 0);
-                /* clear drive IRQ */
-                (void)tp_ops->read_status(hwif);
-                udelay(5);
-                irq = probe_irq_off(cookie);
-                if (!hwif->irq) {
-                        if (irq > 0) {
-                                hwif->irq = irq;
-                        } else {
-                                /* Mmmm.. multiple IRQs..
-                                 * don't know which was ours
-                                 */
-                                printk(KERN_ERR "%s: IRQ probe failed (0x%lx)\n",
-                                        drive->name, cookie);
-                        }
-                }
-        }
-        return retval;
-}
 int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
 {
        u8 stat;
@@ -440,6 +378,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
 {
        ide_hwif_t *hwif = drive->hwif;
        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
+        u16 *id = drive->id;
        int rc;
        u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;
@@ -475,11 +414,10 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
        if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
            present || cmd == ATA_CMD_ID_ATAPI) {
-                /* send cmd and wait */
+                rc = ide_dev_read_id(drive, cmd, id);
-                if ((rc = try_to_identify(drive, cmd))) {
+                if (rc)
                        /* failed: try again */
-                        rc = try_to_identify(drive,cmd);
+                        rc = ide_dev_read_id(drive, cmd, id);
-                }
                stat = tp_ops->read_status(hwif);
@@ -494,7 +432,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
                        msleep(50);
                        tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
                        (void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
-                        rc = try_to_identify(drive, cmd);
+                        rc = ide_dev_read_id(drive, cmd, id);
                }
                /* ensure drive IRQ is clear */
@@ -517,37 +455,6 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
        return rc;
 }
-/*
- *
- */
-static void enable_nest (ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        u8 stat;
-        printk(KERN_INFO "%s: enabling %s -- ",
-                hwif->name, (char *)&drive->id[ATA_ID_PROD]);
-        SELECT_DRIVE(drive);
-        msleep(50);
-        tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
-        if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
-                printk(KERN_CONT "failed (timeout)\n");
-                return;
-        }
-        msleep(50);
-        stat = tp_ops->read_status(hwif);
-        if (!OK_STAT(stat, 0, BAD_STAT))
-                printk(KERN_CONT "failed (status = 0x%02x)\n", stat);
-        else
-                printk(KERN_CONT "success\n");
-}
 /**
 *      probe_for_drives        -       upper level drive probe
 *      @drive: drive to probe for
@@ -563,6 +470,8 @@ static void enable_nest (ide_drive_t *drive)
 static u8 probe_for_drive(ide_drive_t *drive)
 {
        char *m;
+        int rc;
+        u8 cmd;
        /*
         *      In order to keep things simple we have an id
@@ -586,21 +495,19 @@ static u8 probe_for_drive(ide_drive_t *drive)
        /* skip probing? */
        if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
-retry:
                /* if !(success||timed-out) */
-                if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
+                cmd = ATA_CMD_ID_ATA;
+                rc = do_probe(drive, cmd);
+                if (rc >= 2) {
                        /* look for ATAPI device */
-                        (void)do_probe(drive, ATA_CMD_ID_ATAPI);
+                        cmd = ATA_CMD_ID_ATAPI;
+                        rc = do_probe(drive, cmd);
+                }
                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
                        /* drive not found */
                        return 0;
-                if (strstr(m, "E X A B Y T E N E S T")) {
-                        enable_nest(drive);
-                        goto retry;
-                }
                /* identification failed? */
                if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
                        if (drive->media == ide_disk) {
@@ -614,8 +521,12 @@ retry:
                                printk(KERN_WARNING "%s: Unknown device on bus refused identification. Ignoring.\n", drive->name);
                                drive->dev_flags &= ~IDE_DFLAG_PRESENT;
                        }
+                } else {
+                        if (cmd == ATA_CMD_ID_ATAPI)
+                                ide_classify_atapi_dev(drive);
+                        else
+                                ide_classify_ata_dev(drive);
                }
-                /* drive was found */
        }
        if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
@@ -779,7 +690,6 @@ EXPORT_SYMBOL_GPL(ide_undecoded_slave);
 static int ide_probe_port(ide_hwif_t *hwif)
 {
        ide_drive_t *drive;
-        unsigned long flags;
        unsigned int irqd;
        int i, rc = -ENODEV;
@@ -797,9 +707,6 @@ static int ide_probe_port(ide_hwif_t *hwif)
        if (irqd)
                disable_irq(hwif->irq);
-        local_save_flags(flags);
-        local_irq_enable_in_hardirq();
        if (ide_port_wait_ready(hwif) == -EBUSY)
                printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
@@ -813,8 +720,6 @@ static int ide_probe_port(ide_hwif_t *hwif)
                        rc = 0;
        }
-        local_irq_restore(flags);
        /*
         * Use cached IRQ number. It might be (and is...) changed by probe
         * code above
@@ -831,29 +736,18 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
        ide_drive_t *drive;
        int i;
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if (drive->dev_flags & IDE_DFLAG_PRESENT) {
+                if (port_ops && port_ops->quirkproc)
-                        if (port_ops && port_ops->quirkproc)
+                        port_ops->quirkproc(drive);
-                                port_ops->quirkproc(drive);
-                }
        }
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if (drive->dev_flags & IDE_DFLAG_PRESENT) {
+                ide_set_max_pio(drive);
-                        ide_set_max_pio(drive);
-                        drive->dev_flags |= IDE_DFLAG_NICE1;
+                drive->dev_flags |= IDE_DFLAG_NICE1;
-                        if (hwif->dma_ops)
-                                ide_set_dma(drive);
-                }
-        }
-        ide_port_for_each_dev(i, drive, hwif) {
+                if (hwif->dma_ops)
-                if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
+                        ide_set_dma(drive);
-                        drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
-                else
-                        drive->dev_flags &= ~IDE_DFLAG_NO_IO_32BIT;
        }
 }
@@ -924,10 +818,7 @@ static int ide_port_setup_devices(ide_hwif_t *hwif)
        int i, j = 0;
        mutex_lock(&ide_cfg_mtx);
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
-                        continue;
                if (ide_init_queue(drive)) {
                        printk(KERN_ERR "ide: failed to init %s\n",
                                        drive->name);
@@ -953,13 +844,6 @@ static int init_irq (ide_hwif_t *hwif)
        irq_handler_t irq_handler;
        int sa = 0;
-        mutex_lock(&ide_cfg_mtx);
-        spin_lock_init(&hwif->lock);
-        init_timer(&hwif->timer);
-        hwif->timer.function = &ide_timer_expiry;
-        hwif->timer.data = (unsigned long)hwif;
        irq_handler = hwif->host->irq_handler;
        if (irq_handler == NULL)
                irq_handler = ide_intr;
@@ -997,10 +881,8 @@ static int init_irq (ide_hwif_t *hwif)
                printk(KERN_CONT " (serialized)");
        printk(KERN_CONT "\n");
-        mutex_unlock(&ide_cfg_mtx);
        return 0;
 out_up:
-        mutex_unlock(&ide_cfg_mtx);
        return 1;
 }
@@ -1099,14 +981,9 @@ static void drive_release_dev (struct device *dev)
 static int hwif_init(ide_hwif_t *hwif)
 {
-        int old_irq;
        if (!hwif->irq) {
-                hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
+                printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
-                if (!hwif->irq) {
+                return 0;
-                        printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
-                        return 0;
-                }
        }
        if (register_blkdev(hwif->major, hwif->name))
@@ -1124,29 +1001,12 @@ static int hwif_init(ide_hwif_t *hwif)
        sg_init_table(hwif->sg_table, hwif->sg_max_nents);
        
-        if (init_irq(hwif) == 0)
-                goto done;
-        old_irq = hwif->irq;
-        /*
-         *      It failed to initialise. Find the default IRQ for 
-         *      this port and try that.
-         */
-        hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
-        if (!hwif->irq) {
-                printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
-                        hwif->name, old_irq);
-                goto out;
-        }
        if (init_irq(hwif)) {
-                printk(KERN_ERR "%s: probed IRQ %d and default IRQ %d failed\n",
+                printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
-                        hwif->name, old_irq, hwif->irq);
+                        hwif->name, hwif->irq);
                goto out;
        }
-        printk(KERN_WARNING "%s: probed IRQ %d failed, using default\n",
-                hwif->name, hwif->irq);
-done:
        blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
                            THIS_MODULE, ata_probe, ata_lock, hwif);
        return 1;
@@ -1161,13 +1021,10 @@ static void hwif_register_devices(ide_hwif_t *hwif)
        ide_drive_t *drive;
        unsigned int i;
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
                struct device *dev = &drive->gendev;
                int ret;
-                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
-                        continue;
                dev_set_name(dev, "%u.%u", hwif->index, i);
                dev->parent = &hwif->gendev;
                dev->bus = &ide_bus_type;
@@ -1192,6 +1049,8 @@ static void ide_port_init_devices(ide_hwif_t *hwif)
                if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
                        drive->io_32bit = 1;
+                if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
+                        drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
                if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
                        drive->dev_flags |= IDE_DFLAG_UNMASK;
                if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
@@ -1213,10 +1072,6 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
        if (d->init_iops)
                d->init_iops(hwif);
-        if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) ||
-            (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
-                hwif->irq = port ? 15 : 14;
        /* ->host_flags may be set by ->init_iops (or even earlier...) */
        hwif->host_flags |= d->host_flags;
        hwif->pio_mask = d->pio_mask;
@@ -1317,6 +1172,12 @@ static void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
        hwif->name[2]   = 'e';
        hwif->name[3]   = '0' + index;
+        spin_lock_init(&hwif->lock);
+        init_timer(&hwif->timer);
+        hwif->timer.function = &ide_timer_expiry;
+        hwif->timer.data = (unsigned long)hwif;
        init_completion(&hwif->gendev_rel_comp);
        hwif->tp_ops = &default_tp_ops;
@@ -1567,7 +1428,7 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                j++;
-                ide_acpi_init(hwif);
+                ide_acpi_init_port(hwif);
                if (hwif->present)
                        ide_acpi_port_init_devices(hwif);
@@ -1624,11 +1485,9 @@ static void __ide_port_unregister_devices(ide_hwif_t *hwif)
        ide_drive_t *drive;
        int i;
-        ide_port_for_each_dev(i, drive, hwif) {
+        ide_port_for_each_present_dev(i, drive, hwif) {
-                if (drive->dev_flags & IDE_DFLAG_PRESENT) {
+                device_unregister(&drive->gendev);
-                        device_unregister(&drive->gendev);
+                wait_for_completion(&drive->gendev_rel_comp);
-                        wait_for_completion(&drive->gendev_rel_comp);
-                }
        }
 }
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index a7b9287ee0d4..417cde56eafd 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -600,7 +600,7 @@ void ide_proc_port_register_devices(ide_hwif_t *hwif)
        int i;
        ide_port_for_each_dev(i, drive, hwif) {
-                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0 || drive->proc)
+                if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
                        continue;
                drive->proc = proc_mkdir(drive->name, parent);
diff --git a/drivers/ide/ide-xfer-mode.c b/drivers/ide/ide-xfer-mode.c
new file mode 100644
index 000000000000..6910f6a257e8
--- /dev/null
+++ b/drivers/ide/ide-xfer-mode.c
@@ -0,0 +1,246 @@
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/ide.h>
+#include <linux/bitops.h>
+static const char *udma_str[] =
+         { "UDMA/16", "UDMA/25",  "UDMA/33",  "UDMA/44",
+           "UDMA/66", "UDMA/100", "UDMA/133", "UDMA7" };
+static const char *mwdma_str[] =
+        { "MWDMA0", "MWDMA1", "MWDMA2" };
+static const char *swdma_str[] =
+        { "SWDMA0", "SWDMA1", "SWDMA2" };
+static const char *pio_str[] =
+        { "PIO0", "PIO1", "PIO2", "PIO3", "PIO4", "PIO5" };
+/**
+ *      ide_xfer_verbose        -       return IDE mode names
+ *      @mode: transfer mode
+ *
+ *      Returns a constant string giving the name of the mode
+ *      requested.
+ */
+const char *ide_xfer_verbose(u8 mode)
+{
+        const char *s;
+        u8 i = mode & 0xf;
+        if (mode >= XFER_UDMA_0 && mode <= XFER_UDMA_7)
+                s = udma_str[i];
+        else if (mode >= XFER_MW_DMA_0 && mode <= XFER_MW_DMA_2)
+                s = mwdma_str[i];
+        else if (mode >= XFER_SW_DMA_0 && mode <= XFER_SW_DMA_2)
+                s = swdma_str[i];
+        else if (mode >= XFER_PIO_0 && mode <= XFER_PIO_5)
+                s = pio_str[i & 0x7];
+        else if (mode == XFER_PIO_SLOW)
+                s = "PIO SLOW";
+        else
+                s = "XFER ERROR";
+        return s;
+}
+EXPORT_SYMBOL(ide_xfer_verbose);
+/**
+ *      ide_get_best_pio_mode   -       get PIO mode from drive
+ *      @drive: drive to consider
+ *      @mode_wanted: preferred mode
+ *      @max_mode: highest allowed mode
+ *
+ *      This routine returns the recommended PIO settings for a given drive,
+ *      based on the drive->id information and the ide_pio_blacklist[].
+ *
+ *      Drive PIO mode is auto-selected if 255 is passed as mode_wanted.
+ *      This is used by most chipset support modules when "auto-tuning".
+ */
+u8 ide_get_best_pio_mode(ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
+{
+        u16 *id = drive->id;
+        int pio_mode = -1, overridden = 0;
+        if (mode_wanted != 255)
+                return min_t(u8, mode_wanted, max_mode);
+        if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_BLACKLIST) == 0)
+                pio_mode = ide_scan_pio_blacklist((char *)&id[ATA_ID_PROD]);
+        if (pio_mode != -1) {
+                printk(KERN_INFO "%s: is on PIO blacklist\n", drive->name);
+        } else {
+                pio_mode = id[ATA_ID_OLD_PIO_MODES] >> 8;
+                if (pio_mode > 2) {     /* 2 is maximum allowed tPIO value */
+                        pio_mode = 2;
+                        overridden = 1;
+                }
+                if (id[ATA_ID_FIELD_VALID] & 2) {             /* ATA2? */
+                        if (ata_id_has_iordy(id)) {
+                                if (id[ATA_ID_PIO_MODES] & 7) {
+                                        overridden = 0;
+                                        if (id[ATA_ID_PIO_MODES] & 4)
+                                                pio_mode = 5;
+                                        else if (id[ATA_ID_PIO_MODES] & 2)
+                                                pio_mode = 4;
+                                        else
+                                                pio_mode = 3;
+                                }
+                        }
+                }
+                if (overridden)
+                        printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n",
+                                         drive->name);
+        }
+        if (pio_mode > max_mode)
+                pio_mode = max_mode;
+        return pio_mode;
+}
+EXPORT_SYMBOL_GPL(ide_get_best_pio_mode);
+int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
+                return 0;
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL)
+                return -1;
+        /*
+         * TODO: temporary hack for some legacy host drivers that didn't
+         * set transfer mode on the device in ->set_pio_mode method...
+         */
+        if (port_ops->set_dma_mode == NULL) {
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
+                return 0;
+        }
+        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
+                if (ide_config_drive_speed(drive, mode))
+                        return -1;
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
+                return 0;
+        } else {
+                port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
+                return ide_config_drive_speed(drive, mode);
+        }
+}
+int ide_set_dma_mode(ide_drive_t *drive, const u8 mode)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
+                return 0;
+        if (port_ops == NULL || port_ops->set_dma_mode == NULL)
+                return -1;
+        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
+                if (ide_config_drive_speed(drive, mode))
+                        return -1;
+                port_ops->set_dma_mode(drive, mode);
+                return 0;
+        } else {
+                port_ops->set_dma_mode(drive, mode);
+                return ide_config_drive_speed(drive, mode);
+        }
+}
+EXPORT_SYMBOL_GPL(ide_set_dma_mode);
+/* req_pio == "255" for auto-tune */
+void ide_set_pio(ide_drive_t *drive, u8 req_pio)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        u8 host_pio, pio;
+        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
+                return;
+        BUG_ON(hwif->pio_mask == 0x00);
+        host_pio = fls(hwif->pio_mask) - 1;
+        pio = ide_get_best_pio_mode(drive, req_pio, host_pio);
+        /*
+         * TODO:
+         * - report device max PIO mode
+         * - check req_pio != 255 against device max PIO mode
+         */
+        printk(KERN_DEBUG "%s: host max PIO%d wanted PIO%d%s selected PIO%d\n",
+                          drive->name, host_pio, req_pio,
+                          req_pio == 255 ? "(auto-tune)" : "", pio);
+        (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio);
+}
+EXPORT_SYMBOL_GPL(ide_set_pio);
+/**
+ *      ide_rate_filter         -       filter transfer mode
+ *      @drive: IDE device
+ *      @speed: desired speed
+ *
+ *      Given the available transfer modes this function returns
+ *      the best available speed at or below the speed requested.
+ *
+ *      TODO: check device PIO capabilities
+ */
+static u8 ide_rate_filter(ide_drive_t *drive, u8 speed)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        u8 mode = ide_find_dma_mode(drive, speed);
+        if (mode == 0) {
+                if (hwif->pio_mask)
+                        mode = fls(hwif->pio_mask) - 1 + XFER_PIO_0;
+                else
+                        mode = XFER_PIO_4;
+        }
+/*      printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */
+        return min(speed, mode);
+}
+/**
+ *      ide_set_xfer_rate       -       set transfer rate
+ *      @drive: drive to set
+ *      @rate: speed to attempt to set
+ *
+ *      General helper for setting the speed of an IDE device. This
+ *      function knows about user enforced limits from the configuration
+ *      which ->set_pio_mode/->set_dma_mode does not.
+ */
+int ide_set_xfer_rate(ide_drive_t *drive, u8 rate)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_port_ops *port_ops = hwif->port_ops;
+        if (port_ops == NULL || port_ops->set_dma_mode == NULL ||
+            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
+                return -1;
+        rate = ide_rate_filter(drive, rate);
+        BUG_ON(rate < XFER_PIO_0);
+        if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5)
+                return ide_set_pio_mode(drive, rate);
+        return ide_set_dma_mode(drive, rate);
+}
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 0920e3b0c962..92c9b90931e7 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -62,160 +62,6 @@
 struct class *ide_port_class;
-/*
- *      Locks for IDE setting functionality
- */
-DEFINE_MUTEX(ide_setting_mtx);
-ide_devset_get(io_32bit, io_32bit);
-static int set_io_32bit(ide_drive_t *drive, int arg)
-{
-        if (drive->dev_flags & IDE_DFLAG_NO_IO_32BIT)
-                return -EPERM;
-        if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
-                return -EINVAL;
-        drive->io_32bit = arg;
-        return 0;
-}
-ide_devset_get_flag(ksettings, IDE_DFLAG_KEEP_SETTINGS);
-static int set_ksettings(ide_drive_t *drive, int arg)
-{
-        if (arg < 0 || arg > 1)
-                return -EINVAL;
-        if (arg)
-                drive->dev_flags |= IDE_DFLAG_KEEP_SETTINGS;
-        else
-                drive->dev_flags &= ~IDE_DFLAG_KEEP_SETTINGS;
-        return 0;
-}
-ide_devset_get_flag(using_dma, IDE_DFLAG_USING_DMA);
-static int set_using_dma(ide_drive_t *drive, int arg)
-{
-#ifdef CONFIG_BLK_DEV_IDEDMA
-        int err = -EPERM;
-        if (arg < 0 || arg > 1)
-                return -EINVAL;
-        if (ata_id_has_dma(drive->id) == 0)
-                goto out;
-        if (drive->hwif->dma_ops == NULL)
-                goto out;
-        err = 0;
-        if (arg) {
-                if (ide_set_dma(drive))
-                        err = -EIO;
-        } else
-                ide_dma_off(drive);
-out:
-        return err;
-#else
-        if (arg < 0 || arg > 1)
-                return -EINVAL;
-        return -EPERM;
-#endif
-}
-/*
- * handle HDIO_SET_PIO_MODE ioctl abusers here, eventually it will go away
- */
-static int set_pio_mode_abuse(ide_hwif_t *hwif, u8 req_pio)
-{
-        switch (req_pio) {
-        case 202:
-        case 201:
-        case 200:
-        case 102:
-        case 101:
-        case 100:
-                return (hwif->host_flags & IDE_HFLAG_ABUSE_DMA_MODES) ? 1 : 0;
-        case 9:
-        case 8:
-                return (hwif->host_flags & IDE_HFLAG_ABUSE_PREFETCH) ? 1 : 0;
-        case 7:
-        case 6:
-                return (hwif->host_flags & IDE_HFLAG_ABUSE_FAST_DEVSEL) ? 1 : 0;
-        default:
-                return 0;
-        }
-}
-static int set_pio_mode(ide_drive_t *drive, int arg)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        const struct ide_port_ops *port_ops = hwif->port_ops;
-        if (arg < 0 || arg > 255)
-                return -EINVAL;
-        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
-            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
-                return -ENOSYS;
-        if (set_pio_mode_abuse(drive->hwif, arg)) {
-                if (arg == 8 || arg == 9) {
-                        unsigned long flags;
-                        /* take lock for IDE_DFLAG_[NO_]UNMASK/[NO_]IO_32BIT */
-                        spin_lock_irqsave(&hwif->lock, flags);
-                        port_ops->set_pio_mode(drive, arg);
-                        spin_unlock_irqrestore(&hwif->lock, flags);
-                } else
-                        port_ops->set_pio_mode(drive, arg);
-        } else {
-                int keep_dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
-                ide_set_pio(drive, arg);
-                if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) {
-                        if (keep_dma)
-                                ide_dma_on(drive);
-                }
-        }
-        return 0;
-}
-ide_devset_get_flag(unmaskirq, IDE_DFLAG_UNMASK);
-static int set_unmaskirq(ide_drive_t *drive, int arg)
-{
-        if (drive->dev_flags & IDE_DFLAG_NO_UNMASK)
-                return -EPERM;
-        if (arg < 0 || arg > 1)
-                return -EINVAL;
-        if (arg)
-                drive->dev_flags |= IDE_DFLAG_UNMASK;
-        else
-                drive->dev_flags &= ~IDE_DFLAG_UNMASK;
-        return 0;
-}
-ide_ext_devset_rw_sync(io_32bit, io_32bit);
-ide_ext_devset_rw_sync(keepsettings, ksettings);
-ide_ext_devset_rw_sync(unmaskirq, unmaskirq);
-ide_ext_devset_rw_sync(using_dma, using_dma);
-__IDE_DEVSET(pio_mode, DS_SYNC, NULL, set_pio_mode);
 /**
 * ide_device_get       -       get an additional reference to a ide_drive_t
 * @drive:      device to get a reference to
@@ -527,6 +373,8 @@ static int __init ide_init(void)
                goto out_port_class;
        }
+        ide_acpi_init();
        proc_ide_create();
        return 0;
diff --git a/drivers/ide/it821x.c b/drivers/ide/it821x.c
index 13b8153112ed..6b9fc950b4af 100644
--- a/drivers/ide/it821x.c
+++ b/drivers/ide/it821x.c
@@ -603,7 +603,7 @@ static void it8212_disable_raid(struct pci_dev *dev)
        pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
 }
-static unsigned int init_chipset_it821x(struct pci_dev *dev)
+static int init_chipset_it821x(struct pci_dev *dev)
 {
        u8 conf;
        static char *mode[2] = { "pass through", "smart" };
diff --git a/drivers/ide/ns87415.c b/drivers/ide/ns87415.c
index 83643ed9a426..ea48a3ee8063 100644
--- a/drivers/ide/ns87415.c
+++ b/drivers/ide/ns87415.c
@@ -286,9 +286,7 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
        }
        if (!using_inta)
-                hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
+                hwif->irq = pci_get_legacy_ide_irq(dev, hwif->channel);
-        else if (!hwif->irq && hwif->mate && hwif->mate->irq)
-                hwif->irq = hwif->mate->irq;    /* share IRQ with mate */
        if (!hwif->dma_base)
                return;
diff --git a/drivers/ide/pdc202xx_new.c b/drivers/ide/pdc202xx_new.c
index f21290c4b447..b68906c3c17e 100644
--- a/drivers/ide/pdc202xx_new.c
+++ b/drivers/ide/pdc202xx_new.c
@@ -325,7 +325,7 @@ static void apple_kiwi_init(struct pci_dev *pdev)
 }
 #endif /* CONFIG_PPC_PMAC */
-static unsigned int init_chipset_pdcnew(struct pci_dev *dev)
+static int init_chipset_pdcnew(struct pci_dev *dev)
 {
        const char *name = DRV_NAME;
        unsigned long dma_base = pci_resource_start(dev, 4);
@@ -444,7 +444,7 @@ static unsigned int init_chipset_pdcnew(struct pci_dev *dev)
 #endif
 out:
-        return dev->irq;
+        return 0;
 }
 static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
diff --git a/drivers/ide/pdc202xx_old.c b/drivers/ide/pdc202xx_old.c
index 97193323aebf..cba66ebce4e3 100644
--- a/drivers/ide/pdc202xx_old.c
+++ b/drivers/ide/pdc202xx_old.c
@@ -264,7 +264,7 @@ static void pdc202xx_dma_timeout(ide_drive_t *drive)
        ide_dma_timeout(drive);
 }
-static unsigned int init_chipset_pdc202xx(struct pci_dev *dev)
+static int init_chipset_pdc202xx(struct pci_dev *dev)
 {
        unsigned long dmabase = pci_resource_start(dev, 4);
        u8 udma_speed_flag = 0, primary_mode = 0, secondary_mode = 0;
@@ -290,7 +290,7 @@ static unsigned int init_chipset_pdc202xx(struct pci_dev *dev)
                printk("%sACTIVE\n", (inb(dmabase | 0x1f) & 1) ? "" : "IN");
        }
 out:
-        return dev->irq;
+        return 0;
 }
 static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev,
diff --git a/drivers/ide/piix.c b/drivers/ide/piix.c
index f1e2e4ef0d71..2aa699933064 100644
--- a/drivers/ide/piix.c
+++ b/drivers/ide/piix.c
@@ -204,7 +204,7 @@ static void piix_set_dma_mode(ide_drive_t *drive, const u8 speed)
 *      out to be nice and simple.
 */
-static unsigned int init_chipset_ich(struct pci_dev *dev)
+static int init_chipset_ich(struct pci_dev *dev)
 {
        u32 extra = 0;
@@ -318,19 +318,12 @@ static const struct ide_port_ops ich_port_ops = {
        .cable_detect           = piix_cable_detect,
 };
-#ifndef CONFIG_IA64
- #define IDE_HFLAGS_PIIX IDE_HFLAG_LEGACY_IRQS
-#else
- #define IDE_HFLAGS_PIIX 0
-#endif
 #define DECLARE_PIIX_DEV(udma) \
        {                                               \
                .name           = DRV_NAME,             \
                .init_hwif      = init_hwif_piix,       \
                .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
                .port_ops       = &piix_port_ops,       \
-                .host_flags     = IDE_HFLAGS_PIIX,      \
                .pio_mask       = ATA_PIO4,             \
                .swdma_mask     = ATA_SWDMA2_ONLY,      \
                .mwdma_mask     = ATA_MWDMA12_ONLY,     \
@@ -344,7 +337,6 @@ static const struct ide_port_ops ich_port_ops = {
                .init_hwif      = init_hwif_piix, \
                .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
                .port_ops       = &ich_port_ops, \
-                .host_flags     = IDE_HFLAGS_PIIX, \
                .pio_mask       = ATA_PIO4, \
                .swdma_mask     = ATA_SWDMA2_ONLY, \
                .mwdma_mask     = ATA_MWDMA12_ONLY, \
@@ -360,8 +352,7 @@ static const struct ide_port_info piix_pci_info[] __devinitdata = {
                 */
                .name           = DRV_NAME,
                .enablebits     = {{0x6d,0xc0,0x80}, {0x6d,0xc0,0xc0}},
-                .host_flags     = IDE_HFLAG_ISA_PORTS | IDE_HFLAG_NO_DMA |
+                .host_flags     = IDE_HFLAG_ISA_PORTS | IDE_HFLAG_NO_DMA,
-                                  IDE_HFLAGS_PIIX,
                .pio_mask       = ATA_PIO4,
                /* This is a painful system best to let it self tune for now */
        },
diff --git a/drivers/ide/serverworks.c b/drivers/ide/serverworks.c
index 382102ba467b..b6554ef92716 100644
--- a/drivers/ide/serverworks.c
+++ b/drivers/ide/serverworks.c
@@ -175,7 +175,7 @@ static void svwks_set_dma_mode(ide_drive_t *drive, const u8 speed)
        pci_write_config_byte(dev, 0x54, ultra_enable);
 }
-static unsigned int init_chipset_svwks(struct pci_dev *dev)
+static int init_chipset_svwks(struct pci_dev *dev)
 {
        unsigned int reg;
        u8 btr;
@@ -270,7 +270,7 @@ static unsigned int init_chipset_svwks(struct pci_dev *dev)
                pci_write_config_byte(dev, 0x5A, btr);
        }
-        return dev->irq;
+        return 0;
 }
 static u8 ata66_svwks_svwks(ide_hwif_t *hwif)
@@ -353,14 +353,11 @@ static const struct ide_port_ops svwks_port_ops = {
        .cable_detect           = svwks_cable_detect,
 };
-#define IDE_HFLAGS_SVWKS IDE_HFLAG_LEGACY_IRQS
 static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
        {       /* 0: OSB4 */
                .name           = DRV_NAME,
                .init_chipset   = init_chipset_svwks,
                .port_ops       = &osb4_port_ops,
-                .host_flags     = IDE_HFLAGS_SVWKS,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = 0x00, /* UDMA is problematic on OSB4 */
@@ -369,7 +366,6 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
                .name           = DRV_NAME,
                .init_chipset   = init_chipset_svwks,
                .port_ops       = &svwks_port_ops,
-                .host_flags     = IDE_HFLAGS_SVWKS,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
@@ -378,7 +374,6 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
                .name           = DRV_NAME,
                .init_chipset   = init_chipset_svwks,
                .port_ops       = &svwks_port_ops,
-                .host_flags     = IDE_HFLAGS_SVWKS,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
@@ -387,7 +382,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
                .name           = DRV_NAME,
                .init_chipset   = init_chipset_svwks,
                .port_ops       = &svwks_port_ops,
-                .host_flags     = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
+                .host_flags     = IDE_HFLAG_SINGLE,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
@@ -396,7 +391,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
                .name           = DRV_NAME,
                .init_chipset   = init_chipset_svwks,
                .port_ops       = &svwks_port_ops,
-                .host_flags     = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
+                .host_flags     = IDE_HFLAG_SINGLE,
                .pio_mask       = ATA_PIO4,
                .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA5,
diff --git a/drivers/ide/setup-pci.c b/drivers/ide/setup-pci.c
index e85d1ed29c2a..24bc884826fc 100644
--- a/drivers/ide/setup-pci.c
+++ b/drivers/ide/setup-pci.c
@@ -305,7 +305,6 @@ static int ide_pci_check_iomem(struct pci_dev *dev, const struct ide_port_info *
 *      @dev: PCI device holding interface
 *      @d: IDE port info
 *      @port: port number
- *      @irq: PCI IRQ
 *      @hw: hw_regs_t instance corresponding to this port
 *
 *      Perform the initial set up for the hardware interface structure. This
@@ -316,7 +315,7 @@ static int ide_pci_check_iomem(struct pci_dev *dev, const struct ide_port_info *
 */
 static int ide_hw_configure(struct pci_dev *dev, const struct ide_port_info *d,
-                            unsigned int port, int irq, hw_regs_t *hw)
+                            unsigned int port, hw_regs_t *hw)
 {
        unsigned long ctl = 0, base = 0;
@@ -344,7 +343,6 @@ static int ide_hw_configure(struct pci_dev *dev, const struct ide_port_info *d,
        }
        memset(hw, 0, sizeof(*hw));
-        hw->irq = irq;
        hw->dev = &dev->dev;
        hw->chipset = d->chipset ? d->chipset : ide_pci;
        ide_std_init_ports(hw, base, ctl | 2);
@@ -448,7 +446,6 @@ out:
 *      ide_pci_setup_ports     -       configure ports/devices on PCI IDE
 *      @dev: PCI device
 *      @d: IDE port info
- *      @pciirq: IRQ line
 *      @hw: hw_regs_t instances corresponding to this PCI IDE device
 *      @hws: hw_regs_t pointers table to update
 *
@@ -462,7 +459,7 @@ out:
 */
 void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d,
-                         int pciirq, hw_regs_t *hw, hw_regs_t **hws)
+                         hw_regs_t *hw, hw_regs_t **hws)
 {
        int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
        u8 tmp;
@@ -481,7 +478,7 @@ void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d,
                        continue;       /* port not enabled */
                }
-                if (ide_hw_configure(dev, d, port, pciirq, hw + port))
+                if (ide_hw_configure(dev, d, port, hw + port))
                        continue;
                *(hws + port) = hw + port;
@@ -524,7 +521,7 @@ static int do_ide_setup_pci_device(struct pci_dev *dev,
                if (noisy)
                        printk(KERN_INFO "%s %s: not 100%% native mode: will "
                                "probe irqs later\n", d->name, pci_name(dev));
-                pciirq = ret;
+                pciirq = 0;
        } else if (!pciirq && noisy) {
                printk(KERN_WARNING "%s %s: bad irq (%d): will probe later\n",
                        d->name, pci_name(dev), pciirq);
@@ -549,7 +546,7 @@ int ide_pci_init_one(struct pci_dev *dev, const struct ide_port_info *d,
        if (ret < 0)
                goto out;
-        ide_pci_setup_ports(dev, d, 0, &hw[0], &hws[0]);
+        ide_pci_setup_ports(dev, d, &hw[0], &hws[0]);
        host = ide_host_alloc(d, hws);
        if (host == NULL) {
@@ -568,7 +565,11 @@ int ide_pci_init_one(struct pci_dev *dev, const struct ide_port_info *d,
                goto out;
        /* fixup IRQ */
-        hw[1].irq = hw[0].irq = ret;
+        if (ide_pci_is_in_compatibility_mode(dev)) {
+                hw[0].irq = pci_get_legacy_ide_irq(dev, 0);
+                hw[1].irq = pci_get_legacy_ide_irq(dev, 1);
+        } else
+                hw[1].irq = hw[0].irq = ret;
        ret = ide_host_register(host, d, hws);
        if (ret)
@@ -591,7 +592,7 @@ int ide_pci_init_two(struct pci_dev *dev1, struct pci_dev *dev2,
                if (ret < 0)
                        goto out;
-                ide_pci_setup_ports(pdev[i], d, 0, &hw[i*2], &hws[i*2]);
+                ide_pci_setup_ports(pdev[i], d, &hw[i*2], &hws[i*2]);
        }
        host = ide_host_alloc(d, hws);
@@ -619,7 +620,11 @@ int ide_pci_init_two(struct pci_dev *dev1, struct pci_dev *dev2,
                        goto out;
                /* fixup IRQ */
-                hw[i*2 + 1].irq = hw[i*2].irq = ret;
+                if (ide_pci_is_in_compatibility_mode(pdev[i])) {
+                        hw[i*2].irq = pci_get_legacy_ide_irq(pdev[i], 0);
+                        hw[i*2 + 1].irq = pci_get_legacy_ide_irq(pdev[i], 1);
+                } else
+                        hw[i*2 + 1].irq = hw[i*2].irq = ret;
        }
        ret = ide_host_register(host, d, hws);
diff --git a/drivers/ide/siimage.c b/drivers/ide/siimage.c
index cb2b352b876b..1811ae9cd843 100644
--- a/drivers/ide/siimage.c
+++ b/drivers/ide/siimage.c
@@ -464,7 +464,7 @@ static void sil_sata_pre_reset(ide_drive_t *drive)
 *      to 133 MHz clocking if the system isn't already set up to do it.
 */
-static unsigned int init_chipset_siimage(struct pci_dev *dev)
+static int init_chipset_siimage(struct pci_dev *dev)
 {
        struct ide_host *host = pci_get_drvdata(dev);
        void __iomem *ioaddr = host->host_priv;
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c
index 9ec1a4a4432c..afca22beaadf 100644
--- a/drivers/ide/sis5513.c
+++ b/drivers/ide/sis5513.c
@@ -447,7 +447,7 @@ static int __devinit sis_find_family(struct pci_dev *dev)
        return chipset_family;
 }
-static unsigned int init_chipset_sis5513(struct pci_dev *dev)
+static int init_chipset_sis5513(struct pci_dev *dev)
 {
        /* Make general config ops here
           1/ tell IDE channels to operate in Compatibility mode only
@@ -563,7 +563,7 @@ static const struct ide_port_info sis5513_chipset __devinitdata = {
        .name           = DRV_NAME,
        .init_chipset   = init_chipset_sis5513,
        .enablebits     = { {0x4a, 0x02, 0x02}, {0x4a, 0x04, 0x04} },
-        .host_flags     = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_NO_AUTODMA,
+        .host_flags     = IDE_HFLAG_NO_AUTODMA,
        .pio_mask       = ATA_PIO4,
        .mwdma_mask     = ATA_MWDMA2,
 };
diff --git a/drivers/ide/sl82c105.c b/drivers/ide/sl82c105.c
index 6297956507c0..dba213c51baa 100644
--- a/drivers/ide/sl82c105.c
+++ b/drivers/ide/sl82c105.c
@@ -271,7 +271,7 @@ static u8 sl82c105_bridge_revision(struct pci_dev *dev)
 * channel 0 here at least, but channel 1 has to be enabled by
 * firmware or arch code. We still set both to 16 bits mode.
 */
-static unsigned int init_chipset_sl82c105(struct pci_dev *dev)
+static int init_chipset_sl82c105(struct pci_dev *dev)
 {
        u32 val;
@@ -281,7 +281,7 @@ static unsigned int init_chipset_sl82c105(struct pci_dev *dev)
        val |= CTRL_P0EN | CTRL_P0F16 | CTRL_P1F16;
        pci_write_config_dword(dev, 0x40, val);
-        return dev->irq;
+        return 0;
 }
 static const struct ide_port_ops sl82c105_port_ops = {
diff --git a/drivers/ide/slc90e66.c b/drivers/ide/slc90e66.c
index 40b4b94a4288..f55d7d6313e8 100644
--- a/drivers/ide/slc90e66.c
+++ b/drivers/ide/slc90e66.c
@@ -136,7 +136,6 @@ static const struct ide_port_info slc90e66_chipset __devinitdata = {
        .name           = DRV_NAME,
        .enablebits     = { {0x41, 0x80, 0x80}, {0x43, 0x80, 0x80} },
        .port_ops       = &slc90e66_port_ops,
-        .host_flags     = IDE_HFLAG_LEGACY_IRQS,
        .pio_mask       = ATA_PIO4,
        .swdma_mask     = ATA_SWDMA2_ONLY,
        .mwdma_mask     = ATA_MWDMA12_ONLY,
diff --git a/drivers/ide/trm290.c b/drivers/ide/trm290.c
index b6a1285a4021..1c09e549c423 100644
--- a/drivers/ide/trm290.c
+++ b/drivers/ide/trm290.c
@@ -277,9 +277,6 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
        if (reg & 0x10)
                /* legacy mode */
                hwif->irq = hwif->channel ? 15 : 14;
-        else if (!hwif->irq && hwif->mate && hwif->mate->irq)
-                /* sharing IRQ with mate */
-                hwif->irq = hwif->mate->irq;
 #if 1
        {
diff --git a/drivers/ide/via82cxxx.c b/drivers/ide/via82cxxx.c
index 6092fe3f409d..3ff7231e4858 100644
--- a/drivers/ide/via82cxxx.c
+++ b/drivers/ide/via82cxxx.c
@@ -267,7 +267,7 @@ static void via_cable_detect(struct via82cxxx_dev *vdev, u32 u)
 *      and initialize its drive independent registers.
 */
-static unsigned int init_chipset_via82cxxx(struct pci_dev *dev)
+static int init_chipset_via82cxxx(struct pci_dev *dev)
 {
        struct ide_host *host = pci_get_drvdata(dev);
        struct via82cxxx_dev *vdev = host->host_priv;
@@ -443,16 +443,6 @@ static int __devinit via_init_one(struct pci_dev *dev, const struct pci_device_i
        if ((via_config->flags & VIA_NO_UNMASK) == 0)
                d.host_flags |= IDE_HFLAG_UNMASK_IRQS;
-#ifdef CONFIG_PPC_CHRP
-        if (machine_is(chrp) && _chrp_type == _CHRP_Pegasos)
-                d.host_flags |= IDE_HFLAG_FORCE_LEGACY_IRQS;
-#endif
-#ifdef CONFIG_AMIGAONE
-        if (machine_is(amigaone))
-                d.host_flags |= IDE_HFLAG_FORCE_LEGACY_IRQS;
-#endif
        d.udma_mask = via_config->udma_mask;
        vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
diff --git a/drivers/input/joystick/maplecontrol.c b/drivers/input/joystick/maplecontrol.c
index e50047bfe938..77cfde571bd9 100644
--- a/drivers/input/joystick/maplecontrol.c
+++ b/drivers/input/joystick/maplecontrol.c
@@ -3,7 +3,7 @@
 *      Based on drivers/usb/iforce.c
 *
 *      Copyright Yaegashi Takeshi, 2001
- *      Adrian McMenamin, 2008
+ *      Adrian McMenamin, 2008 - 2009
 */
 #include <linux/kernel.h>
@@ -29,7 +29,7 @@ static void dc_pad_callback(struct mapleq *mq)
        struct maple_device *mapledev = mq->dev;
        struct dc_pad *pad = maple_get_drvdata(mapledev);
        struct input_dev *dev = pad->dev;
-        unsigned char *res = mq->recvbuf;
+        unsigned char *res = mq->recvbuf->buf;
        buttons = ~le16_to_cpup((__le16 *)(res + 8));
diff --git a/drivers/input/keyboard/maple_keyb.c b/drivers/input/keyboard/maple_keyb.c
index 22f17a593be7..5aa2361aef95 100644
--- a/drivers/input/keyboard/maple_keyb.c
+++ b/drivers/input/keyboard/maple_keyb.c
@@ -1,8 +1,8 @@
 /*
 * SEGA Dreamcast keyboard driver
 * Based on drivers/usb/usbkbd.c
- * Copyright YAEGASHI Takeshi, 2001
+ * Copyright (c) YAEGASHI Takeshi, 2001
- * Porting to 2.6 Copyright Adrian McMenamin, 2007, 2008
+ * Porting to 2.6 Copyright (c) Adrian McMenamin, 2007 - 2009
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@ static DEFINE_MUTEX(maple_keyb_mutex);
 #define NR_SCANCODES 256
-MODULE_AUTHOR("YAEGASHI Takeshi, Adrian McMenamin");
+MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk");
 MODULE_DESCRIPTION("SEGA Dreamcast keyboard driver");
 MODULE_LICENSE("GPL");
@@ -115,7 +115,7 @@ static void dc_scan_kbd(struct dc_kbd *kbd)
                                input_event(dev, EV_MSC, MSC_SCAN, code);
                                input_report_key(dev, keycode, 0);
                        } else
-                                printk(KERN_DEBUG "maple_keyb: "
+                                dev_dbg(&dev->dev,
                                        "Unknown key (scancode %#x) released.",
                                        code);
                }
@@ -127,7 +127,7 @@ static void dc_scan_kbd(struct dc_kbd *kbd)
                                input_event(dev, EV_MSC, MSC_SCAN, code);
                                input_report_key(dev, keycode, 1);
                        } else
-                                printk(KERN_DEBUG "maple_keyb: "
+                                dev_dbg(&dev->dev,
                                        "Unknown key (scancode %#x) pressed.",
                                        code);
                }
@@ -140,7 +140,7 @@ static void dc_kbd_callback(struct mapleq *mq)
 {
        struct maple_device *mapledev = mq->dev;
        struct dc_kbd *kbd = maple_get_drvdata(mapledev);
-        unsigned long *buf = mq->recvbuf;
+        unsigned long *buf = (unsigned long *)(mq->recvbuf->buf);
        /*
         * We should always get the lock because the only
@@ -159,22 +159,27 @@ static void dc_kbd_callback(struct mapleq *mq)
 static int probe_maple_kbd(struct device *dev)
 {
-        struct maple_device *mdev = to_maple_dev(dev);
+        struct maple_device *mdev;
-        struct maple_driver *mdrv = to_maple_driver(dev->driver);
+        struct maple_driver *mdrv;
        int i, error;
        struct dc_kbd *kbd;
        struct input_dev *idev;
-        if (!(mdev->function & MAPLE_FUNC_KEYBOARD))
+        mdev = to_maple_dev(dev);
-                return -EINVAL;
+        mdrv = to_maple_driver(dev->driver);
        kbd = kzalloc(sizeof(struct dc_kbd), GFP_KERNEL);
-        idev = input_allocate_device();
+        if (!kbd) {
-        if (!kbd || !idev) {
                error = -ENOMEM;
                goto fail;
        }
+        idev = input_allocate_device();
+        if (!idev) {
+                error = -ENOMEM;
+                goto fail_idev_alloc;
+        }
        kbd->dev = idev;
        memcpy(kbd->keycode, dc_kbd_keycode, sizeof(kbd->keycode));
@@ -195,7 +200,7 @@ static int probe_maple_kbd(struct device *dev)
        error = input_register_device(idev);
        if (error)
-                goto fail;
+                goto fail_register;
        /* Maple polling is locked to VBLANK - which may be just 50/s */
        maple_getcond_callback(mdev, dc_kbd_callback, HZ/50,
@@ -207,10 +212,12 @@ static int probe_maple_kbd(struct device *dev)
        return error;
-fail:
+fail_register:
+        maple_set_drvdata(mdev, NULL);
        input_free_device(idev);
+fail_idev_alloc:
        kfree(kbd);
-        maple_set_drvdata(mdev, NULL);
+fail:
        return error;
 }
diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
index 5c8a1bcf7ca7..e1480fb11de3 100644
--- a/drivers/input/keyboard/sh_keysc.c
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -219,6 +219,8 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
                  pdata->scan_timing, priv->iomem_base + KYCR1_OFFS);
        iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
        iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
+        device_init_wakeup(&pdev->dev, 1);
        return 0;
 err5:
        free_irq(irq, pdev);
@@ -253,17 +255,33 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
        return 0;
 }
+static int sh_keysc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
+        unsigned short value;
+        value = ioread16(priv->iomem_base + KYCR1_OFFS);
+        if (device_may_wakeup(dev))
+                value |= 0x80;
+        else
+                value &= ~0x80;
-#define sh_keysc_suspend NULL
+        iowrite16(value, priv->iomem_base + KYCR1_OFFS);
-#define sh_keysc_resume NULL
+        return 0;
+}
+static struct dev_pm_ops sh_keysc_dev_pm_ops = {
+        .suspend = sh_keysc_suspend,
+};
 struct platform_driver sh_keysc_device_driver = {
        .probe          = sh_keysc_probe,
        .remove         = __devexit_p(sh_keysc_remove),
-        .suspend        = sh_keysc_suspend,
-        .resume         = sh_keysc_resume,
        .driver         = {
                .name   = "sh_keysc",
+                .pm     = &sh_keysc_dev_pm_ops,
        }
 };
diff --git a/drivers/isdn/gigaset/ser-gigaset.c b/drivers/isdn/gigaset/ser-gigaset.c
index ac245e7e96a5..3071a52467ed 100644
--- a/drivers/isdn/gigaset/ser-gigaset.c
+++ b/drivers/isdn/gigaset/ser-gigaset.c
@@ -389,8 +389,7 @@ static void gigaset_freecshw(struct cardstate *cs)
 static void gigaset_device_release(struct device *dev)
 {
-        struct platform_device *pdev =
+        struct platform_device *pdev = to_platform_device(dev);
-                container_of(dev, struct platform_device, dev);
        /* adapted from platform_device_release() in drivers/base/platform.c */
        //FIXME is this actually necessary?
diff --git a/drivers/mca/mca-bus.c b/drivers/mca/mca-bus.c
index ef2dbfe74714..ada5ebbaa255 100644
--- a/drivers/mca/mca-bus.c
+++ b/drivers/mca/mca-bus.c
@@ -110,7 +110,7 @@ int __init mca_register_device(int bus, struct mca_device *mca_dev)
        mca_dev->dev.parent = &mca_bus->dev;
        mca_dev->dev.bus = &mca_bus_type;
-        sprintf (mca_dev->dev.bus_id, "%02d:%02X", bus, mca_dev->slot);
+        dev_set_name(&mca_dev->dev, "%02d:%02X", bus, mca_dev->slot);
        mca_dev->dma_mask = mca_bus->default_dma_mask;
        mca_dev->dev.dma_mask = &mca_dev->dma_mask;
        mca_dev->dev.coherent_dma_mask = mca_dev->dma_mask;
@@ -151,7 +151,7 @@ struct mca_bus * __devinit mca_attach_bus(int bus)
        if (!mca_bus)
                return NULL;
-        sprintf(mca_bus->dev.bus_id,"mca%d",bus);
+        dev_set_name(&mca_bus->dev, "mca%d", bus);
        sprintf(mca_bus->name,"Host %s MCA Bridge", bus ? "Secondary" : "Primary");
        if (device_register(&mca_bus->dev)) {
                kfree(mca_bus);
diff --git a/drivers/media/radio/radio-tea5764.c b/drivers/media/radio/radio-tea5764.c
index 4d35308fc1ff..393623818ade 100644
--- a/drivers/media/radio/radio-tea5764.c
+++ b/drivers/media/radio/radio-tea5764.c
@@ -298,7 +298,8 @@ static int vidioc_querycap(struct file *file, void  *priv,
        strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
        strlcpy(v->card, dev->name, sizeof(v->card));
-        snprintf(v->bus_info, sizeof(v->bus_info), "I2C:%s", dev->dev.bus_id);
+        snprintf(v->bus_info, sizeof(v->bus_info),
+                 "I2C:%s", dev_name(&dev->dev));
        v->version = RADIO_VERSION;
        v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
        return 0;
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index 66c755c116dc..ce98d955231a 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -803,9 +803,10 @@ static int __devinit cx88_audio_initdev(struct pci_dev *pci,
                return (-ENOENT);
        }
-        card = snd_card_new(index[devno], id[devno], THIS_MODULE, sizeof(snd_cx88_card_t));
+        err = snd_card_create(index[devno], id[devno], THIS_MODULE,
-        if (!card)
+                              sizeof(snd_cx88_card_t), &card);
-                return (-ENOMEM);
+        if (err < 0)
+                return err;
        card->private_free = snd_cx88_dev_free;
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
index 2ac738fa6a07..f132e31f6edd 100644
--- a/drivers/media/video/em28xx/em28xx-audio.c
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -448,9 +448,10 @@ static int em28xx_audio_init(struct em28xx *dev)
        printk(KERN_INFO "em28xx-audio.c: Copyright (C) 2006 Markus "
                         "Rechberger\n");
-        card = snd_card_new(index[devnr], "Em28xx Audio", THIS_MODULE, 0);
+        err = snd_card_create(index[devnr], "Em28xx Audio", THIS_MODULE, 0,
-        if (card == NULL)
+                              &card);
-                return -ENOMEM;
+        if (err < 0)
+                return err;
        spin_lock_init(&adev->slock);
        err = snd_pcm_new(card, "Em28xx Audio", 0, 0, 1, &pcm);
diff --git a/drivers/media/video/saa7134/saa7134-alsa.c b/drivers/media/video/saa7134/saa7134-alsa.c
index c750d3dd57d2..8b0b64a89874 100644
--- a/drivers/media/video/saa7134/saa7134-alsa.c
+++ b/drivers/media/video/saa7134/saa7134-alsa.c
@@ -990,10 +990,10 @@ static int alsa_card_saa7134_create(struct saa7134_dev *dev, int devnum)
        if (!enable[devnum])
                return -ENODEV;
-        card = snd_card_new(index[devnum], id[devnum], THIS_MODULE, sizeof(snd_card_saa7134_t));
+        err = snd_card_create(index[devnum], id[devnum], THIS_MODULE,
+                              sizeof(snd_card_saa7134_t), &card);
-        if (card == NULL)
+        if (err < 0)
-                return -ENOMEM;
+                return err;
        strcpy(card->driver, "SAA7134");
diff --git a/drivers/media/video/v4l2-device.c b/drivers/media/video/v4l2-device.c
index cf9d4c7f571a..8a4b74f3129f 100644
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@ -34,7 +34,7 @@ int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
        spin_lock_init(&v4l2_dev->lock);
        v4l2_dev->dev = dev;
        snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
-                        dev->driver->name, dev->bus_id);
+                        dev->driver->name, dev_name(dev));
        dev_set_drvdata(dev, v4l2_dev);
        return 0;
 }
diff --git a/drivers/mfd/mcp-core.c b/drivers/mfd/mcp-core.c
index 6063dc2b52e8..57271cb3b316 100644
--- a/drivers/mfd/mcp-core.c
+++ b/drivers/mfd/mcp-core.c
@@ -214,7 +214,7 @@ EXPORT_SYMBOL(mcp_host_alloc);
 int mcp_host_register(struct mcp *mcp)
 {
-        strcpy(mcp->attached_device.bus_id, "mcp0");
+        dev_set_name(&mcp->attached_device, "mcp0");
        return device_register(&mcp->attached_device);
 }
 EXPORT_SYMBOL(mcp_host_register);
diff --git a/drivers/mfd/ucb1x00-core.c b/drivers/mfd/ucb1x00-core.c
index 6860c924f364..fea9085fe52c 100644
--- a/drivers/mfd/ucb1x00-core.c
+++ b/drivers/mfd/ucb1x00-core.c
@@ -492,7 +492,7 @@ static int ucb1x00_probe(struct mcp *mcp)
        ucb->dev.class = &ucb1x00_class;
        ucb->dev.parent = &mcp->attached_device;
-        strlcpy(ucb->dev.bus_id, "ucb1x00", sizeof(ucb->dev.bus_id));
+        dev_set_name(&ucb->dev, "ucb1x00");
        spin_lock_init(&ucb->lock);
        spin_lock_init(&ucb->io_lock);
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 2b1196e6142c..e94e92001e7c 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -1603,7 +1603,7 @@ static int __init atmci_probe(struct platform_device *pdev)
        tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)host);
-        ret = request_irq(irq, atmci_interrupt, 0, pdev->dev.bus_id, host);
+        ret = request_irq(irq, atmci_interrupt, 0, dev_name(&pdev->dev), host);
        if (ret)
                goto err_request_irq;
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index fb2921f8099d..0c44d560bf1a 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -103,7 +103,7 @@ struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
                if (!gpio_is_valid(oms->gpios[i]))
                        continue;
-                ret = gpio_request(oms->gpios[i], dev->bus_id);
+                ret = gpio_request(oms->gpios[i], dev_name(dev));
                if (ret < 0) {
                        oms->gpios[i] = -EINVAL;
                        continue;
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 043d50fb6ef6..729f899a5cd5 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -551,5 +551,15 @@ config MTD_PLATRAM
          This selection automatically selects the map_ram driver.
-endmenu
+config MTD_VMU
+        tristate "Map driver for Dreamcast VMU"
+        depends on MAPLE
+        help
+          This driver enables access to the Dreamcast Visual Memory Unit (VMU).
+          Most Dreamcast users will want to say Y here.
+          To build this as a module select M here, the module will be called
+          vmu-flash.
+endmenu
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile
index 6d9ba35caf11..26b28a7a90b5 100644
--- a/drivers/mtd/maps/Makefile
+++ b/drivers/mtd/maps/Makefile
@@ -61,3 +61,4 @@ obj-$(CONFIG_MTD_PLATRAM)	+= plat-ram.o
 obj-$(CONFIG_MTD_OMAP_NOR)      += omap_nor.o
 obj-$(CONFIG_MTD_INTEL_VR_NOR)  += intel_vr_nor.o
 obj-$(CONFIG_MTD_BFIN_ASYNC)    += bfin-async-flash.o
+obj-$(CONFIG_MTD_VMU)           += vmu-flash.o
diff --git a/drivers/mtd/maps/pxa2xx-flash.c b/drivers/mtd/maps/pxa2xx-flash.c
index 771139c5bf87..e9026cb1c5b2 100644
--- a/drivers/mtd/maps/pxa2xx-flash.c
+++ b/drivers/mtd/maps/pxa2xx-flash.c
@@ -41,9 +41,8 @@ struct pxa2xx_flash_info {
 static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
-static int __init pxa2xx_flash_probe(struct device *dev)
+static int __init pxa2xx_flash_probe(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
        struct flash_platform_data *flash = pdev->dev.platform_data;
        struct pxa2xx_flash_info *info;
        struct mtd_partition *parts;
@@ -114,15 +113,15 @@ static int __init pxa2xx_flash_probe(struct device *dev)
                add_mtd_device(info->mtd);
        }
-        dev_set_drvdata(dev, info);
+        platform_set_drvdata(pdev, info);
        return 0;
 }
-static int __exit pxa2xx_flash_remove(struct device *dev)
+static int __exit pxa2xx_flash_remove(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 #ifdef CONFIG_MTD_PARTITIONS
        if (info->nr_parts)
@@ -141,9 +140,9 @@ static int __exit pxa2xx_flash_remove(struct device *dev)
 }
 #ifdef CONFIG_PM
-static int pxa2xx_flash_suspend(struct device *dev, pm_message_t state)
+static int pxa2xx_flash_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
        int ret = 0;
        if (info->mtd && info->mtd->suspend)
@@ -151,17 +150,17 @@ static int pxa2xx_flash_suspend(struct device *dev, pm_message_t state)
        return ret;
 }
-static int pxa2xx_flash_resume(struct device *dev)
+static int pxa2xx_flash_resume(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
        if (info->mtd && info->mtd->resume)
                info->mtd->resume(info->mtd);
        return 0;
 }
-static void pxa2xx_flash_shutdown(struct device *dev)
+static void pxa2xx_flash_shutdown(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
        if (info && info->mtd->suspend(info->mtd) == 0)
                info->mtd->resume(info->mtd);
@@ -172,11 +171,13 @@ static void pxa2xx_flash_shutdown(struct device *dev)
 #define pxa2xx_flash_shutdown NULL
 #endif
-static struct device_driver pxa2xx_flash_driver = {
+static struct platform_driver pxa2xx_flash_driver = {
-        .name           = "pxa2xx-flash",
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = "pxa2xx-flash",
+                .owner          = THIS_MODULE,
+        },
        .probe          = pxa2xx_flash_probe,
-        .remove         = __exit_p(pxa2xx_flash_remove),
+        .remove         = __devexit_p(pxa2xx_flash_remove),
        .suspend        = pxa2xx_flash_suspend,
        .resume         = pxa2xx_flash_resume,
        .shutdown       = pxa2xx_flash_shutdown,
@@ -184,12 +185,12 @@ static struct device_driver pxa2xx_flash_driver = {
 static int __init init_pxa2xx_flash(void)
 {
-        return driver_register(&pxa2xx_flash_driver);
+        return platform_driver_register(&pxa2xx_flash_driver);
 }
 static void __exit cleanup_pxa2xx_flash(void)
 {
-        driver_unregister(&pxa2xx_flash_driver);
+        platform_driver_unregister(&pxa2xx_flash_driver);
 }
 module_init(init_pxa2xx_flash);
diff --git a/drivers/mtd/maps/vmu-flash.c b/drivers/mtd/maps/vmu-flash.c
new file mode 100644
index 000000000000..1f73297e7776
--- /dev/null
+++ b/drivers/mtd/maps/vmu-flash.c
@@ -0,0 +1,832 @@
+/* vmu-flash.c
+ * Driver for SEGA Dreamcast Visual Memory Unit
+ *
+ * Copyright (c) Adrian McMenamin 2002 - 2009
+ * Copyright (c) Paul Mundt 2001
+ *
+ * Licensed under version 2 of the
+ * GNU General Public Licence
+ */
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/maple.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/map.h>
+struct vmu_cache {
+        unsigned char *buffer;          /* Cache */
+        unsigned int block;             /* Which block was cached */
+        unsigned long jiffies_atc;      /* When was it cached? */
+        int valid;
+};
+struct mdev_part {
+        struct maple_device *mdev;
+        int partition;
+};
+struct vmupart {
+        u16 user_blocks;
+        u16 root_block;
+        u16 numblocks;
+        char *name;
+        struct vmu_cache *pcache;
+};
+struct memcard {
+        u16 tempA;
+        u16 tempB;
+        u32 partitions;
+        u32 blocklen;
+        u32 writecnt;
+        u32 readcnt;
+        u32 removeable;
+        int partition;
+        int read;
+        unsigned char *blockread;
+        struct vmupart *parts;
+        struct mtd_info *mtd;
+};
+struct vmu_block {
+        unsigned int num; /* block number */
+        unsigned int ofs; /* block offset */
+};
+static struct vmu_block *ofs_to_block(unsigned long src_ofs,
+        struct mtd_info *mtd, int partition)
+{
+        struct vmu_block *vblock;
+        struct maple_device *mdev;
+        struct memcard *card;
+        struct mdev_part *mpart;
+        int num;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        card = maple_get_drvdata(mdev);
+        if (src_ofs >= card->parts[partition].numblocks * card->blocklen)
+                goto failed;
+        num = src_ofs / card->blocklen;
+        if (num > card->parts[partition].numblocks)
+                goto failed;
+        vblock = kmalloc(sizeof(struct vmu_block), GFP_KERNEL);
+        if (!vblock)
+                goto failed;
+        vblock->num = num;
+        vblock->ofs = src_ofs % card->blocklen;
+        return vblock;
+failed:
+        return NULL;
+}
+/* Maple bus callback function for reads */
+static void vmu_blockread(struct mapleq *mq)
+{
+        struct maple_device *mdev;
+        struct memcard *card;
+        mdev = mq->dev;
+        card = maple_get_drvdata(mdev);
+        /* copy the read in data */
+        if (unlikely(!card->blockread))
+                return;
+        memcpy(card->blockread, mq->recvbuf->buf + 12,
+                card->blocklen/card->readcnt);
+}
+/* Interface with maple bus to read blocks
+ * caching the results so that other parts
+ * of the driver can access block reads */
+static int maple_vmu_read_block(unsigned int num, unsigned char *buf,
+        struct mtd_info *mtd)
+{
+        struct memcard *card;
+        struct mdev_part *mpart;
+        struct maple_device *mdev;
+        int partition, error = 0, x, wait;
+        unsigned char *blockread = NULL;
+        struct vmu_cache *pcache;
+        __be32 sendbuf;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        partition = mpart->partition;
+        card = maple_get_drvdata(mdev);
+        pcache = card->parts[partition].pcache;
+        pcache->valid = 0;
+        /* prepare the cache for this block */
+        if (!pcache->buffer) {
+                pcache->buffer = kmalloc(card->blocklen, GFP_KERNEL);
+                if (!pcache->buffer) {
+                        dev_err(&mdev->dev, "VMU at (%d, %d) - read fails due"
+                                " to lack of memory\n", mdev->port,
+                                mdev->unit);
+                        error = -ENOMEM;
+                        goto outB;
+                }
+        }
+        /*
+        * Reads may be phased - again the hardware spec
+        * supports this - though may not be any devices in
+        * the wild that implement it, but we will here
+        */
+        for (x = 0; x < card->readcnt; x++) {
+                sendbuf = cpu_to_be32(partition << 24 | x << 16 | num);
+                if (atomic_read(&mdev->busy) == 1) {
+                        wait_event_interruptible_timeout(mdev->maple_wait,
+                                atomic_read(&mdev->busy) == 0, HZ);
+                        if (atomic_read(&mdev->busy) == 1) {
+                                dev_notice(&mdev->dev, "VMU at (%d, %d)"
+                                        " is busy\n", mdev->port, mdev->unit);
+                                error = -EAGAIN;
+                                goto outB;
+                        }
+                }
+                atomic_set(&mdev->busy, 1);
+                blockread = kmalloc(card->blocklen/card->readcnt, GFP_KERNEL);
+                if (!blockread) {
+                        error = -ENOMEM;
+                        atomic_set(&mdev->busy, 0);
+                        goto outB;
+                }
+                card->blockread = blockread;
+                maple_getcond_callback(mdev, vmu_blockread, 0,
+                        MAPLE_FUNC_MEMCARD);
+                error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
+                                MAPLE_COMMAND_BREAD, 2, &sendbuf);
+                /* Very long timeouts seem to be needed when box is stressed */
+                wait = wait_event_interruptible_timeout(mdev->maple_wait,
+                        (atomic_read(&mdev->busy) == 0 ||
+                        atomic_read(&mdev->busy) == 2), HZ * 3);
+                /*
+                * MTD layer does not handle hotplugging well
+                * so have to return errors when VMU is unplugged
+                * in the middle of a read (busy == 2)
+                */
+                if (error || atomic_read(&mdev->busy) == 2) {
+                        if (atomic_read(&mdev->busy) == 2)
+                                error = -ENXIO;
+                        atomic_set(&mdev->busy, 0);
+                        card->blockread = NULL;
+                        goto outA;
+                }
+                if (wait == 0 || wait == -ERESTARTSYS) {
+                        card->blockread = NULL;
+                        atomic_set(&mdev->busy, 0);
+                        error = -EIO;
+                        list_del_init(&(mdev->mq->list));
+                        kfree(mdev->mq->sendbuf);
+                        mdev->mq->sendbuf = NULL;
+                        if (wait == -ERESTARTSYS) {
+                                dev_warn(&mdev->dev, "VMU read on (%d, %d)"
+                                        " interrupted on block 0x%X\n",
+                                        mdev->port, mdev->unit, num);
+                        } else
+                                dev_notice(&mdev->dev, "VMU read on (%d, %d)"
+                                        " timed out on block 0x%X\n",
+                                        mdev->port, mdev->unit, num);
+                        goto outA;
+                }
+                memcpy(buf + (card->blocklen/card->readcnt) * x, blockread,
+                        card->blocklen/card->readcnt);
+                memcpy(pcache->buffer + (card->blocklen/card->readcnt) * x,
+                        card->blockread, card->blocklen/card->readcnt);
+                card->blockread = NULL;
+                pcache->block = num;
+                pcache->jiffies_atc = jiffies;
+                pcache->valid = 1;
+                kfree(blockread);
+        }
+        return error;
+outA:
+        kfree(blockread);
+outB:
+        return error;
+}
+/* communicate with maple bus for phased writing */
+static int maple_vmu_write_block(unsigned int num, const unsigned char *buf,
+        struct mtd_info *mtd)
+{
+        struct memcard *card;
+        struct mdev_part *mpart;
+        struct maple_device *mdev;
+        int partition, error, locking, x, phaselen, wait;
+        __be32 *sendbuf;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        partition = mpart->partition;
+        card = maple_get_drvdata(mdev);
+        phaselen = card->blocklen/card->writecnt;
+        sendbuf = kmalloc(phaselen + 4, GFP_KERNEL);
+        if (!sendbuf) {
+                error = -ENOMEM;
+                goto fail_nosendbuf;
+        }
+        for (x = 0; x < card->writecnt; x++) {
+                sendbuf[0] = cpu_to_be32(partition << 24 | x << 16 | num);
+                memcpy(&sendbuf[1], buf + phaselen * x, phaselen);
+                /* wait until the device is not busy doing something else
+                * or 1 second - which ever is longer */
+                if (atomic_read(&mdev->busy) == 1) {
+                        wait_event_interruptible_timeout(mdev->maple_wait,
+                                atomic_read(&mdev->busy) == 0, HZ);
+                        if (atomic_read(&mdev->busy) == 1) {
+                                error = -EBUSY;
+                                dev_notice(&mdev->dev, "VMU write at (%d, %d)"
+                                        "failed - device is busy\n",
+                                        mdev->port, mdev->unit);
+                                goto fail_nolock;
+                        }
+                }
+                atomic_set(&mdev->busy, 1);
+                locking = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
+                        MAPLE_COMMAND_BWRITE, phaselen / 4 + 2, sendbuf);
+                wait = wait_event_interruptible_timeout(mdev->maple_wait,
+                        atomic_read(&mdev->busy) == 0, HZ/10);
+                if (locking) {
+                        error = -EIO;
+                        atomic_set(&mdev->busy, 0);
+                        goto fail_nolock;
+                }
+                if (atomic_read(&mdev->busy) == 2) {
+                        atomic_set(&mdev->busy, 0);
+                } else if (wait == 0 || wait == -ERESTARTSYS) {
+                        error = -EIO;
+                        dev_warn(&mdev->dev, "Write at (%d, %d) of block"
+                                " 0x%X at phase %d failed: could not"
+                                " communicate with VMU", mdev->port,
+                                mdev->unit, num, x);
+                        atomic_set(&mdev->busy, 0);
+                        kfree(mdev->mq->sendbuf);
+                        mdev->mq->sendbuf = NULL;
+                        list_del_init(&(mdev->mq->list));
+                        goto fail_nolock;
+                }
+        }
+        kfree(sendbuf);
+        return card->blocklen;
+fail_nolock:
+        kfree(sendbuf);
+fail_nosendbuf:
+        dev_err(&mdev->dev, "VMU (%d, %d): write failed\n", mdev->port,
+                mdev->unit);
+        return error;
+}
+/* mtd function to simulate reading byte by byte */
+static unsigned char vmu_flash_read_char(unsigned long ofs, int *retval,
+        struct mtd_info *mtd)
+{
+        struct vmu_block *vblock;
+        struct memcard *card;
+        struct mdev_part *mpart;
+        struct maple_device *mdev;
+        unsigned char *buf, ret;
+        int partition, error;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        partition = mpart->partition;
+        card = maple_get_drvdata(mdev);
+        *retval =  0;
+        buf = kmalloc(card->blocklen, GFP_KERNEL);
+        if (!buf) {
+                *retval = 1;
+                ret = -ENOMEM;
+                goto finish;
+        }
+        vblock = ofs_to_block(ofs, mtd, partition);
+        if (!vblock) {
+                *retval = 3;
+                ret = -ENOMEM;
+                goto out_buf;
+        }
+        error = maple_vmu_read_block(vblock->num, buf, mtd);
+        if (error) {
+                ret = error;
+                *retval = 2;
+                goto out_vblock;
+        }
+        ret = buf[vblock->ofs];
+out_vblock:
+        kfree(vblock);
+out_buf:
+        kfree(buf);
+finish:
+        return ret;
+}
+/* mtd higher order function to read flash */
+static int vmu_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
+        size_t *retlen,  u_char *buf)
+{
+        struct maple_device *mdev;
+        struct memcard *card;
+        struct mdev_part *mpart;
+        struct vmu_cache *pcache;
+        struct vmu_block *vblock;
+        int index = 0, retval, partition, leftover, numblocks;
+        unsigned char cx;
+        if (len < 1)
+                return -EIO;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        partition = mpart->partition;
+        card = maple_get_drvdata(mdev);
+        numblocks = card->parts[partition].numblocks;
+        if (from + len > numblocks * card->blocklen)
+                len = numblocks * card->blocklen - from;
+        if (len == 0)
+                return -EIO;
+        /* Have we cached this bit already? */
+        pcache = card->parts[partition].pcache;
+        do {
+                vblock =  ofs_to_block(from + index, mtd, partition);
+                if (!vblock)
+                        return -ENOMEM;
+                /* Have we cached this and is the cache valid and timely? */
+                if (pcache->valid &&
+                        time_before(jiffies, pcache->jiffies_atc + HZ) &&
+                        (pcache->block == vblock->num)) {
+                        /* we have cached it, so do necessary copying */
+                        leftover = card->blocklen - vblock->ofs;
+                        if (vblock->ofs + len - index < card->blocklen) {
+                                /* only a bit of this block to copy */
+                                memcpy(buf + index,
+                                        pcache->buffer + vblock->ofs,
+                                        len - index);
+                                index = len;
+                        } else {
+                                /* otherwise copy remainder of whole block */
+                                memcpy(buf + index, pcache->buffer +
+                                        vblock->ofs, leftover);
+                                index += leftover;
+                        }
+                } else {
+                        /*
+                        * Not cached so read one byte -
+                        * but cache the rest of the block
+                        */
+                        cx = vmu_flash_read_char(from + index, &retval, mtd);
+                        if (retval) {
+                                *retlen = index;
+                                kfree(vblock);
+                                return cx;
+                        }
+                        memset(buf + index, cx, 1);
+                        index++;
+                }
+                kfree(vblock);
+        } while (len > index);
+        *retlen = index;
+        return 0;
+}
+static int vmu_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
+        size_t *retlen, const u_char *buf)
+{
+        struct maple_device *mdev;
+        struct memcard *card;
+        struct mdev_part *mpart;
+        int index = 0, partition, error = 0, numblocks;
+        struct vmu_cache *pcache;
+        struct vmu_block *vblock;
+        unsigned char *buffer;
+        mpart = mtd->priv;
+        mdev = mpart->mdev;
+        partition = mpart->partition;
+        card = maple_get_drvdata(mdev);
+        /* simple sanity checks */
+        if (len < 1) {
+                error = -EIO;
+                goto failed;
+        }
+        numblocks = card->parts[partition].numblocks;
+        if (to + len > numblocks * card->blocklen)
+                len = numblocks * card->blocklen - to;
+        if (len == 0) {
+                error = -EIO;
+                goto failed;
+        }
+        vblock = ofs_to_block(to, mtd, partition);
+        if (!vblock) {
+                error = -ENOMEM;
+                goto failed;
+        }
+        buffer = kmalloc(card->blocklen, GFP_KERNEL);
+        if (!buffer) {
+                error = -ENOMEM;
+                goto fail_buffer;
+        }
+        do {
+                /* Read in the block we are to write to */
+                error = maple_vmu_read_block(vblock->num, buffer, mtd);
+                if (error)
+                        goto fail_io;
+                do {
+                        buffer[vblock->ofs] = buf[index];
+                        vblock->ofs++;
+                        index++;
+                        if (index >= len)
+                                break;
+                } while (vblock->ofs < card->blocklen);
+                /* write out new buffer */
+                error = maple_vmu_write_block(vblock->num, buffer, mtd);
+                /* invalidate the cache */
+                pcache = card->parts[partition].pcache;
+                pcache->valid = 0;
+                if (error != card->blocklen)
+                        goto fail_io;
+                vblock->num++;
+                vblock->ofs = 0;
+        } while (len > index);
+        kfree(buffer);
+        *retlen = index;
+        kfree(vblock);
+        return 0;
+fail_io:
+        kfree(buffer);
+fail_buffer:
+        kfree(vblock);
+failed:
+        dev_err(&mdev->dev, "VMU write failing with error %d\n", error);
+        return error;
+}
+static void vmu_flash_sync(struct mtd_info *mtd)
+{
+        /* Do nothing here */
+}
+/* Maple bus callback function to recursively query hardware details */
+static void vmu_queryblocks(struct mapleq *mq)
+{
+        struct maple_device *mdev;
+        unsigned short *res;
+        struct memcard *card;
+        __be32 partnum;
+        struct vmu_cache *pcache;
+        struct mdev_part *mpart;
+        struct mtd_info *mtd_cur;
+        struct vmupart *part_cur;
+        int error;
+        mdev = mq->dev;
+        card = maple_get_drvdata(mdev);
+        res = (unsigned short *) (mq->recvbuf->buf);
+        card->tempA = res[12];
+        card->tempB = res[6];
+        dev_info(&mdev->dev, "VMU device at partition %d has %d user "
+                "blocks with a root block at %d\n", card->partition,
+                card->tempA, card->tempB);
+        part_cur = &card->parts[card->partition];
+        part_cur->user_blocks = card->tempA;
+        part_cur->root_block = card->tempB;
+        part_cur->numblocks = card->tempB + 1;
+        part_cur->name = kmalloc(12, GFP_KERNEL);
+        if (!part_cur->name)
+                goto fail_name;
+        sprintf(part_cur->name, "vmu%d.%d.%d",
+                mdev->port, mdev->unit, card->partition);
+        mtd_cur = &card->mtd[card->partition];
+        mtd_cur->name = part_cur->name;
+        mtd_cur->type = 8;
+        mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE;
+        mtd_cur->size = part_cur->numblocks * card->blocklen;
+        mtd_cur->erasesize = card->blocklen;
+        mtd_cur->write = vmu_flash_write;
+        mtd_cur->read = vmu_flash_read;
+        mtd_cur->sync = vmu_flash_sync;
+        mtd_cur->writesize = card->blocklen;
+        mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);
+        if (!mpart)
+                goto fail_mpart;
+        mpart->mdev = mdev;
+        mpart->partition = card->partition;
+        mtd_cur->priv = mpart;
+        mtd_cur->owner = THIS_MODULE;
+        pcache = kzalloc(sizeof(struct vmu_cache), GFP_KERNEL);
+        if (!pcache)
+                goto fail_cache_create;
+        part_cur->pcache = pcache;
+        error = add_mtd_device(mtd_cur);
+        if (error)
+                goto fail_mtd_register;
+        maple_getcond_callback(mdev, NULL, 0,
+                MAPLE_FUNC_MEMCARD);
+        /*
+        * Set up a recursive call to the (probably theoretical)
+        * second or more partition
+        */
+        if (++card->partition < card->partitions) {
+                partnum = cpu_to_be32(card->partition << 24);
+                maple_getcond_callback(mdev, vmu_queryblocks, 0,
+                        MAPLE_FUNC_MEMCARD);
+                maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
+                        MAPLE_COMMAND_GETMINFO, 2, &partnum);
+        }
+        return;
+fail_mtd_register:
+        dev_err(&mdev->dev, "Could not register maple device at (%d, %d)"
+                "error is 0x%X\n", mdev->port, mdev->unit, error);
+        for (error = 0; error <= card->partition; error++) {
+                kfree(((card->parts)[error]).pcache);
+                ((card->parts)[error]).pcache = NULL;
+        }
+fail_cache_create:
+fail_mpart:
+        for (error = 0; error <= card->partition; error++) {
+                kfree(((card->mtd)[error]).priv);
+                ((card->mtd)[error]).priv = NULL;
+        }
+        maple_getcond_callback(mdev, NULL, 0,
+                MAPLE_FUNC_MEMCARD);
+        kfree(part_cur->name);
+fail_name:
+        return;
+}
+/* Handles very basic info about the flash, queries for details */
+static int __devinit vmu_connect(struct maple_device *mdev)
+{
+        unsigned long test_flash_data, basic_flash_data;
+        int c, error;
+        struct memcard *card;
+        u32 partnum = 0;
+        test_flash_data = be32_to_cpu(mdev->devinfo.function);
+        /* Need to count how many bits are set - to find out which
+         * function_data element has details of the memory card:
+         * using Brian Kernighan's/Peter Wegner's method */
+        for (c = 0; test_flash_data; c++)
+                test_flash_data &= test_flash_data - 1;
+        basic_flash_data = be32_to_cpu(mdev->devinfo.function_data[c - 1]);
+        card = kmalloc(sizeof(struct memcard), GFP_KERNEL);
+        if (!card) {
+                error = ENOMEM;
+                goto fail_nomem;
+        }
+        card->partitions = (basic_flash_data >> 24 & 0xFF) + 1;
+        card->blocklen = ((basic_flash_data >> 16 & 0xFF) + 1) << 5;
+        card->writecnt = basic_flash_data >> 12 & 0xF;
+        card->readcnt = basic_flash_data >> 8 & 0xF;
+        card->removeable = basic_flash_data >> 7 & 1;
+        card->partition = 0;
+        /*
+        * Not sure there are actually any multi-partition devices in the
+        * real world, but the hardware supports them, so, so will we
+        */
+        card->parts = kmalloc(sizeof(struct vmupart) * card->partitions,
+                GFP_KERNEL);
+        if (!card->parts) {
+                error = -ENOMEM;
+                goto fail_partitions;
+        }
+        card->mtd = kmalloc(sizeof(struct mtd_info) * card->partitions,
+                GFP_KERNEL);
+        if (!card->mtd) {
+                error = -ENOMEM;
+                goto fail_mtd_info;
+        }
+        maple_set_drvdata(mdev, card);
+        /*
+        * We want to trap meminfo not get cond
+        * so set interval to zero, but rely on maple bus
+        * driver to pass back the results of the meminfo
+        */
+        maple_getcond_callback(mdev, vmu_queryblocks, 0,
+                MAPLE_FUNC_MEMCARD);
+        /* Make sure we are clear to go */
+        if (atomic_read(&mdev->busy) == 1) {
+                wait_event_interruptible_timeout(mdev->maple_wait,
+                        atomic_read(&mdev->busy) == 0, HZ);
+                if (atomic_read(&mdev->busy) == 1) {
+                        dev_notice(&mdev->dev, "VMU at (%d, %d) is busy\n",
+                                mdev->port, mdev->unit);
+                        error = -EAGAIN;
+                        goto fail_device_busy;
+                }
+        }
+        atomic_set(&mdev->busy, 1);
+        /*
+        * Set up the minfo call: vmu_queryblocks will handle
+        * the information passed back
+        */
+        error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
+                MAPLE_COMMAND_GETMINFO, 2, &partnum);
+        if (error) {
+                dev_err(&mdev->dev, "Could not lock VMU at (%d, %d)"
+                        " error is 0x%X\n", mdev->port, mdev->unit, error);
+                goto fail_mtd_info;
+        }
+        return 0;
+fail_device_busy:
+        kfree(card->mtd);
+fail_mtd_info:
+        kfree(card->parts);
+fail_partitions:
+        kfree(card);
+fail_nomem:
+        return error;
+}
+static void __devexit vmu_disconnect(struct maple_device *mdev)
+{
+        struct memcard *card;
+        struct mdev_part *mpart;
+        int x;
+        mdev->callback = NULL;
+        card = maple_get_drvdata(mdev);
+        for (x = 0; x < card->partitions; x++) {
+                mpart = ((card->mtd)[x]).priv;
+                mpart->mdev = NULL;
+                del_mtd_device(&((card->mtd)[x]));
+                kfree(((card->parts)[x]).name);
+        }
+        kfree(card->parts);
+        kfree(card->mtd);
+        kfree(card);
+}
+/* Callback to handle eccentricities of both mtd subsystem
+ * and general flakyness of Dreamcast VMUs
+ */
+static int vmu_can_unload(struct maple_device *mdev)
+{
+        struct memcard *card;
+        int x;
+        struct mtd_info *mtd;
+        card = maple_get_drvdata(mdev);
+        for (x = 0; x < card->partitions; x++) {
+                mtd = &((card->mtd)[x]);
+                if (mtd->usecount > 0)
+                        return 0;
+        }
+        return 1;
+}
+#define ERRSTR "VMU at (%d, %d) file error -"
+static void vmu_file_error(struct maple_device *mdev, void *recvbuf)
+{
+        enum maple_file_errors error = ((int *)recvbuf)[1];
+        switch (error) {
+        case MAPLE_FILEERR_INVALID_PARTITION:
+                dev_notice(&mdev->dev, ERRSTR " invalid partition number\n",
+                        mdev->port, mdev->unit);
+                break;
+        case MAPLE_FILEERR_PHASE_ERROR:
+                dev_notice(&mdev->dev, ERRSTR " phase error\n",
+                        mdev->port, mdev->unit);
+                break;
+        case MAPLE_FILEERR_INVALID_BLOCK:
+                dev_notice(&mdev->dev, ERRSTR " invalid block number\n",
+                        mdev->port, mdev->unit);
+                break;
+        case MAPLE_FILEERR_WRITE_ERROR:
+                dev_notice(&mdev->dev, ERRSTR " write error\n",
+                        mdev->port, mdev->unit);
+                break;
+        case MAPLE_FILEERR_INVALID_WRITE_LENGTH:
+                dev_notice(&mdev->dev, ERRSTR " invalid write length\n",
+                        mdev->port, mdev->unit);
+                break;
+        case MAPLE_FILEERR_BAD_CRC:
+                dev_notice(&mdev->dev, ERRSTR " bad CRC\n",
+                        mdev->port, mdev->unit);
+                break;
+        default:
+                dev_notice(&mdev->dev, ERRSTR " 0x%X\n",
+                        mdev->port, mdev->unit, error);
+        }
+}
+static int __devinit probe_maple_vmu(struct device *dev)
+{
+        int error;
+        struct maple_device *mdev = to_maple_dev(dev);
+        struct maple_driver *mdrv = to_maple_driver(dev->driver);
+        mdev->can_unload = vmu_can_unload;
+        mdev->fileerr_handler = vmu_file_error;
+        mdev->driver = mdrv;
+        error = vmu_connect(mdev);
+        if (error)
+                return error;
+        return 0;
+}
+static int __devexit remove_maple_vmu(struct device *dev)
+{
+        struct maple_device *mdev = to_maple_dev(dev);
+        vmu_disconnect(mdev);
+        return 0;
+}
+static struct maple_driver vmu_flash_driver = {
+        .function =     MAPLE_FUNC_MEMCARD,
+        .drv = {
+                .name =         "Dreamcast_visual_memory",
+                .probe =        probe_maple_vmu,
+                .remove =       __devexit_p(remove_maple_vmu),
+        },
+};
+static int __init vmu_flash_map_init(void)
+{
+        return maple_driver_register(&vmu_flash_driver);
+}
+static void __exit vmu_flash_map_exit(void)
+{
+        maple_driver_unregister(&vmu_flash_driver);
+}
+module_init(vmu_flash_map_init);
+module_exit(vmu_flash_map_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Adrian McMenamin");
+MODULE_DESCRIPTION("Flash mapping for Sega Dreamcast visual memory");
diff --git a/drivers/mtd/nand/excite_nandflash.c b/drivers/mtd/nand/excite_nandflash.c
index ced14b5294d5..72446fb48d4b 100644
--- a/drivers/mtd/nand/excite_nandflash.c
+++ b/drivers/mtd/nand/excite_nandflash.c
@@ -128,11 +128,11 @@ static int excite_nand_devready(struct mtd_info *mtd)
 * The binding to the mtd and all allocated
 * resources are released.
 */
-static int __exit excite_nand_remove(struct device *dev)
+static int __exit excite_nand_remove(struct platform_device *dev)
 {
-        struct excite_nand_drvdata * const this = dev_get_drvdata(dev);
+        struct excite_nand_drvdata * const this = platform_get_drvdata(dev);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
        if (unlikely(!this)) {
                printk(KERN_ERR "%s: called %s without private data!!",
@@ -159,9 +159,8 @@ static int __exit excite_nand_remove(struct device *dev)
 * it can allocate all necessary resources then calls the
 * nand layer to look for devices.
 */
-static int __init excite_nand_probe(struct device *dev)
+static int __init excite_nand_probe(struct platform_device *pdev)
 {
-        struct platform_device * const pdev = to_platform_device(dev);
        struct excite_nand_drvdata *drvdata;    /* private driver data */
        struct nand_chip *board_chip;   /* private flash chip data */
        struct mtd_info *board_mtd;     /* mtd info for this board */
@@ -175,7 +174,7 @@ static int __init excite_nand_probe(struct device *dev)
        }
        /* bind private data into driver */
-        dev_set_drvdata(dev, drvdata);
+        platform_set_drvdata(pdev, drvdata);
        /* allocate and map the resource */
        drvdata->regs =
@@ -219,23 +218,25 @@ static int __init excite_nand_probe(struct device *dev)
        return 0;
 }
-static struct device_driver excite_nand_driver = {
+static struct platform_driver excite_nand_driver = {
-        .name = "excite_nand",
+        .driver = {
-        .bus = &platform_bus_type,
+                .name = "excite_nand",
+                .owner          = THIS_MODULE,
+        },
        .probe = excite_nand_probe,
-        .remove = __exit_p(excite_nand_remove)
+        .remove = __devexit_p(excite_nand_remove)
 };
 static int __init excite_nand_init(void)
 {
        pr_info("Basler eXcite nand flash driver Version "
                EXCITE_NANDFLASH_VERSION "\n");
-        return driver_register(&excite_nand_driver);
+        return platform_driver_register(&excite_nand_driver);
 }
 static void __exit excite_nand_exit(void)
 {
-        driver_unregister(&excite_nand_driver);
+        platform_driver_unregister(&excite_nand_driver);
 }
 module_init(excite_nand_init);
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index 582cf80f555a..89bf85af642c 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -187,7 +187,7 @@ static int ndfc_chip_init(struct ndfc_controller *ndfc,
                return -ENODEV;
        ndfc->mtd.name = kasprintf(GFP_KERNEL, "%s.%s",
-                                   ndfc->ofdev->dev.bus_id, flash_np->name);
+                        dev_name(&ndfc->ofdev->dev), flash_np->name);
        if (!ndfc->mtd.name) {
                ret = -ENOMEM;
                goto err;
diff --git a/drivers/mtd/onenand/generic.c b/drivers/mtd/onenand/generic.c
index 5b69e7773c6c..3a496c33fb52 100644
--- a/drivers/mtd/onenand/generic.c
+++ b/drivers/mtd/onenand/generic.c
@@ -36,10 +36,9 @@ struct onenand_info {
        struct onenand_chip     onenand;
 };
-static int __devinit generic_onenand_probe(struct device *dev)
+static int __devinit generic_onenand_probe(struct platform_device *pdev)
 {
        struct onenand_info *info;
-        struct platform_device *pdev = to_platform_device(dev);
        struct flash_platform_data *pdata = pdev->dev.platform_data;
        struct resource *res = pdev->resource;
        unsigned long size = res->end - res->start + 1;
@@ -49,7 +48,7 @@ static int __devinit generic_onenand_probe(struct device *dev)
        if (!info)
                return -ENOMEM;
-        if (!request_mem_region(res->start, size, dev->driver->name)) {
+        if (!request_mem_region(res->start, size, pdev->dev.driver->name)) {
                err = -EBUSY;
                goto out_free_info;
        }
@@ -82,7 +81,7 @@ static int __devinit generic_onenand_probe(struct device *dev)
 #endif
                err = add_mtd_device(&info->mtd);
-        dev_set_drvdata(&pdev->dev, info);
+        platform_set_drvdata(pdev, info);
        return 0;
@@ -96,14 +95,13 @@ out_free_info:
        return err;
 }
-static int __devexit generic_onenand_remove(struct device *dev)
+static int __devexit generic_onenand_remove(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
+        struct onenand_info *info = platform_get_drvdata(pdev);
-        struct onenand_info *info = dev_get_drvdata(&pdev->dev);
        struct resource *res = pdev->resource;
        unsigned long size = res->end - res->start + 1;
-        dev_set_drvdata(&pdev->dev, NULL);
+        platform_set_drvdata(pdev, NULL);
        if (info) {
                if (info->parts)
@@ -120,9 +118,11 @@ static int __devexit generic_onenand_remove(struct device *dev)
        return 0;
 }
-static struct device_driver generic_onenand_driver = {
+static struct platform_driver generic_onenand_driver = {
-        .name           = DRIVER_NAME,
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = DRIVER_NAME,
+                .owner          = THIS_MODULE,
+        },
        .probe          = generic_onenand_probe,
        .remove         = __devexit_p(generic_onenand_remove),
 };
@@ -131,12 +131,12 @@ MODULE_ALIAS(DRIVER_NAME);
 static int __init generic_onenand_init(void)
 {
-        return driver_register(&generic_onenand_driver);
+        return platform_driver_register(&generic_onenand_driver);
 }
 static void __exit generic_onenand_exit(void)
 {
-        driver_unregister(&generic_onenand_driver);
+        platform_driver_unregister(&generic_onenand_driver);
 }
 module_init(generic_onenand_init);
diff --git a/drivers/net/arm/ks8695net.c b/drivers/net/arm/ks8695net.c
index f3a127434897..35cd264abae7 100644
--- a/drivers/net/arm/ks8695net.c
+++ b/drivers/net/arm/ks8695net.c
@@ -1059,7 +1059,7 @@ ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
 {
        strlcpy(info->driver, MODULENAME, sizeof(info->driver));
        strlcpy(info->version, MODULEVERSION, sizeof(info->version));
-        strlcpy(info->bus_info, ndev->dev.parent->bus_id,
+        strlcpy(info->bus_info, dev_name(ndev->dev.parent),
                sizeof(info->bus_info));
 }
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index 9c875bb3f76c..79aec32c6add 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -355,8 +355,8 @@ static int mii_probe (struct net_device *dev)
        /* now we are supposed to have a proper phydev, to attach to... */
        BUG_ON(phydev->attached_dev);
-        phydev = phy_connect(dev, phydev->dev.bus_id, &au1000_adjust_link, 0,
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &au1000_adjust_link,
-                        PHY_INTERFACE_MODE_MII);
+                        0, PHY_INTERFACE_MODE_MII);
        if (IS_ERR(phydev)) {
                printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
@@ -381,8 +381,8 @@ static int mii_probe (struct net_device *dev)
        aup->phy_dev = phydev;
        printk(KERN_INFO "%s: attached PHY driver [%s] "
-               "(mii_bus:phy_addr=%s, irq=%d)\n",
+               "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
-               dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+               phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
        return 0;
 }
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 78e31aa861e0..9afe8092dfc4 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -415,11 +415,11 @@ static int mii_probe(struct net_device *dev)
        }
 #if defined(CONFIG_BFIN_MAC_RMII)
-        phydev = phy_connect(dev, phydev->dev.bus_id, &bfin_mac_adjust_link, 0,
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &bfin_mac_adjust_link,
-                        PHY_INTERFACE_MODE_RMII);
+                        0, PHY_INTERFACE_MODE_RMII);
 #else
-        phydev = phy_connect(dev, phydev->dev.bus_id, &bfin_mac_adjust_link, 0,
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &bfin_mac_adjust_link,
-                        PHY_INTERFACE_MODE_MII);
+                        0, PHY_INTERFACE_MODE_MII);
 #endif
        if (IS_ERR(phydev)) {
@@ -447,7 +447,7 @@ static int mii_probe(struct net_device *dev)
        printk(KERN_INFO "%s: attached PHY driver [%s] "
               "(mii_bus:phy_addr=%s, irq=%d, mdc_clk=%dHz(mdc_div=%d)"
               "@sclk=%dMHz)\n",
-               DRV_NAME, phydev->drv->name, phydev->dev.bus_id, phydev->irq,
+               DRV_NAME, phydev->drv->name, dev_name(&phydev->dev), phydev->irq,
               MDC_CLK, mdc_div, sclk/1000000);
        return 0;
@@ -488,7 +488,7 @@ static void bfin_mac_ethtool_getdrvinfo(struct net_device *dev,
        strcpy(info->driver, DRV_NAME);
        strcpy(info->version, DRV_VERSION);
        strcpy(info->fw_version, "N/A");
-        strcpy(info->bus_info, dev->dev.bus_id);
+        strcpy(info->bus_info, dev_name(&dev->dev));
 }
 static struct ethtool_ops bfin_mac_ethtool_ops = {
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 8a546a33d581..1ab58375d061 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1240,7 +1240,7 @@ static void bmac_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *inf
 {
        struct bmac_data *bp = netdev_priv(dev);
        strcpy(info->driver, "bmac");
-        strcpy(info->bus_info, bp->mdev->ofdev.dev.bus_id);
+        strcpy(info->bus_info, dev_name(&bp->mdev->ofdev.dev));
 }
 static const struct ethtool_ops bmac_ethtool_ops = {
diff --git a/drivers/net/cpmac.c b/drivers/net/cpmac.c
index f66548751c38..79741c5f9fe7 100644
--- a/drivers/net/cpmac.c
+++ b/drivers/net/cpmac.c
@@ -1161,7 +1161,7 @@ static int __devinit cpmac_probe(struct platform_device *pdev)
        priv->msg_enable = netif_msg_init(debug_level, 0xff);
        memcpy(dev->dev_addr, pdata->dev_addr, sizeof(dev->dev_addr));
-        priv->phy = phy_connect(dev, cpmac_mii->phy_map[phy_id]->dev.bus_id,
+        priv->phy = phy_connect(dev, dev_name(&cpmac_mii->phy_map[phy_id]->dev),
                                &cpmac_adjust_link, 0, PHY_INTERFACE_MODE_MII);
        if (IS_ERR(priv->phy)) {
                if (netif_msg_drv(priv))
diff --git a/drivers/net/declance.c b/drivers/net/declance.c
index 7ce3053530f9..861c867fca87 100644
--- a/drivers/net/declance.c
+++ b/drivers/net/declance.c
@@ -1027,7 +1027,7 @@ static int __init dec_lance_probe(struct device *bdev, const int type)
                printk(version);
        if (bdev)
-                snprintf(name, sizeof(name), "%s", bdev->bus_id);
+                snprintf(name, sizeof(name), "%s", dev_name(bdev));
        else {
                i = 0;
                dev = root_lance_dev;
@@ -1105,10 +1105,10 @@ static int __init dec_lance_probe(struct device *bdev, const int type)
                start = to_tc_dev(bdev)->resource.start;
                len = to_tc_dev(bdev)->resource.end - start + 1;
-                if (!request_mem_region(start, len, bdev->bus_id)) {
+                if (!request_mem_region(start, len, dev_name(bdev))) {
                        printk(KERN_ERR
                               "%s: Unable to reserve MMIO resource\n",
-                               bdev->bus_id);
+                               dev_name(bdev));
                        ret = -EBUSY;
                        goto err_out_dev;
                }
diff --git a/drivers/net/depca.c b/drivers/net/depca.c
index e4cef491dc73..55625dbbae5a 100644
--- a/drivers/net/depca.c
+++ b/drivers/net/depca.c
@@ -606,8 +606,8 @@ static int __init depca_hw_init (struct net_device *dev, struct device *device)
        if (!mem_start || lp->adapter < DEPCA || lp->adapter >=unknown)
                return -ENXIO;
-        printk ("%s: %s at 0x%04lx",
+        printk("%s: %s at 0x%04lx",
-                device->bus_id, depca_signature[lp->adapter], ioaddr);
+               dev_name(device), depca_signature[lp->adapter], ioaddr);
        switch (lp->depca_bus) {
 #ifdef CONFIG_MCA
@@ -669,7 +669,7 @@ static int __init depca_hw_init (struct net_device *dev, struct device *device)
        spin_lock_init(&lp->lock);
        sprintf(lp->adapter_name, "%s (%s)",
-                depca_signature[lp->adapter], device->bus_id);
+                depca_signature[lp->adapter], dev_name(device));
        status = -EBUSY;
        /* Initialisation Block */
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index dfe92264e825..8e7c16535ad7 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -3040,7 +3040,7 @@ static struct device *ehea_register_port(struct ehea_port *port,
        port->ofdev.dev.parent = &port->adapter->ofdev->dev;
        port->ofdev.dev.bus = &ibmebus_bus_type;
-        sprintf(port->ofdev.dev.bus_id, "port%d", port_name_cnt++);
+        dev_set_name(&port->ofdev.dev, "port%d", port_name_cnt++);
        port->ofdev.dev.release = logical_port_release;
        ret = of_device_register(&port->ofdev);
diff --git a/drivers/net/jazzsonic.c b/drivers/net/jazzsonic.c
index 334ff9e12cdd..14248cfc3dfd 100644
--- a/drivers/net/jazzsonic.c
+++ b/drivers/net/jazzsonic.c
@@ -131,7 +131,8 @@ static int __init sonic_probe1(struct net_device *dev)
        if (sonic_debug  &&  version_printed++ == 0)
                printk(version);
-        printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ", lp->device->bus_id, dev->base_addr);
+        printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ",
+               dev_name(lp->device), dev->base_addr);
        /*
         * Put the sonic into software reset, then
@@ -156,7 +157,8 @@ static int __init sonic_probe1(struct net_device *dev)
        if ((lp->descriptors = dma_alloc_coherent(lp->device,
                                SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
                                &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
+                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
+                       dev_name(lp->device));
                goto out;
        }
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index f6c4936e2fa8..f4086542c358 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -211,10 +211,10 @@ static int macb_mii_probe(struct net_device *dev)
        /* attach the mac to the phy */
        if (pdata && pdata->is_rmii) {
-                phydev = phy_connect(dev, phydev->dev.bus_id,
+                phydev = phy_connect(dev, dev_name(&phydev->dev),
                        &macb_handle_link_change, 0, PHY_INTERFACE_MODE_RMII);
        } else {
-                phydev = phy_connect(dev, phydev->dev.bus_id,
+                phydev = phy_connect(dev, dev_name(&phydev->dev),
                        &macb_handle_link_change, 0, PHY_INTERFACE_MODE_MII);
        }
@@ -1077,7 +1077,7 @@ static void macb_get_drvinfo(struct net_device *dev,
        strcpy(info->driver, bp->pdev->dev.driver->name);
        strcpy(info->version, "$Revision: 1.14 $");
-        strcpy(info->bus_info, bp->pdev->dev.bus_id);
+        strcpy(info->bus_info, dev_name(&bp->pdev->dev));
 }
 static struct ethtool_ops macb_ethtool_ops = {
@@ -1234,8 +1234,8 @@ static int __init macb_probe(struct platform_device *pdev)
        phydev = bp->phy_dev;
        printk(KERN_INFO "%s: attached PHY driver [%s] "
-                "(mii_bus:phy_addr=%s, irq=%d)\n",
+                "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
        return 0;
diff --git a/drivers/net/macsonic.c b/drivers/net/macsonic.c
index 205bb05c25d6..527166e35d56 100644
--- a/drivers/net/macsonic.c
+++ b/drivers/net/macsonic.c
@@ -176,7 +176,8 @@ static int __init macsonic_init(struct net_device *dev)
        if ((lp->descriptors = dma_alloc_coherent(lp->device,
                    SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
                    &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
+                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
+                       dev_name(lp->device));
                return -ENOMEM;
        }
@@ -337,7 +338,7 @@ static int __init mac_onboard_sonic_probe(struct net_device *dev)
                sonic_version_printed = 1;
        }
        printk(KERN_INFO "%s: onboard / comm-slot SONIC at 0x%08lx\n",
-               lp->device->bus_id, dev->base_addr);
+               dev_name(lp->device), dev->base_addr);
        /* The PowerBook's SONIC is 16 bit always. */
        if (macintosh_config->ident == MAC_MODEL_PB520) {
@@ -370,10 +371,10 @@ static int __init mac_onboard_sonic_probe(struct net_device *dev)
        }
        printk(KERN_INFO
               "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
-               lp->device->bus_id, sr, lp->dma_bitmode?32:16, lp->reg_offset);
+               dev_name(lp->device), sr, lp->dma_bitmode?32:16, lp->reg_offset);
 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
-        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp->device->bus_id,
+        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
               SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 #endif
@@ -525,12 +526,12 @@ static int __init mac_nubus_sonic_probe(struct net_device *dev)
                sonic_version_printed = 1;
        }
        printk(KERN_INFO "%s: %s in slot %X\n",
-               lp->device->bus_id, ndev->board->name, ndev->board->slot);
+               dev_name(lp->device), ndev->board->name, ndev->board->slot);
        printk(KERN_INFO "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
-               lp->device->bus_id, SONIC_READ(SONIC_SR), dma_bitmode?32:16, reg_offset);
+               dev_name(lp->device), SONIC_READ(SONIC_SR), dma_bitmode?32:16, reg_offset);
 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
-        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp->device->bus_id,
+        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
               SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 #endif
diff --git a/drivers/net/mipsnet.c b/drivers/net/mipsnet.c
index 4e7a5faf0351..664835b822fb 100644
--- a/drivers/net/mipsnet.c
+++ b/drivers/net/mipsnet.c
@@ -237,7 +237,7 @@ static void mipsnet_set_mclist(struct net_device *dev)
 {
 }
-static int __init mipsnet_probe(struct device *dev)
+static int __init mipsnet_probe(struct platform_device *dev)
 {
        struct net_device *netdev;
        int err;
@@ -248,7 +248,7 @@ static int __init mipsnet_probe(struct device *dev)
                goto out;
        }
-        dev_set_drvdata(dev, netdev);
+        platform_set_drvdata(dev, netdev);
        netdev->open                    = mipsnet_open;
        netdev->stop                    = mipsnet_close;
@@ -293,23 +293,25 @@ out:
        return err;
 }
-static int __devexit mipsnet_device_remove(struct device *device)
+static int __devexit mipsnet_device_remove(struct platform_device *device)
 {
-        struct net_device *dev = dev_get_drvdata(device);
+        struct net_device *dev = platform_get_drvdata(device);
        unregister_netdev(dev);
        release_region(dev->base_addr, sizeof(struct mipsnet_regs));
        free_netdev(dev);
-        dev_set_drvdata(device, NULL);
+        platform_set_drvdata(device, NULL);
        return 0;
 }
-static struct device_driver mipsnet_driver = {
+static struct platform_driver mipsnet_driver = {
-        .name   = mipsnet_string,
+        .driver = {
-        .bus    = &platform_bus_type,
+                .name           = mipsnet_string,
-        .probe  = mipsnet_probe,
+                .owner          = THIS_MODULE,
-        .remove = __devexit_p(mipsnet_device_remove),
+        },
+        .probe          = mipsnet_probe,
+        .remove         = __devexit_p(mipsnet_device_remove),
 };
 static int __init mipsnet_init_module(void)
@@ -319,7 +321,7 @@ static int __init mipsnet_init_module(void)
        printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
               "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
-        err = driver_register(&mipsnet_driver);
+        err = platform_driver_register(&mipsnet_driver);
        if (err)
                printk(KERN_ERR "Driver registration failed\n");
@@ -328,7 +330,7 @@ static int __init mipsnet_init_module(void)
 static void __exit mipsnet_exit_module(void)
 {
-        driver_unregister(&mipsnet_driver);
+        platform_driver_unregister(&mipsnet_driver);
 }
 module_init(mipsnet_init_module);
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index b0bc3bc18e9c..fe4e158c893d 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -2588,7 +2588,7 @@ static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
        phy_reset(mp);
-        phy_attach(mp->dev, phy->dev.bus_id, 0, PHY_INTERFACE_MODE_GMII);
+        phy_attach(mp->dev, dev_name(&phy->dev), 0, PHY_INTERFACE_MODE_GMII);
        if (speed == 0) {
                phy->autoneg = AUTONEG_ENABLE;
diff --git a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c
index 31e38fae017f..845431c186ac 100644
--- a/drivers/net/sb1250-mac.c
+++ b/drivers/net/sb1250-mac.c
@@ -2478,7 +2478,7 @@ static int sbmac_mii_probe(struct net_device *dev)
                return -ENXIO;
        }
-        phy_dev = phy_connect(dev, phy_dev->dev.bus_id, &sbmac_mii_poll, 0,
+        phy_dev = phy_connect(dev, dev_name(&phy_dev->dev), &sbmac_mii_poll, 0,
                              PHY_INTERFACE_MODE_GMII);
        if (IS_ERR(phy_dev)) {
                printk(KERN_ERR "%s: could not attach to PHY\n", dev->name);
@@ -2500,7 +2500,7 @@ static int sbmac_mii_probe(struct net_device *dev)
        pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
                dev->name, phy_dev->drv->name,
-                phy_dev->dev.bus_id, phy_dev->irq);
+                dev_name(&phy_dev->dev), phy_dev->irq);
        sc->phy_dev = phy_dev;
@@ -2697,7 +2697,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
        sbm_base = ioremap_nocache(res->start, res->end - res->start + 1);
        if (!sbm_base) {
                printk(KERN_ERR "%s: unable to map device registers\n",
-                       pldev->dev.bus_id);
+                       dev_name(&pldev->dev));
                err = -ENOMEM;
                goto out_out;
        }
@@ -2708,7 +2708,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
         * If we find a zero, skip this MAC.
         */
        sbmac_orig_hwaddr = __raw_readq(sbm_base + R_MAC_ETHERNET_ADDR);
-        pr_debug("%s: %sconfiguring MAC at 0x%08Lx\n", pldev->dev.bus_id,
+        pr_debug("%s: %sconfiguring MAC at 0x%08Lx\n", dev_name(&pldev->dev),
                 sbmac_orig_hwaddr ? "" : "not ", (long long)res->start);
        if (sbmac_orig_hwaddr == 0) {
                err = 0;
@@ -2721,7 +2721,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
        dev = alloc_etherdev(sizeof(struct sbmac_softc));
        if (!dev) {
                printk(KERN_ERR "%s: unable to allocate etherdev\n",
-                       pldev->dev.bus_id);
+                       dev_name(&pldev->dev));
                err = -ENOMEM;
                goto out_unmap;
        }
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index 223cde0d43be..293610334a77 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -1545,7 +1545,7 @@ smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        strncpy(info->driver, CARDNAME, sizeof(info->driver));
        strncpy(info->version, version, sizeof(info->version));
-        strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+        strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 static int smc911x_ethtool_nwayreset(struct net_device *dev)
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index b215a8d85e62..0b6da9501444 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1614,7 +1614,7 @@ smc_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        strncpy(info->driver, CARDNAME, sizeof(info->driver));
        strncpy(info->version, version, sizeof(info->version));
-        strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+        strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 static int smc_ethtool_nwayreset(struct net_device *dev)
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index d1590ac55e4b..ab18ee0f60f3 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -769,7 +769,7 @@ static int smsc911x_mii_probe(struct net_device *dev)
                return -ENODEV;
        }
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                &smsc911x_phy_adjust_link, 0, pdata->config.phy_interface);
        if (IS_ERR(phydev)) {
@@ -778,7 +778,8 @@ static int smsc911x_mii_probe(struct net_device *dev)
        }
        pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                dev->name, phydev->drv->name,
+                dev_name(&phydev->dev), phydev->irq);
        /* mask with MAC supported features */
        phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
@@ -1549,7 +1550,7 @@ static void smsc911x_ethtool_getdrvinfo(struct net_device *dev,
 {
        strlcpy(info->driver, SMSC_CHIPNAME, sizeof(info->driver));
        strlcpy(info->version, SMSC_DRV_VERSION, sizeof(info->version));
-        strlcpy(info->bus_info, dev->dev.parent->bus_id,
+        strlcpy(info->bus_info, dev_name(dev->dev.parent),
                sizeof(info->bus_info));
 }
diff --git a/drivers/net/smsc9420.c b/drivers/net/smsc9420.c
index 4e15ae068b3f..72f1348eb809 100644
--- a/drivers/net/smsc9420.c
+++ b/drivers/net/smsc9420.c
@@ -1160,7 +1160,7 @@ static int smsc9420_mii_probe(struct net_device *dev)
        smsc_info(PROBE, "PHY addr %d, phy_id 0x%08X", phydev->addr,
                phydev->phy_id);
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                &smsc9420_phy_adjust_link, 0, PHY_INTERFACE_MODE_MII);
        if (IS_ERR(phydev)) {
@@ -1169,7 +1169,7 @@ static int smsc9420_mii_probe(struct net_device *dev)
        }
        pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                dev->name, phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
        /* mask with MAC supported features */
        phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
diff --git a/drivers/net/tc35815.c b/drivers/net/tc35815.c
index bcd0e60cbda9..e1f8eb96a45c 100644
--- a/drivers/net/tc35815.c
+++ b/drivers/net/tc35815.c
@@ -725,7 +725,7 @@ static int tc_mii_probe(struct net_device *dev)
        }
        /* attach the mac to the phy */
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                             &tc_handle_link_change, 0,
                             lp->chiptype == TC35815_TX4939 ?
                             PHY_INTERFACE_MODE_RMII : PHY_INTERFACE_MODE_MII);
@@ -735,7 +735,7 @@ static int tc_mii_probe(struct net_device *dev)
        }
        printk(KERN_INFO "%s: attached PHY driver [%s] "
                "(mii_bus:phy_addr=%s, id=%x)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id,
+                dev->name, phydev->drv->name, dev_name(&phydev->dev),
                phydev->phy_id);
        /* mask with MAC supported features */
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index e80a0b65a754..d58b971faa64 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -613,7 +613,7 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
        d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
        snprintf(wimax_dev->name, sizeof(wimax_dev->name),
-                 "i2400m-%s:%s", dev->bus->name, dev->bus_id);
+                 "i2400m-%s:%s", dev->bus->name, dev_name(dev));
        i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
        if (i2400m->bm_cmd_buf == NULL) {
diff --git a/drivers/net/wimax/i2400m/usb-notif.c b/drivers/net/wimax/i2400m/usb-notif.c
index 9702c22b2497..0528879f6d39 100644
--- a/drivers/net/wimax/i2400m/usb-notif.c
+++ b/drivers/net/wimax/i2400m/usb-notif.c
@@ -102,7 +102,7 @@ int i2400mu_notification_grok(struct i2400mu *i2400mu, const void *buf,
                dev_err(dev, "HW BUG? Unknown/unexpected data in notification "
                        "message (%zu bytes)\n", buf_len);
                snprintf(prefix, sizeof(prefix), "%s %s: ",
-                         dev_driver_string(dev) , dev->bus_id);
+                         dev_driver_string(dev) , dev_name(dev));
                if (buf_len > 64) {
                        print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
                                       8, 4, buf, 64, 0);
diff --git a/drivers/net/xtsonic.c b/drivers/net/xtsonic.c
index 03a3f34e9039..a12a7211c982 100644
--- a/drivers/net/xtsonic.c
+++ b/drivers/net/xtsonic.c
@@ -183,7 +183,7 @@ static int __init sonic_probe1(struct net_device *dev)
        if (lp->descriptors == NULL) {
                printk(KERN_ERR "%s: couldn't alloc DMA memory for "
-                                " descriptors.\n", lp->device->bus_id);
+                                " descriptors.\n", dev_name(lp->device));
                goto out;
        }
diff --git a/drivers/pci/hotplug/cpqphp_sysfs.c b/drivers/pci/hotplug/cpqphp_sysfs.c
index a13abf55d784..8450f4a6568a 100644
--- a/drivers/pci/hotplug/cpqphp_sysfs.c
+++ b/drivers/pci/hotplug/cpqphp_sysfs.c
@@ -225,7 +225,8 @@ void cpqhp_shutdown_debugfs(void)
 void cpqhp_create_debugfs_files(struct controller *ctrl)
 {
-        ctrl->dentry = debugfs_create_file(ctrl->pci_dev->dev.bus_id, S_IRUGO, root, ctrl, &debug_ops);
+        ctrl->dentry = debugfs_create_file(dev_name(&ctrl->pci_dev->dev),
+                                           S_IRUGO, root, ctrl, &debug_ops);
 }
 void cpqhp_remove_debugfs_files(struct controller *ctrl)
diff --git a/drivers/pcmcia/au1000_generic.c b/drivers/pcmcia/au1000_generic.c
index fc1de46fd20a..90013341cd5f 100644
--- a/drivers/pcmcia/au1000_generic.c
+++ b/drivers/pcmcia/au1000_generic.c
@@ -468,13 +468,13 @@ out:
        return ret;
 }
-int au1x00_drv_pcmcia_remove(struct device *dev)
+int au1x00_drv_pcmcia_remove(struct platform_device *dev)
 {
-        struct skt_dev_info *sinfo = dev_get_drvdata(dev);
+        struct skt_dev_info *sinfo = platform_get_drvdata(dev);
        int i;
        mutex_lock(&pcmcia_sockets_lock);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
        for (i = 0; i < sinfo->nskt; i++) {
                struct au1000_pcmcia_socket *skt = PCMCIA_SOCKET(i);
@@ -498,13 +498,13 @@ int au1x00_drv_pcmcia_remove(struct device *dev)
 * PCMCIA "Driver" API
 */
-static int au1x00_drv_pcmcia_probe(struct device *dev)
+static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
 {
        int i, ret = -ENODEV;
        mutex_lock(&pcmcia_sockets_lock);
        for (i=0; i < ARRAY_SIZE(au1x00_pcmcia_hw_init); i++) {
-                ret = au1x00_pcmcia_hw_init[i](dev);
+                ret = au1x00_pcmcia_hw_init[i](&dev->dev);
                if (ret == 0)
                        break;
        }
@@ -512,14 +512,26 @@ static int au1x00_drv_pcmcia_probe(struct device *dev)
        return ret;
 }
+static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
-static struct device_driver au1x00_pcmcia_driver = {
+static struct platform_driver au1x00_pcmcia_driver = {
+        .driver = {
+                .name           = "au1x00-pcmcia",
+                .owner          = THIS_MODULE,
+        },
        .probe          = au1x00_drv_pcmcia_probe,
        .remove         = au1x00_drv_pcmcia_remove,
-        .name           = "au1x00-pcmcia",
+        .suspend        = au1x00_drv_pcmcia_suspend,
-        .bus            = &platform_bus_type,
+        .resume         = au1x00_drv_pcmcia_resume,
-        .suspend        = pcmcia_socket_dev_suspend,
-        .resume         = pcmcia_socket_dev_resume,
 };
@@ -533,8 +545,7 @@ static struct device_driver au1x00_pcmcia_driver = {
 static int __init au1x00_pcmcia_init(void)
 {
        int error = 0;
-        if ((error = driver_register(&au1x00_pcmcia_driver)))
+        error = platform_driver_register(&au1x00_pcmcia_driver);
-                return error;
        return error;
 }
@@ -544,7 +555,7 @@ static int __init au1x00_pcmcia_init(void)
 */
 static void __exit au1x00_pcmcia_exit(void)
 {
-        driver_unregister(&au1x00_pcmcia_driver);
+        platform_driver_unregister(&au1x00_pcmcia_driver);
 }
 module_init(au1x00_pcmcia_init);
diff --git a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c
index 71653ab84890..40d4953e4b12 100644
--- a/drivers/pcmcia/i82365.c
+++ b/drivers/pcmcia/i82365.c
@@ -1238,6 +1238,16 @@ static int pcic_init(struct pcmcia_socket *s)
        return 0;
 }
+static int i82365_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int i82365_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 static struct pccard_operations pcic_operations = {
        .init                   = pcic_init,
        .get_status             = pcic_get_status,
@@ -1248,11 +1258,13 @@ static struct pccard_operations pcic_operations = {
 /*====================================================================*/
-static struct device_driver i82365_driver = {
+static struct platform_driver i82365_driver = {
-        .name = "i82365",
+        .driver = {
-        .bus = &platform_bus_type,
+                .name = "i82365",
-        .suspend = pcmcia_socket_dev_suspend,
+                .owner          = THIS_MODULE,
-        .resume = pcmcia_socket_dev_resume,
+        },
+        .suspend        = i82365_drv_pcmcia_suspend,
+        .resume         = i82365_drv_pcmcia_resume,
 };
 static struct platform_device *i82365_device;
@@ -1261,7 +1273,7 @@ static int __init init_i82365(void)
 {
    int i, ret;
-    ret = driver_register(&i82365_driver);
+    ret = platform_driver_register(&i82365_driver);
    if (ret)
        goto err_out;
@@ -1337,7 +1349,7 @@ err_dev_unregister:
        pnp_disable_dev(i82365_pnpdev);
 #endif
 err_driver_unregister:
-    driver_unregister(&i82365_driver);
+    platform_driver_unregister(&i82365_driver);
 err_out:
    return ret;
 } /* init_i82365 */
@@ -1365,7 +1377,7 @@ static void __exit exit_i82365(void)
    if (i82365_pnpdev)
                pnp_disable_dev(i82365_pnpdev);
 #endif
-    driver_unregister(&i82365_driver);
+    platform_driver_unregister(&i82365_driver);
 } /* exit_i82365 */
 module_init(init_i82365);
diff --git a/drivers/pcmcia/m32r_cfc.c b/drivers/pcmcia/m32r_cfc.c
index 2ab4f22c21de..62b4ecc97c46 100644
--- a/drivers/pcmcia/m32r_cfc.c
+++ b/drivers/pcmcia/m32r_cfc.c
@@ -696,13 +696,25 @@ static struct pccard_operations pcc_operations = {
        .set_mem_map            = pcc_set_mem_map,
 };
+static int cfc_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int cfc_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
-static struct device_driver pcc_driver = {
+static struct platform_driver pcc_driver = {
-        .name = "cfc",
+        .driver = {
-        .bus = &platform_bus_type,
+                .name           = "cfc",
-        .suspend = pcmcia_socket_dev_suspend,
+                .owner          = THIS_MODULE,
-        .resume = pcmcia_socket_dev_resume,
+        },
+        .suspend        = cfc_drv_pcmcia_suspend,
+        .resume         = cfc_drv_pcmcia_resume,
 };
 static struct platform_device pcc_device = {
@@ -716,13 +728,13 @@ static int __init init_m32r_pcc(void)
 {
        int i, ret;
-        ret = driver_register(&pcc_driver);
+        ret = platform_driver_register(&pcc_driver);
        if (ret)
                return ret;
        ret = platform_device_register(&pcc_device);
        if (ret){
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                return ret;
        }
@@ -754,7 +766,7 @@ static int __init init_m32r_pcc(void)
        if (pcc_sockets == 0) {
                printk("socket is not found.\n");
                platform_device_unregister(&pcc_device);
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                return -ENODEV;
        }
@@ -802,7 +814,7 @@ static void __exit exit_m32r_pcc(void)
        if (poll_interval != 0)
                del_timer_sync(&poll_timer);
-        driver_unregister(&pcc_driver);
+        platform_driver_unregister(&pcc_driver);
 } /* exit_m32r_pcc */
 module_init(init_m32r_pcc);
diff --git a/drivers/pcmcia/m32r_pcc.c b/drivers/pcmcia/m32r_pcc.c
index 2f108c23dbd9..12034b41d196 100644
--- a/drivers/pcmcia/m32r_pcc.c
+++ b/drivers/pcmcia/m32r_pcc.c
@@ -672,13 +672,25 @@ static struct pccard_operations pcc_operations = {
        .set_mem_map            = pcc_set_mem_map,
 };
+static int pcc_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int pcc_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
-static struct device_driver pcc_driver = {
+static struct platform_driver pcc_driver = {
-        .name = "pcc",
+        .driver = {
-        .bus = &platform_bus_type,
+                .name           = "pcc",
-        .suspend = pcmcia_socket_dev_suspend,
+                .owner          = THIS_MODULE,
-        .resume = pcmcia_socket_dev_resume,
+        },
+        .suspend        = pcc_drv_pcmcia_suspend,
+        .resume         = pcc_drv_pcmcia_resume,
 };
 static struct platform_device pcc_device = {
@@ -692,13 +704,13 @@ static int __init init_m32r_pcc(void)
 {
        int i, ret;
-        ret = driver_register(&pcc_driver);
+        ret = platform_driver_register(&pcc_driver);
        if (ret)
                return ret;
        ret = platform_device_register(&pcc_device);
        if (ret){
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                return ret;
        }
@@ -715,7 +727,7 @@ static int __init init_m32r_pcc(void)
        if (pcc_sockets == 0) {
                printk("socket is not found.\n");
                platform_device_unregister(&pcc_device);
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                return -ENODEV;
        }
@@ -763,7 +775,7 @@ static void __exit exit_m32r_pcc(void)
        if (poll_interval != 0)
                del_timer_sync(&poll_timer);
-        driver_unregister(&pcc_driver);
+        platform_driver_unregister(&pcc_driver);
 } /* exit_m32r_pcc */
 module_init(init_m32r_pcc);
diff --git a/drivers/pcmcia/rsrc_mgr.c b/drivers/pcmcia/rsrc_mgr.c
index c0e2afc79e3e..e592e0e0d7ed 100644
--- a/drivers/pcmcia/rsrc_mgr.c
+++ b/drivers/pcmcia/rsrc_mgr.c
@@ -153,7 +153,7 @@ static struct resource *iodyn_find_io_region(unsigned long base, int num,
                unsigned long align, struct pcmcia_socket *s)
 {
        struct resource *res = make_resource(0, num, IORESOURCE_IO,
-                                             s->dev.bus_id);
+                                             dev_name(&s->dev));
        struct pcmcia_align_data data;
        unsigned long min = base;
        int ret;
diff --git a/drivers/pcmcia/sa1100_generic.c b/drivers/pcmcia/sa1100_generic.c
index c5b2a44b4c37..d8da5ac844e9 100644
--- a/drivers/pcmcia/sa1100_generic.c
+++ b/drivers/pcmcia/sa1100_generic.c
@@ -65,7 +65,7 @@ static int (*sa11x0_pcmcia_hw_init[])(struct device *dev) = {
 #endif
 };
-static int sa11x0_drv_pcmcia_probe(struct device *dev)
+static int sa11x0_drv_pcmcia_probe(struct platform_device *dev)
 {
        int i, ret = -ENODEV;
@@ -73,7 +73,7 @@ static int sa11x0_drv_pcmcia_probe(struct device *dev)
         * Initialise any "on-board" PCMCIA sockets.
         */
        for (i = 0; i < ARRAY_SIZE(sa11x0_pcmcia_hw_init); i++) {
-                ret = sa11x0_pcmcia_hw_init[i](dev);
+                ret = sa11x0_pcmcia_hw_init[i](&dev->dev);
                if (ret == 0)
                        break;
        }
@@ -81,13 +81,31 @@ static int sa11x0_drv_pcmcia_probe(struct device *dev)
        return ret;
 }
-static struct device_driver sa11x0_pcmcia_driver = {
+static int sa11x0_drv_pcmcia_remove(struct platform_device *dev)
+{
+        return soc_common_drv_pcmcia_remove(&dev->dev);
+}
+static int sa11x0_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int sa11x0_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
+static struct platform_driver sa11x0_pcmcia_driver = {
+        .driver = {
+                .name           = "sa11x0-pcmcia",
+                .owner          = THIS_MODULE,
+        },
        .probe          = sa11x0_drv_pcmcia_probe,
-        .remove         = soc_common_drv_pcmcia_remove,
+        .remove         = sa11x0_drv_pcmcia_remove,
-        .name           = "sa11x0-pcmcia",
+        .suspend        = sa11x0_drv_pcmcia_suspend,
-        .bus            = &platform_bus_type,
+        .resume         = sa11x0_drv_pcmcia_resume,
-        .suspend        = pcmcia_socket_dev_suspend,
-        .resume         = pcmcia_socket_dev_resume,
 };
 /* sa11x0_pcmcia_init()
@@ -100,7 +118,7 @@ static struct device_driver sa11x0_pcmcia_driver = {
 */
 static int __init sa11x0_pcmcia_init(void)
 {
-        return driver_register(&sa11x0_pcmcia_driver);
+        return platform_driver_register(&sa11x0_pcmcia_driver);
 }
 /* sa11x0_pcmcia_exit()
@@ -110,7 +128,7 @@ static int __init sa11x0_pcmcia_init(void)
 */
 static void __exit sa11x0_pcmcia_exit(void)
 {
-        driver_unregister(&sa11x0_pcmcia_driver);
+        platform_driver_unregister(&sa11x0_pcmcia_driver);
 }
 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index 2a613e920fd4..9ad97ea836e8 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -363,13 +363,25 @@ static int __init get_tcic_id(void)
    return id;
 }
+static int tcic_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+static int tcic_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
-static struct device_driver tcic_driver = {
+static struct platform_driver tcic_driver = {
-        .name = "tcic-pcmcia",
+        .driver = {
-        .bus = &platform_bus_type,
+                .name = "tcic-pcmcia",
-        .suspend = pcmcia_socket_dev_suspend,
+                .owner          = THIS_MODULE,
-        .resume = pcmcia_socket_dev_resume,
+        },
+        .suspend        = tcic_drv_pcmcia_suspend,
+        .resume         = tcic_drv_pcmcia_resume,
 };
 static struct platform_device tcic_device = {
@@ -383,7 +395,7 @@ static int __init init_tcic(void)
    int i, sock, ret = 0;
    u_int mask, scan;
-    if (driver_register(&tcic_driver))
+    if (platform_driver_register(&tcic_driver))
        return -1;
    
    printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
@@ -391,7 +403,7 @@ static int __init init_tcic(void)
    if (!request_region(tcic_base, 16, "tcic-2")) {
        printk("could not allocate ports,\n ");
-        driver_unregister(&tcic_driver);
+        platform_driver_unregister(&tcic_driver);
        return -ENODEV;
    }
    else {
@@ -414,7 +426,7 @@ static int __init init_tcic(void)
    if (sock == 0) {
        printk("not found.\n");
        release_region(tcic_base, 16);
-        driver_unregister(&tcic_driver);
+        platform_driver_unregister(&tcic_driver);
        return -ENODEV;
    }
@@ -542,7 +554,7 @@ static void __exit exit_tcic(void)
    }
    platform_device_unregister(&tcic_device);
-    driver_unregister(&tcic_driver);
+    platform_driver_unregister(&tcic_driver);
 } /* exit_tcic */
 /*====================================================================*/
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index b2c412419059..659421d0ca46 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -704,24 +704,37 @@ static int __devinit vrc4171_card_setup(char *options)
 __setup("vrc4171_card=", vrc4171_card_setup);
-static struct device_driver vrc4171_card_driver = {
+static int vrc4171_card_suspend(struct platform_device *dev,
-        .name           = vrc4171_card_name,
+                                     pm_message_t state)
-        .bus            = &platform_bus_type,
+{
-        .suspend        = pcmcia_socket_dev_suspend,
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
-        .resume         = pcmcia_socket_dev_resume,
+}
+static int vrc4171_card_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
+static struct platform_driver vrc4171_card_driver = {
+        .driver = {
+                .name           = vrc4171_card_name,
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = vrc4171_card_suspend,
+        .resume         = vrc4171_card_resume,
 };
 static int __devinit vrc4171_card_init(void)
 {
        int retval;
-        retval = driver_register(&vrc4171_card_driver);
+        retval = platform_driver_register(&vrc4171_card_driver);
        if (retval < 0)
                return retval;
        retval = platform_device_register(&vrc4171_card_device);
        if (retval < 0) {
-                driver_unregister(&vrc4171_card_driver);
+                platform_driver_unregister(&vrc4171_card_driver);
                return retval;
        }
@@ -735,11 +748,12 @@ static int __devinit vrc4171_card_init(void)
        if (retval < 0) {
                vrc4171_remove_sockets();
                platform_device_unregister(&vrc4171_card_device);
-                driver_unregister(&vrc4171_card_driver);
+                platform_driver_unregister(&vrc4171_card_driver);
                return retval;
        }
-        printk(KERN_INFO "%s, connected to IRQ %d\n", vrc4171_card_driver.name, vrc4171_irq);
+        printk(KERN_INFO "%s, connected to IRQ %d\n",
+                vrc4171_card_driver.driver.name, vrc4171_irq);
        return 0;
 }
@@ -749,7 +763,7 @@ static void __devexit vrc4171_card_exit(void)
        free_irq(vrc4171_irq, vrc4171_sockets);
        vrc4171_remove_sockets();
        platform_device_unregister(&vrc4171_card_device);
-        driver_unregister(&vrc4171_card_driver);
+        platform_driver_unregister(&vrc4171_card_driver);
 }
 module_init(vrc4171_card_init);
diff --git a/drivers/rapidio/rio-driver.c b/drivers/rapidio/rio-driver.c
index addb87cf44d9..3222fa3c808c 100644
--- a/drivers/rapidio/rio-driver.c
+++ b/drivers/rapidio/rio-driver.c
@@ -193,7 +193,7 @@ static int rio_match_bus(struct device *dev, struct device_driver *drv)
 }
 static struct device rio_bus = {
-        .bus_id = "rapidio",
+        .init_name = "rapidio",
 };
 struct bus_type rio_bus_type = {
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index d5e4e637ddec..86c61f143515 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -351,7 +351,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
        /* register irq handler after we know what name we'll use */
        ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
                                IRQF_DISABLED | IRQF_SHARED,
-                                rtc->rtcdev->dev.bus_id, rtc);
+                                dev_name(&rtc->rtcdev->dev), rtc);
        if (ret) {
                dev_dbg(&pdev->dev, "can't share IRQ %d?\n", AT91_ID_SYS);
                rtc_device_unregister(rtc->rtcdev);
@@ -366,7 +366,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
        if (gpbr_readl(rtc) == 0)
                dev_warn(&pdev->dev, "%s: SET TIME!\n",
-                                rtc->rtcdev->dev.bus_id);
+                                dev_name(&rtc->rtcdev->dev));
        return 0;
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 2cbeb0794f14..bd1ce8e2bc18 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -377,13 +377,13 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
        /* handle periodic and alarm irqs */
        if (request_irq(omap_rtc_timer, rtc_irq, IRQF_DISABLED,
-                        rtc->dev.bus_id, rtc)) {
+                        dev_name(&rtc->dev), rtc)) {
                pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                        pdev->name, omap_rtc_timer);
                goto fail0;
        }
        if (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
-                        rtc->dev.bus_id, rtc)) {
+                        dev_name(&rtc->dev), rtc)) {
                pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
                        pdev->name, omap_rtc_alarm);
                goto fail1;
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 1c3fc6b428e9..4898f7fe8518 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -28,7 +28,7 @@
 #include <asm/rtc.h>
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.2.0"
+#define DRV_VERSION     "0.2.1"
 #define RTC_REG(r)      ((r) * rtc_reg_size)
@@ -99,56 +99,51 @@ struct sh_rtc {
        unsigned short periodic_freq;
 };
-static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
+static int __sh_rtc_interrupt(struct sh_rtc *rtc)
 {
-        struct sh_rtc *rtc = dev_id;
+        unsigned int tmp, pending;
-        unsigned int tmp;
-        spin_lock(&rtc->lock);
        tmp = readb(rtc->regbase + RCR1);
+        pending = tmp & RCR1_CF;
        tmp &= ~RCR1_CF;
        writeb(tmp, rtc->regbase + RCR1);
        /* Users have requested One x Second IRQ */
-        if (rtc->periodic_freq & PF_OXS)
+        if (pending && rtc->periodic_freq & PF_OXS)
                rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
-        spin_unlock(&rtc->lock);
+        return pending;
-        return IRQ_HANDLED;
 }
-static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
+static int __sh_rtc_alarm(struct sh_rtc *rtc)
 {
-        struct sh_rtc *rtc = dev_id;
+        unsigned int tmp, pending;
-        unsigned int tmp;
-        spin_lock(&rtc->lock);
        tmp = readb(rtc->regbase + RCR1);
+        pending = tmp & RCR1_AF;
        tmp &= ~(RCR1_AF | RCR1_AIE);
-                writeb(tmp, rtc->regbase + RCR1);
+        writeb(tmp, rtc->regbase + RCR1);
-        rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
-        spin_unlock(&rtc->lock);
+        if (pending)
+                rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
-        return IRQ_HANDLED;
+        return pending;
 }
-static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
+static int __sh_rtc_periodic(struct sh_rtc *rtc)
 {
-        struct sh_rtc *rtc = dev_id;
        struct rtc_device *rtc_dev = rtc->rtc_dev;
-        unsigned int tmp;
+        struct rtc_task *irq_task;
+        unsigned int tmp, pending;
-        spin_lock(&rtc->lock);
        tmp = readb(rtc->regbase + RCR2);
+        pending = tmp & RCR2_PEF;
        tmp &= ~RCR2_PEF;
        writeb(tmp, rtc->regbase + RCR2);
+        if (!pending)
+                return 0;
        /* Half period enabled than one skipped and the next notified */
        if ((rtc->periodic_freq & PF_HP) && (rtc->periodic_freq & PF_COUNT))
                rtc->periodic_freq &= ~PF_COUNT;
@@ -157,16 +152,65 @@ static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
                        rtc->periodic_freq |= PF_COUNT;
                if (rtc->periodic_freq & PF_KOU) {
                        spin_lock(&rtc_dev->irq_task_lock);
-                        if (rtc_dev->irq_task)
+                        irq_task = rtc_dev->irq_task;
-                                rtc_dev->irq_task->func(rtc_dev->irq_task->private_data);
+                        if (irq_task)
+                                irq_task->func(irq_task->private_data);
                        spin_unlock(&rtc_dev->irq_task_lock);
                } else
                        rtc_update_irq(rtc->rtc_dev, 1, RTC_PF | RTC_IRQF);
        }
+        return pending;
+}
+static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
+{
+        struct sh_rtc *rtc = dev_id;
+        int ret;
+        spin_lock(&rtc->lock);
+        ret = __sh_rtc_interrupt(rtc);
+        spin_unlock(&rtc->lock);
+        return IRQ_RETVAL(ret);
+}
+static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
+{
+        struct sh_rtc *rtc = dev_id;
+        int ret;
+        spin_lock(&rtc->lock);
+        ret = __sh_rtc_alarm(rtc);
+        spin_unlock(&rtc->lock);
+        return IRQ_RETVAL(ret);
+}
+static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
+{
+        struct sh_rtc *rtc = dev_id;
+        int ret;
+        spin_lock(&rtc->lock);
+        ret = __sh_rtc_periodic(rtc);
        spin_unlock(&rtc->lock);
-        return IRQ_HANDLED;
+        return IRQ_RETVAL(ret);
+}
+static irqreturn_t sh_rtc_shared(int irq, void *dev_id)
+{
+        struct sh_rtc *rtc = dev_id;
+        int ret;
+        spin_lock(&rtc->lock);
+        ret = __sh_rtc_interrupt(rtc);
+        ret |= __sh_rtc_alarm(rtc);
+        ret |= __sh_rtc_periodic(rtc);
+        spin_unlock(&rtc->lock);
+        return IRQ_RETVAL(ret);
 }
 static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
@@ -275,6 +319,25 @@ static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
        return 0;
 }
+static inline void sh_rtc_setcie(struct device *dev, unsigned int enable)
+{
+        struct sh_rtc *rtc = dev_get_drvdata(dev);
+        unsigned int tmp;
+        spin_lock_irq(&rtc->lock);
+        tmp = readb(rtc->regbase + RCR1);
+        if (!enable)
+                tmp &= ~RCR1_CIE;
+        else
+                tmp |= RCR1_CIE;
+        writeb(tmp, rtc->regbase + RCR1);
+        spin_unlock_irq(&rtc->lock);
+}
 static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
        struct sh_rtc *rtc = dev_get_drvdata(dev);
@@ -291,9 +354,11 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
                break;
        case RTC_UIE_OFF:
                rtc->periodic_freq &= ~PF_OXS;
+                sh_rtc_setcie(dev, 0);
                break;
        case RTC_UIE_ON:
                rtc->periodic_freq |= PF_OXS;
+                sh_rtc_setcie(dev, 1);
                break;
        case RTC_IRQP_READ:
                ret = put_user(rtc->rtc_dev->irq_freq,
@@ -356,18 +421,17 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
                tm->tm_sec--;
 #endif
+        /* only keep the carry interrupt enabled if UIE is on */
+        if (!(rtc->periodic_freq & PF_OXS))
+                sh_rtc_setcie(dev, 0);
        dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
                __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
-        if (rtc_valid_tm(tm) < 0) {
+        return rtc_valid_tm(tm);
-                dev_err(dev, "invalid date\n");
-                rtc_time_to_tm(0, tm);
-        }
-        return 0;
 }
 static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -572,7 +636,7 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
 {
        struct sh_rtc *rtc;
        struct resource *res;
-        unsigned int tmp;
+        struct rtc_time r;
        int ret;
        rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
@@ -585,26 +649,12 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
        ret = platform_get_irq(pdev, 0);
        if (unlikely(ret <= 0)) {
                ret = -ENOENT;
-                dev_err(&pdev->dev, "No IRQ for period\n");
+                dev_err(&pdev->dev, "No IRQ resource\n");
                goto err_badres;
        }
        rtc->periodic_irq = ret;
+        rtc->carry_irq = platform_get_irq(pdev, 1);
-        ret = platform_get_irq(pdev, 1);
+        rtc->alarm_irq = platform_get_irq(pdev, 2);
-        if (unlikely(ret <= 0)) {
-                ret = -ENOENT;
-                dev_err(&pdev->dev, "No IRQ for carry\n");
-                goto err_badres;
-        }
-        rtc->carry_irq = ret;
-        ret = platform_get_irq(pdev, 2);
-        if (unlikely(ret <= 0)) {
-                ret = -ENOENT;
-                dev_err(&pdev->dev, "No IRQ for alarm\n");
-                goto err_badres;
-        }
-        rtc->alarm_irq = ret;
        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
        if (unlikely(res == NULL)) {
@@ -646,47 +696,66 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
        }
        rtc->rtc_dev->max_user_freq = 256;
-        rtc->rtc_dev->irq_freq = 1;
-        rtc->periodic_freq = 0x60;
        platform_set_drvdata(pdev, rtc);
-        /* register periodic/carry/alarm irqs */
+        if (rtc->carry_irq <= 0) {
-        ret = request_irq(rtc->periodic_irq, sh_rtc_periodic, IRQF_DISABLED,
+                /* register shared periodic/carry/alarm irq */
-                          "sh-rtc period", rtc);
+                ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
-        if (unlikely(ret)) {
+                                  IRQF_DISABLED, "sh-rtc", rtc);
-                dev_err(&pdev->dev,
+                if (unlikely(ret)) {
-                        "request period IRQ failed with %d, IRQ %d\n", ret,
+                        dev_err(&pdev->dev,
-                        rtc->periodic_irq);
+                                "request IRQ failed with %d, IRQ %d\n", ret,
-                goto err_unmap;
+                                rtc->periodic_irq);
-        }
+                        goto err_unmap;
+                }
+        } else {
+                /* register periodic/carry/alarm irqs */
+                ret = request_irq(rtc->periodic_irq, sh_rtc_periodic,
+                                  IRQF_DISABLED, "sh-rtc period", rtc);
+                if (unlikely(ret)) {
+                        dev_err(&pdev->dev,
+                                "request period IRQ failed with %d, IRQ %d\n",
+                                ret, rtc->periodic_irq);
+                        goto err_unmap;
+                }
-        ret = request_irq(rtc->carry_irq, sh_rtc_interrupt, IRQF_DISABLED,
+                ret = request_irq(rtc->carry_irq, sh_rtc_interrupt,
-                          "sh-rtc carry", rtc);
+                                  IRQF_DISABLED, "sh-rtc carry", rtc);
-        if (unlikely(ret)) {
+                if (unlikely(ret)) {
-                dev_err(&pdev->dev,
+                        dev_err(&pdev->dev,
-                        "request carry IRQ failed with %d, IRQ %d\n", ret,
+                                "request carry IRQ failed with %d, IRQ %d\n",
-                        rtc->carry_irq);
+                                ret, rtc->carry_irq);
-                free_irq(rtc->periodic_irq, rtc);
+                        free_irq(rtc->periodic_irq, rtc);
-                goto err_unmap;
+                        goto err_unmap;
-        }
+                }
-        ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
+                ret = request_irq(rtc->alarm_irq, sh_rtc_alarm,
-                          "sh-rtc alarm", rtc);
+                                  IRQF_DISABLED, "sh-rtc alarm", rtc);
-        if (unlikely(ret)) {
+                if (unlikely(ret)) {
-                dev_err(&pdev->dev,
+                        dev_err(&pdev->dev,
-                        "request alarm IRQ failed with %d, IRQ %d\n", ret,
+                                "request alarm IRQ failed with %d, IRQ %d\n",
-                        rtc->alarm_irq);
+                                ret, rtc->alarm_irq);
-                free_irq(rtc->carry_irq, rtc);
+                        free_irq(rtc->carry_irq, rtc);
-                free_irq(rtc->periodic_irq, rtc);
+                        free_irq(rtc->periodic_irq, rtc);
-                goto err_unmap;
+                        goto err_unmap;
+                }
        }
-        tmp = readb(rtc->regbase + RCR1);
+        /* everything disabled by default */
-        tmp &= ~RCR1_CF;
+        rtc->periodic_freq = 0;
-        tmp |= RCR1_CIE;
+        rtc->rtc_dev->irq_freq = 0;
-        writeb(tmp, rtc->regbase + RCR1);
+        sh_rtc_setpie(&pdev->dev, 0);
+        sh_rtc_setaie(&pdev->dev, 0);
+        sh_rtc_setcie(&pdev->dev, 0);
+        /* reset rtc to epoch 0 if time is invalid */
+        if (rtc_read_time(rtc->rtc_dev, &r) < 0) {
+                rtc_time_to_tm(0, &r);
+                rtc_set_time(rtc->rtc_dev, &r);
+        }
+        device_init_wakeup(&pdev->dev, 1);
        return 0;
 err_unmap:
@@ -708,10 +777,13 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
        sh_rtc_setpie(&pdev->dev, 0);
        sh_rtc_setaie(&pdev->dev, 0);
+        sh_rtc_setcie(&pdev->dev, 0);
-        free_irq(rtc->carry_irq, rtc);
        free_irq(rtc->periodic_irq, rtc);
-        free_irq(rtc->alarm_irq, rtc);
+        if (rtc->carry_irq > 0) {
+                free_irq(rtc->carry_irq, rtc);
+                free_irq(rtc->alarm_irq, rtc);
+        }
        release_resource(rtc->res);
diff --git a/drivers/rtc/rtc-twl4030.c b/drivers/rtc/rtc-twl4030.c
index ad35f76c46b7..a6341e4f9a0f 100644
--- a/drivers/rtc/rtc-twl4030.c
+++ b/drivers/rtc/rtc-twl4030.c
@@ -426,7 +426,7 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
        ret = request_irq(irq, twl4030_rtc_interrupt,
                                IRQF_TRIGGER_RISING,
-                                rtc->dev.bus_id, rtc);
+                                dev_name(&rtc->dev), rtc);
        if (ret < 0) {
                dev_err(&pdev->dev, "IRQ is not free.\n");
                goto out1;
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 918e6fce2573..b91c1719b075 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -104,8 +104,9 @@ ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const
        rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
 out:
        if (rc) {
-                /* Release onoff "lock" when ungrouping failed. */
+                if (rc != -EAGAIN)
-                atomic_set(&gdev->onoff, 0);
+                        /* Release onoff "lock" when ungrouping failed. */
+                        atomic_set(&gdev->onoff, 0);
                return rc;
        }
        return count;
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index 0a2f2edafc03..93eca1731b81 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -84,8 +84,8 @@ static int chsc_subchannel_probe(struct subchannel *sch)
                kfree(private);
        } else {
                sch->private = private;
-                if (sch->dev.uevent_suppress) {
+                if (dev_get_uevent_suppress(&sch->dev)) {
-                        sch->dev.uevent_suppress = 0;
+                        dev_set_uevent_suppress(&sch->dev, 0);
                        kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
                }
        }
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 8019288bc6de..427d11d88069 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -272,7 +272,7 @@ static int css_register_subchannel(struct subchannel *sch)
         * the subchannel driver can decide itself when it wants to inform
         * userspace of its existence.
         */
-        sch->dev.uevent_suppress = 1;
+        dev_set_uevent_suppress(&sch->dev, 1);
        css_update_ssd_info(sch);
        /* make it known to the system */
        ret = css_sch_device_register(sch);
@@ -287,7 +287,7 @@ static int css_register_subchannel(struct subchannel *sch)
                 * a fitting driver module may be loaded based on the
                 * modalias.
                 */
-                sch->dev.uevent_suppress = 0;
+                dev_set_uevent_suppress(&sch->dev, 0);
                kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
        }
        return ret;
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 23d5752349b5..e28f8ae53453 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -799,7 +799,7 @@ static void sch_attach_disconnected_device(struct subchannel *sch,
                return;
        other_sch = to_subchannel(cdev->dev.parent);
        /* Note: device_move() changes cdev->dev.parent */
-        ret = device_move(&cdev->dev, &sch->dev);
+        ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
        if (ret) {
                CIO_MSG_EVENT(0, "Moving disconnected device 0.%x.%04x failed "
                              "(ret=%d)!\n", cdev->private->dev_id.ssid,
@@ -830,7 +830,7 @@ static void sch_attach_orphaned_device(struct subchannel *sch,
         * Try to move the ccw device to its new subchannel.
         * Note: device_move() changes cdev->dev.parent
         */
-        ret = device_move(&cdev->dev, &sch->dev);
+        ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
        if (ret) {
                CIO_MSG_EVENT(0, "Moving device 0.%x.%04x from orphanage "
                              "failed (ret=%d)!\n",
@@ -897,7 +897,8 @@ void ccw_device_move_to_orphanage(struct work_struct *work)
         * ccw device can take its place on the subchannel.
         * Note: device_move() changes cdev->dev.parent
         */
-        ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev);
+        ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev,
+                DPM_ORDER_NONE);
        if (ret) {
                CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to orphanage failed "
                              "(ret=%d)!\n", cdev->private->dev_id.ssid,
@@ -981,7 +982,7 @@ io_subchannel_register(struct work_struct *work)
         * Now we know this subchannel will stay, we can throw
         * our delayed uevent.
         */
-        sch->dev.uevent_suppress = 0;
+        dev_set_uevent_suppress(&sch->dev, 0);
        kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
        /* make it known to the system */
        ret = ccw_device_register(cdev);
@@ -1129,7 +1130,7 @@ static void ccw_device_move_to_sch(struct work_struct *work)
         * Try to move the ccw device to its new subchannel.
         * Note: device_move() changes cdev->dev.parent
         */
-        rc = device_move(&cdev->dev, &sch->dev);
+        rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
        mutex_unlock(&sch->reg_mutex);
        if (rc) {
                CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to subchannel "
@@ -1243,7 +1244,7 @@ static int io_subchannel_probe(struct subchannel *sch)
                 * the ccw_device and exit. This happens for all early
                 * devices, e.g. the console.
                 */
-                sch->dev.uevent_suppress = 0;
+                dev_set_uevent_suppress(&sch->dev, 0);
                kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
                cdev->dev.groups = ccwdev_attr_groups;
                device_initialize(&cdev->dev);
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 3d04920b9bb9..0dcc036d34aa 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -1038,7 +1038,7 @@ static int qeth_l3_setadapter_parms(struct qeth_card *card)
        rc = qeth_query_setadapterparms(card);
        if (rc) {
                QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
-                        "0x%x\n", card->gdev->dev.bus_id, rc);
+                        "0x%x\n", dev_name(&card->gdev->dev), rc);
                return rc;
        }
        if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
diff --git a/drivers/scsi/a4000t.c b/drivers/scsi/a4000t.c
index d4bda2017746..61af3d91ac8a 100644
--- a/drivers/scsi/a4000t.c
+++ b/drivers/scsi/a4000t.c
@@ -35,7 +35,7 @@ static struct platform_device *a4000t_scsi_device;
 #define A4000T_SCSI_ADDR 0xdd0040
-static int __devinit a4000t_probe(struct device *dev)
+static int __devinit a4000t_probe(struct platform_device *dev)
 {
        struct Scsi_Host *host;
        struct NCR_700_Host_Parameters *hostdata;
@@ -61,7 +61,8 @@ static int __devinit a4000t_probe(struct device *dev)
        hostdata->dcntl_extra = EA_710;
        /* and register the chip */
-        host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata,
+                              &dev->dev);
        if (!host) {
                printk(KERN_ERR "a4000t-scsi: No host detected; "
                                "board configuration problem?\n");
@@ -78,7 +79,7 @@ static int __devinit a4000t_probe(struct device *dev)
                goto out_put_host;
        }
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
        scsi_scan_host(host);
        return 0;
@@ -93,9 +94,9 @@ static int __devinit a4000t_probe(struct device *dev)
        return -ENODEV;
 }
-static __devexit int a4000t_device_remove(struct device *dev)
+static __devexit int a4000t_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
        struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
        scsi_remove_host(host);
@@ -108,25 +109,27 @@ static __devexit int a4000t_device_remove(struct device *dev)
        return 0;
 }
-static struct device_driver a4000t_scsi_driver = {
+static struct platform_driver a4000t_scsi_driver = {
-        .name   = "a4000t-scsi",
+        .driver = {
-        .bus    = &platform_bus_type,
+                .name           = "a4000t-scsi",
-        .probe  = a4000t_probe,
+                .owner          = THIS_MODULE,
-        .remove = __devexit_p(a4000t_device_remove),
+        },
+        .probe          = a4000t_probe,
+        .remove         = __devexit_p(a4000t_device_remove),
 };
 static int __init a4000t_scsi_init(void)
 {
        int err;
-        err = driver_register(&a4000t_scsi_driver);
+        err = platform_driver_register(&a4000t_scsi_driver);
        if (err)
                return err;
        a4000t_scsi_device = platform_device_register_simple("a4000t-scsi",
                        -1, NULL, 0);
        if (IS_ERR(a4000t_scsi_device)) {
-                driver_unregister(&a4000t_scsi_driver);
+                platform_driver_register(&a4000t_scsi_driver);
                return PTR_ERR(a4000t_scsi_device);
        }
@@ -136,7 +139,7 @@ static int __init a4000t_scsi_init(void)
 static void __exit a4000t_scsi_exit(void)
 {
        platform_device_unregister(a4000t_scsi_device);
-        driver_unregister(&a4000t_scsi_driver);
+        platform_driver_unregister(&a4000t_scsi_driver);
 }
 module_init(a4000t_scsi_init);
diff --git a/drivers/scsi/bvme6000_scsi.c b/drivers/scsi/bvme6000_scsi.c
index d858f3d41274..5799cb5cba6b 100644
--- a/drivers/scsi/bvme6000_scsi.c
+++ b/drivers/scsi/bvme6000_scsi.c
@@ -34,7 +34,7 @@ static struct scsi_host_template bvme6000_scsi_driver_template = {
 static struct platform_device *bvme6000_scsi_device;
 static __devinit int
-bvme6000_probe(struct device *dev)
+bvme6000_probe(struct platform_device *dev)
 {
        struct Scsi_Host *host;
        struct NCR_700_Host_Parameters *hostdata;
@@ -58,7 +58,8 @@ bvme6000_probe(struct device *dev)
        hostdata->ctest7_extra = CTEST7_TT1;
        /* and register the chip */
-        host = NCR_700_detect(&bvme6000_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&bvme6000_scsi_driver_template, hostdata,
+                              &dev->dev);
        if (!host) {
                printk(KERN_ERR "bvme6000-scsi: No host detected; "
                                "board configuration problem?\n");
@@ -73,7 +74,7 @@ bvme6000_probe(struct device *dev)
                goto out_put_host;
        }
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
        scsi_scan_host(host);
        return 0;
@@ -87,9 +88,9 @@ bvme6000_probe(struct device *dev)
 }
 static __devexit int
-bvme6000_device_remove(struct device *dev)
+bvme6000_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
        struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
        scsi_remove_host(host);
@@ -100,25 +101,27 @@ bvme6000_device_remove(struct device *dev)
        return 0;
 }
-static struct device_driver bvme6000_scsi_driver = {
+static struct platform_driver bvme6000_scsi_driver = {
-        .name   = "bvme6000-scsi",
+        .driver = {
-        .bus    = &platform_bus_type,
+                .name           = "bvme6000-scsi",
-        .probe  = bvme6000_probe,
+                .owner          = THIS_MODULE,
-        .remove = __devexit_p(bvme6000_device_remove),
+        },
+        .probe          = bvme6000_probe,
+        .remove         = __devexit_p(bvme6000_device_remove),
 };
 static int __init bvme6000_scsi_init(void)
 {
        int err;
-        err = driver_register(&bvme6000_scsi_driver);
+        err = platform_driver_register(&bvme6000_scsi_driver);
        if (err)
                return err;
        bvme6000_scsi_device = platform_device_register_simple("bvme6000-scsi",
                                                               -1, NULL, 0);
        if (IS_ERR(bvme6000_scsi_device)) {
-                driver_unregister(&bvme6000_scsi_driver);
+                platform_driver_unregister(&bvme6000_scsi_driver);
                return PTR_ERR(bvme6000_scsi_device);
        }
@@ -128,7 +131,7 @@ static int __init bvme6000_scsi_init(void)
 static void __exit bvme6000_scsi_exit(void)
 {
        platform_device_unregister(bvme6000_scsi_device);
-        driver_unregister(&bvme6000_scsi_driver);
+        platform_driver_unregister(&bvme6000_scsi_driver);
 }
 module_init(bvme6000_scsi_init);
diff --git a/drivers/scsi/mvme16x_scsi.c b/drivers/scsi/mvme16x_scsi.c
index b264b499d982..b5fbfd6ce870 100644
--- a/drivers/scsi/mvme16x_scsi.c
+++ b/drivers/scsi/mvme16x_scsi.c
@@ -34,7 +34,7 @@ static struct scsi_host_template mvme16x_scsi_driver_template = {
 static struct platform_device *mvme16x_scsi_device;
 static __devinit int
-mvme16x_probe(struct device *dev)
+mvme16x_probe(struct platform_device *dev)
 {
        struct Scsi_Host * host = NULL;
        struct NCR_700_Host_Parameters *hostdata;
@@ -64,7 +64,8 @@ mvme16x_probe(struct device *dev)
        hostdata->ctest7_extra = CTEST7_TT1;
        /* and register the chip */
-        host = NCR_700_detect(&mvme16x_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&mvme16x_scsi_driver_template, hostdata,
+                              &dev->dev);
        if (!host) {
                printk(KERN_ERR "mvme16x-scsi: No host detected; "
                                "board configuration problem?\n");
@@ -88,7 +89,7 @@ mvme16x_probe(struct device *dev)
                out_be32(0xfff4202c, v);
        }
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
        scsi_scan_host(host);
        return 0;
@@ -102,9 +103,9 @@ mvme16x_probe(struct device *dev)
 }
 static __devexit int
-mvme16x_device_remove(struct device *dev)
+mvme16x_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
        struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
        /* Disable scsi chip ints */
@@ -123,25 +124,27 @@ mvme16x_device_remove(struct device *dev)
        return 0;
 }
-static struct device_driver mvme16x_scsi_driver = {
+static struct platform_driver mvme16x_scsi_driver = {
-        .name   = "mvme16x-scsi",
+        .driver = {
-        .bus    = &platform_bus_type,
+                .name           = "mvme16x-scsi",
-        .probe  = mvme16x_probe,
+                .owner          = THIS_MODULE,
-        .remove = __devexit_p(mvme16x_device_remove),
+        },
+        .probe          = mvme16x_probe,
+        .remove         = __devexit_p(mvme16x_device_remove),
 };
 static int __init mvme16x_scsi_init(void)
 {
        int err;
-        err = driver_register(&mvme16x_scsi_driver);
+        err = platform_driver_register(&mvme16x_scsi_driver);
        if (err)
                return err;
        mvme16x_scsi_device = platform_device_register_simple("mvme16x-scsi",
                                                              -1, NULL, 0);
        if (IS_ERR(mvme16x_scsi_device)) {
-                driver_unregister(&mvme16x_scsi_driver);
+                platform_driver_unregister(&mvme16x_scsi_driver);
                return PTR_ERR(mvme16x_scsi_device);
        }
@@ -151,7 +154,7 @@ static int __init mvme16x_scsi_init(void)
 static void __exit mvme16x_scsi_exit(void)
 {
        platform_device_unregister(mvme16x_scsi_device);
-        driver_unregister(&mvme16x_scsi_driver);
+        platform_driver_unregister(&mvme16x_scsi_driver);
 }
 module_init(mvme16x_scsi_init);
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 557b54ab2f25..dbf5357a77b3 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -139,7 +139,7 @@ static void sci_poll_put_char(struct uart_port *port, unsigned char c)
        } while (!(status & SCxSR_TDxE(port)));
        sci_in(port, SCxSR);            /* Dummy read */
-        sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port));
+        sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port) & ~SCxSR_TEND(port));
        sci_out(port, SCxTDR, c);
 }
 #endif /* CONFIG_CONSOLE_POLL || CONFIG_SERIAL_SH_SCI_CONSOLE */
@@ -263,6 +263,7 @@ static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7763) || \
      defined(CONFIG_CPU_SUBTYPE_SH7780) || \
      defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7786) || \
      defined(CONFIG_CPU_SUBTYPE_SHX3)
 static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
 {
@@ -284,7 +285,8 @@ static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7785)
+    defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7786)
 static inline int scif_txroom(struct uart_port *port)
 {
        return SCIF_TXROOM_MAX - (sci_in(port, SCTFDR) & 0xff);
@@ -1095,6 +1097,7 @@ static void serial_console_write(struct console *co, const char *s,
                                 unsigned count)
 {
        struct uart_port *port = &serial_console_port->port;
+        unsigned short bits;
        int i;
        for (i = 0; i < count; i++) {
@@ -1103,6 +1106,11 @@ static void serial_console_write(struct console *co, const char *s,
                sci_poll_put_char(port, *s++);
        }
+        /* wait until fifo is empty and last bit has been transmitted */
+        bits = SCxSR_TDxE(port) | SCxSR_TEND(port);
+        while ((sci_in(port, SCxSR) & bits) != bits)
+                cpu_relax();
 }
 static int __init serial_console_setup(struct console *co, char *options)
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 022e89ffec1d..d0aa82d7fce0 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -1,6 +1,6 @@
 #include <linux/serial_core.h>
 #include <asm/io.h>
-#include <asm/gpio.h>
+#include <linux/gpio.h>
 #if defined(CONFIG_H83007) || defined(CONFIG_H83068)
 #include <asm/regs306x.h>
@@ -126,7 +126,8 @@
 # define SCSPTR1        0xffe10024      /* 16 bit SCIF */
 # define SCIF_ORER      0x0001          /* Overrun error bit */
 # define SCSCR_INIT(port)       0x3a    /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7785)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7786)
 # define SCSPTR0        0xffea0024      /* 16 bit SCIF */
 # define SCSPTR1        0xffeb0024      /* 16 bit SCIF */
 # define SCSPTR2        0xffec0024      /* 16 bit SCIF */
@@ -182,6 +183,7 @@
    defined(CONFIG_CPU_SUBTYPE_SH7763)  || \
    defined(CONFIG_CPU_SUBTYPE_SH7780)  || \
    defined(CONFIG_CPU_SUBTYPE_SH7785)  || \
+    defined(CONFIG_CPU_SUBTYPE_SH7786)  || \
    defined(CONFIG_CPU_SUBTYPE_SHX3)
 #define SCI_CTRL_FLAGS_REIE 0x08 /* 7750 SCIF */
 #else
@@ -413,7 +415,8 @@ SCIx_FNS(SCxRDR, 0x0a,  8, 0x14,  8, 0x0A,  8, 0x14,  8, 0x05,  8)
 SCIF_FNS(SCFCR,                      0x0c,  8, 0x18, 16)
 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7785)
+    defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7786)
 SCIF_FNS(SCFDR,                      0x0e, 16, 0x1C, 16)
 SCIF_FNS(SCTFDR,                     0x0e, 16, 0x1C, 16)
 SCIF_FNS(SCRFDR,                     0x0e, 16, 0x20, 16)
@@ -644,7 +647,8 @@ static inline int sci_rxd_in(struct uart_port *port)
                return ctrl_inw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
        return 1;
 }
-#elif defined(CONFIG_CPU_SUBTYPE_SH7785)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7786)
 static inline int sci_rxd_in(struct uart_port *port)
 {
        if (port->mapbase == 0xffea0000)
@@ -746,7 +750,8 @@ static inline int sci_rxd_in(struct uart_port *port)
 */
 #if defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7785)
+    defined(CONFIG_CPU_SUBTYPE_SH7785) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7786)
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(16*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
      defined(CONFIG_CPU_SUBTYPE_SH7720) || \
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index 45a299f35617..e09d3cebb4fb 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -1438,12 +1438,12 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
        } else {
                printk(KERN_INFO "%s: Keyboard at MMIO 0x%llx (irq = %d) "
                       "is a %s\n",
-                       op->dev.bus_id,
+                       dev_name(&op->dev),
                       (unsigned long long) up[0].port.mapbase,
                       op->irqs[0], sunzilog_type(&up[0].port));
                printk(KERN_INFO "%s: Mouse at MMIO 0x%llx (irq = %d) "
                       "is a %s\n",
-                       op->dev.bus_id,
+                       dev_name(&op->dev),
                       (unsigned long long) up[1].port.mapbase,
                       op->irqs[0], sunzilog_type(&up[1].port));
                kbm_inst++;
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index 58d24c5a76ce..2269fbcaa182 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -568,6 +568,10 @@ static void __init intc_register_irq(struct intc_desc *desc,
        if (!data[0] && data[1])
                primary = 1;
+        if (!data[0] && !data[1])
+                pr_warning("intc: missing unique irq mask for "
+                           "irq %d (vect 0x%04x)\n", irq, irq2evt(irq));
        data[0] = data[0] ? data[0] : intc_mask_data(desc, d, enum_id, 1);
        data[1] = data[1] ? data[1] : intc_prio_data(desc, d, enum_id, 1);
@@ -641,6 +645,17 @@ static unsigned int __init save_reg(struct intc_desc_int *d,
        return 0;
 }
+static unsigned char *intc_evt2irq_table;
+unsigned int intc_evt2irq(unsigned int vector)
+{
+        unsigned int irq = evt2irq(vector);
+        if (intc_evt2irq_table && intc_evt2irq_table[irq])
+                irq = intc_evt2irq_table[irq];
+        return irq;
+}
 void __init register_intc_controller(struct intc_desc *desc)
 {
@@ -705,9 +720,41 @@ void __init register_intc_controller(struct intc_desc *desc)
        BUG_ON(k > 256); /* _INTC_ADDR_E() and _INTC_ADDR_D() are 8 bits */
+        /* keep the first vector only if same enum is used multiple times */
+        for (i = 0; i < desc->nr_vectors; i++) {
+                struct intc_vect *vect = desc->vectors + i;
+                int first_irq = evt2irq(vect->vect);
+                if (!vect->enum_id)
+                        continue;
+                for (k = i + 1; k < desc->nr_vectors; k++) {
+                        struct intc_vect *vect2 = desc->vectors + k;
+                        if (vect->enum_id != vect2->enum_id)
+                                continue;
+                        vect2->enum_id = 0;
+                        if (!intc_evt2irq_table)
+                                intc_evt2irq_table = alloc_bootmem(NR_IRQS);
+                        if (!intc_evt2irq_table) {
+                                pr_warning("intc: cannot allocate evt2irq!\n");
+                                continue;
+                        }
+                        intc_evt2irq_table[evt2irq(vect2->vect)] = first_irq;
+                }
+        }
+        /* register the vectors one by one */
        for (i = 0; i < desc->nr_vectors; i++) {
                struct intc_vect *vect = desc->vectors + i;
+                if (!vect->enum_id)
+                        continue;
                intc_register_irq(desc, d, vect->enum_id, evt2irq(vect->vect));
        }
 }
diff --git a/drivers/sh/maple/maple.c b/drivers/sh/maple/maple.c
index 63f0de29aa14..cab1ab7cfb78 100644
--- a/drivers/sh/maple/maple.c
+++ b/drivers/sh/maple/maple.c
@@ -1,16 +1,10 @@
 /*
 * Core maple bus functionality
 *
- *  Copyright (C) 2007, 2008 Adrian McMenamin
+ *  Copyright (C) 2007 - 2009 Adrian McMenamin
 *  Copyright (C) 2001 - 2008 Paul Mundt
- *
+ *  Copyright (C) 2000 - 2001 YAEGASHI Takeshi
- * Based on 2.4 code by:
- *
- *  Copyright (C) 2000-2001 YAEGASHI Takeshi
 *  Copyright (C) 2001 M. R. Brown
- *  Copyright (C) 2001 Paul Mundt
- *
- * and others.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
@@ -32,7 +26,7 @@
 #include <mach/dma.h>
 #include <mach/sysasic.h>
-MODULE_AUTHOR("Yaegashi Takeshi, Paul Mundt, M. R. Brown, Adrian McMenamin");
+MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");
 MODULE_DESCRIPTION("Maple bus driver for Dreamcast");
 MODULE_LICENSE("GPL v2");
 MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
@@ -49,7 +43,7 @@ static LIST_HEAD(maple_sentq);
 /* mutex to protect queue of waiting packets */
 static DEFINE_MUTEX(maple_wlist_lock);
-static struct maple_driver maple_dummy_driver;
+static struct maple_driver maple_unsupported_device;
 static struct device maple_bus;
 static int subdevice_map[MAPLE_PORTS];
 static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr;
@@ -62,8 +56,9 @@ struct maple_device_specify {
        int unit;
 };
-static bool checked[4];
+static bool checked[MAPLE_PORTS];
-static struct maple_device *baseunits[4];
+static bool empty[MAPLE_PORTS];
+static struct maple_device *baseunits[MAPLE_PORTS];
 /**
 * maple_driver_register - register a maple driver
@@ -97,12 +92,20 @@ void maple_driver_unregister(struct maple_driver *drv)
 EXPORT_SYMBOL_GPL(maple_driver_unregister);
 /* set hardware registers to enable next round of dma */
-static void maplebus_dma_reset(void)
+static void maple_dma_reset(void)
 {
        ctrl_outl(MAPLE_MAGIC, MAPLE_RESET);
        /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */
        ctrl_outl(1, MAPLE_TRIGTYPE);
-        ctrl_outl(MAPLE_2MBPS | MAPLE_TIMEOUT(50000), MAPLE_SPEED);
+        /*
+        * Maple system register
+        * bits 31 - 16  timeout in units of 20nsec
+        * bit 12        hard trigger - set 0 to keep responding to VBLANK
+        * bits 9 - 8    set 00 for 2 Mbps, 01 for 1 Mbps
+        * bits 3 - 0    delay (in 1.3ms) between VBLANK and start of DMA
+        * max delay is 11
+        */
+        ctrl_outl(MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), MAPLE_SPEED);
        ctrl_outl(PHYSADDR(maple_sendbuf), MAPLE_DMAADDR);
        ctrl_outl(1, MAPLE_ENABLE);
 }
@@ -134,21 +137,16 @@ static void maple_release_device(struct device *dev)
 {
        struct maple_device *mdev;
        struct mapleq *mq;
-        if (!dev)
-                return;
        mdev = to_maple_dev(dev);
        mq = mdev->mq;
-        if (mq) {
+        kmem_cache_free(maple_queue_cache, mq->recvbuf);
-                if (mq->recvbufdcsp)
+        kfree(mq);
-                        kmem_cache_free(maple_queue_cache, mq->recvbufdcsp);
-                kfree(mq);
-                mq = NULL;
-        }
        kfree(mdev);
 }
 /**
- * maple_add_packet - add a single instruction to the queue
+ * maple_add_packet - add a single instruction to the maple bus queue
 * @mdev: maple device
 * @function: function on device being queried
 * @command: maple command to add
@@ -158,68 +156,12 @@ static void maple_release_device(struct device *dev)
 int maple_add_packet(struct maple_device *mdev, u32 function, u32 command,
        size_t length, void *data)
 {
-        int locking, ret = 0;
+        int ret = 0;
        void *sendbuf = NULL;
-        mutex_lock(&maple_wlist_lock);
-        /* bounce if device already locked */
-        locking = mutex_is_locked(&mdev->mq->mutex);
-        if (locking) {
-                ret = -EBUSY;
-                goto out;
-        }
-        mutex_lock(&mdev->mq->mutex);
        if (length) {
-                sendbuf = kmalloc(length * 4, GFP_KERNEL);
+                sendbuf = kzalloc(length * 4, GFP_KERNEL);
                if (!sendbuf) {
-                        mutex_unlock(&mdev->mq->mutex);
-                        ret = -ENOMEM;
-                        goto out;
-                }
-                ((__be32 *)sendbuf)[0] = cpu_to_be32(function);
-        }
-        mdev->mq->command = command;
-        mdev->mq->length = length;
-        if (length > 1)
-                memcpy(sendbuf + 4, data, (length - 1) * 4);
-        mdev->mq->sendbuf = sendbuf;
-        list_add(&mdev->mq->list, &maple_waitq);
-out:
-        mutex_unlock(&maple_wlist_lock);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(maple_add_packet);
-/**
- * maple_add_packet_sleeps - add a single instruction to the queue
- * @mdev: maple device
- * @function: function on device being queried
- * @command: maple command to add
- * @length: length of command string (in 32 bit words)
- * @data: remainder of command string
- *
- * Same as maple_add_packet(), but waits for the lock to become free.
- */
-int maple_add_packet_sleeps(struct maple_device *mdev, u32 function,
-        u32 command, size_t length, void *data)
-{
-        int locking, ret = 0;
-        void *sendbuf = NULL;
-        locking = mutex_lock_interruptible(&mdev->mq->mutex);
-        if (locking) {
-                ret = -EIO;
-                goto out;
-        }
-        if (length) {
-                sendbuf = kmalloc(length * 4, GFP_KERNEL);
-                if (!sendbuf) {
-                        mutex_unlock(&mdev->mq->mutex);
                        ret = -ENOMEM;
                        goto out;
                }
@@ -233,38 +175,35 @@ int maple_add_packet_sleeps(struct maple_device *mdev, u32 function,
        mdev->mq->sendbuf = sendbuf;
        mutex_lock(&maple_wlist_lock);
-        list_add(&mdev->mq->list, &maple_waitq);
+        list_add_tail(&mdev->mq->list, &maple_waitq);
        mutex_unlock(&maple_wlist_lock);
 out:
        return ret;
 }
-EXPORT_SYMBOL_GPL(maple_add_packet_sleeps);
+EXPORT_SYMBOL_GPL(maple_add_packet);
 static struct mapleq *maple_allocq(struct maple_device *mdev)
 {
        struct mapleq *mq;
-        mq = kmalloc(sizeof(*mq), GFP_KERNEL);
+        mq = kzalloc(sizeof(*mq), GFP_KERNEL);
        if (!mq)
                goto failed_nomem;
+        INIT_LIST_HEAD(&mq->list);
        mq->dev = mdev;
-        mq->recvbufdcsp = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL);
+        mq->recvbuf = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL);
-        mq->recvbuf = (void *) P2SEGADDR(mq->recvbufdcsp);
        if (!mq->recvbuf)
                goto failed_p2;
-        /*
+        mq->recvbuf->buf = &((mq->recvbuf->bufx)[0]);
-         * most devices do not need the mutex - but
-         * anything that injects block reads or writes
-         * will rely on it
-         */
-        mutex_init(&mq->mutex);
        return mq;
 failed_p2:
        kfree(mq);
 failed_nomem:
+        dev_err(&mdev->dev, "could not allocate memory for device (%d, %d)\n",
+                mdev->port, mdev->unit);
        return NULL;
 }
@@ -272,12 +211,16 @@ static struct maple_device *maple_alloc_dev(int port, int unit)
 {
        struct maple_device *mdev;
+        /* zero this out to avoid kobj subsystem
+        * thinking it has already been registered */
        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
        if (!mdev)
                return NULL;
        mdev->port = port;
        mdev->unit = unit;
        mdev->mq = maple_allocq(mdev);
        if (!mdev->mq) {
@@ -286,19 +229,14 @@ static struct maple_device *maple_alloc_dev(int port, int unit)
        }
        mdev->dev.bus = &maple_bus_type;
        mdev->dev.parent = &maple_bus;
+        init_waitqueue_head(&mdev->maple_wait);
        return mdev;
 }
 static void maple_free_dev(struct maple_device *mdev)
 {
-        if (!mdev)
+        kmem_cache_free(maple_queue_cache, mdev->mq->recvbuf);
-                return;
+        kfree(mdev->mq);
-        if (mdev->mq) {
-                if (mdev->mq->recvbufdcsp)
-                        kmem_cache_free(maple_queue_cache,
-                                mdev->mq->recvbufdcsp);
-                kfree(mdev->mq);
-        }
        kfree(mdev);
 }
@@ -320,7 +258,7 @@ static void maple_build_block(struct mapleq *mq)
        maple_lastptr = maple_sendptr;
        *maple_sendptr++ = (port << 16) | len | 0x80000000;
-        *maple_sendptr++ = PHYSADDR(mq->recvbuf);
+        *maple_sendptr++ = PHYSADDR(mq->recvbuf->buf);
        *maple_sendptr++ =
            mq->command | (to << 8) | (from << 16) | (len << 24);
        while (len-- > 0)
@@ -333,20 +271,28 @@ static void maple_send(void)
        int i, maple_packets = 0;
        struct mapleq *mq, *nmq;
-        if (!list_empty(&maple_sentq))
+        if (!maple_dma_done())
                return;
+        /* disable DMA */
+        ctrl_outl(0, MAPLE_ENABLE);
+        if (!list_empty(&maple_sentq))
+                goto finish;
        mutex_lock(&maple_wlist_lock);
-        if (list_empty(&maple_waitq) || !maple_dma_done()) {
+        if (list_empty(&maple_waitq)) {
                mutex_unlock(&maple_wlist_lock);
-                return;
+                goto finish;
        }
-        mutex_unlock(&maple_wlist_lock);
        maple_lastptr = maple_sendbuf;
        maple_sendptr = maple_sendbuf;
-        mutex_lock(&maple_wlist_lock);
        list_for_each_entry_safe(mq, nmq, &maple_waitq, list) {
                maple_build_block(mq);
-                list_move(&mq->list, &maple_sentq);
+                list_del_init(&mq->list);
+                list_add_tail(&mq->list, &maple_sentq);
                if (maple_packets++ > MAPLE_MAXPACKETS)
                        break;
        }
@@ -356,10 +302,13 @@ static void maple_send(void)
                        dma_cache_sync(0, maple_sendbuf + i * PAGE_SIZE,
                                       PAGE_SIZE, DMA_BIDIRECTIONAL);
        }
+finish:
+        maple_dma_reset();
 }
 /* check if there is a driver registered likely to match this device */
-static int check_matching_maple_driver(struct device_driver *driver,
+static int maple_check_matching_driver(struct device_driver *driver,
                                        void *devptr)
 {
        struct maple_driver *maple_drv;
@@ -374,10 +323,7 @@ static int check_matching_maple_driver(struct device_driver *driver,
 static void maple_detach_driver(struct maple_device *mdev)
 {
-        if (!mdev)
-                return;
        device_unregister(&mdev->dev);
-        mdev = NULL;
 }
 /* process initial MAPLE_COMMAND_DEVINFO for each device or port */
@@ -385,9 +331,9 @@ static void maple_attach_driver(struct maple_device *mdev)
 {
        char *p, *recvbuf;
        unsigned long function;
-        int matched, retval;
+        int matched, error;
-        recvbuf = mdev->mq->recvbuf;
+        recvbuf = mdev->mq->recvbuf->buf;
        /* copy the data as individual elements in
        * case of memory optimisation */
        memcpy(&mdev->devinfo.function, recvbuf + 4, 4);
@@ -395,7 +341,6 @@ static void maple_attach_driver(struct maple_device *mdev)
        memcpy(&mdev->devinfo.area_code, recvbuf + 20, 1);
        memcpy(&mdev->devinfo.connector_direction, recvbuf + 21, 1);
        memcpy(&mdev->devinfo.product_name[0], recvbuf + 22, 30);
-        memcpy(&mdev->devinfo.product_licence[0], recvbuf + 52, 60);
        memcpy(&mdev->devinfo.standby_power, recvbuf + 112, 2);
        memcpy(&mdev->devinfo.max_power, recvbuf + 114, 2);
        memcpy(mdev->product_name, mdev->devinfo.product_name, 30);
@@ -414,43 +359,39 @@ static void maple_attach_driver(struct maple_device *mdev)
                else
                        break;
-        printk(KERN_INFO "Maple device detected: %s\n",
-                mdev->product_name);
-        printk(KERN_INFO "Maple device: %s\n", mdev->product_licence);
        function = be32_to_cpu(mdev->devinfo.function);
+        dev_info(&mdev->dev, "detected %s: function 0x%lX: at (%d, %d)\n",
+                mdev->product_name, function, mdev->port, mdev->unit);
        if (function > 0x200) {
                /* Do this silently - as not a real device */
                function = 0;
-                mdev->driver = &maple_dummy_driver;
+                mdev->driver = &maple_unsupported_device;
-                sprintf(mdev->dev.bus_id, "%d:0.port", mdev->port);
+                dev_set_name(&mdev->dev, "%d:0.port", mdev->port);
        } else {
-                printk(KERN_INFO
-                        "Maple bus at (%d, %d): Function 0x%lX\n",
-                        mdev->port, mdev->unit, function);
                matched =
                        bus_for_each_drv(&maple_bus_type, NULL, mdev,
-                                check_matching_maple_driver);
+                                maple_check_matching_driver);
                if (matched == 0) {
                        /* Driver does not exist yet */
-                        printk(KERN_INFO
+                        dev_info(&mdev->dev, "no driver found\n");
-                                "No maple driver found.\n");
+                        mdev->driver = &maple_unsupported_device;
-                        mdev->driver = &maple_dummy_driver;
                }
-                sprintf(mdev->dev.bus_id, "%d:0%d.%lX", mdev->port,
+                dev_set_name(&mdev->dev, "%d:0%d.%lX", mdev->port,
-                        mdev->unit, function);
+                             mdev->unit, function);
        }
        mdev->function = function;
        mdev->dev.release = &maple_release_device;
-        retval = device_register(&mdev->dev);
-        if (retval) {
+        atomic_set(&mdev->busy, 0);
-                printk(KERN_INFO
+        error = device_register(&mdev->dev);
-                "Maple bus: Attempt to register device"
+        if (error) {
-                " (%x, %x) failed.\n",
+                dev_warn(&mdev->dev, "could not register device at"
-                mdev->port, mdev->unit);
+                        " (%d, %d), with error 0x%X\n", mdev->unit,
+                        mdev->port, error);
                maple_free_dev(mdev);
                mdev = NULL;
                return;
@@ -462,7 +403,7 @@ static void maple_attach_driver(struct maple_device *mdev)
 * port and unit then return 1 - allows identification
 * of which devices need to be attached or detached
 */
-static int detach_maple_device(struct device *device, void *portptr)
+static int check_maple_device(struct device *device, void *portptr)
 {
        struct maple_device_specify *ds;
        struct maple_device *mdev;
@@ -477,21 +418,25 @@ static int detach_maple_device(struct device *device, void *portptr)
 static int setup_maple_commands(struct device *device, void *ignored)
 {
        int add;
-        struct maple_device *maple_dev = to_maple_dev(device);
+        struct maple_device *mdev = to_maple_dev(device);
+        if (mdev->interval > 0 && atomic_read(&mdev->busy) == 0 &&
-        if ((maple_dev->interval > 0)
+                time_after(jiffies, mdev->when)) {
-            && time_after(jiffies, maple_dev->when)) {
+                /* bounce if we cannot add */
-                /* bounce if we cannot lock */
+                add = maple_add_packet(mdev,
-                add = maple_add_packet(maple_dev,
+                        be32_to_cpu(mdev->devinfo.function),
-                        be32_to_cpu(maple_dev->devinfo.function),
                        MAPLE_COMMAND_GETCOND, 1, NULL);
                if (!add)
-                        maple_dev->when = jiffies + maple_dev->interval;
+                        mdev->when = jiffies + mdev->interval;
        } else {
                if (time_after(jiffies, maple_pnp_time))
-                        /* This will also bounce */
+                        /* Ensure we don't have block reads and devinfo
-                        maple_add_packet(maple_dev, 0,
+                        * calls interfering with one another - so flag the
-                                MAPLE_COMMAND_DEVINFO, 0, NULL);
+                        * device as busy */
+                        if (atomic_read(&mdev->busy) == 0) {
+                                atomic_set(&mdev->busy, 1);
+                                maple_add_packet(mdev, 0,
+                                        MAPLE_COMMAND_DEVINFO, 0, NULL);
+                        }
        }
        return 0;
 }
@@ -499,29 +444,50 @@ static int setup_maple_commands(struct device *device, void *ignored)
 /* VBLANK bottom half - implemented via workqueue */
 static void maple_vblank_handler(struct work_struct *work)
 {
-        if (!list_empty(&maple_sentq) || !maple_dma_done())
+        int x, locking;
+        struct maple_device *mdev;
+        if (!maple_dma_done())
                return;
        ctrl_outl(0, MAPLE_ENABLE);
+        if (!list_empty(&maple_sentq))
+                goto finish;
+        /*
+        * Set up essential commands - to fetch data and
+        * check devices are still present
+        */
        bus_for_each_dev(&maple_bus_type, NULL, NULL,
-                         setup_maple_commands);
+                setup_maple_commands);
+        if (time_after(jiffies, maple_pnp_time)) {
+                /*
+                * Scan the empty ports - bus is flakey and may have
+                * mis-reported emptyness
+                */
+                for (x = 0; x < MAPLE_PORTS; x++) {
+                        if (checked[x] && empty[x]) {
+                                mdev = baseunits[x];
+                                if (!mdev)
+                                        break;
+                                atomic_set(&mdev->busy, 1);
+                                locking = maple_add_packet(mdev, 0,
+                                        MAPLE_COMMAND_DEVINFO, 0, NULL);
+                                if (!locking)
+                                        break;
+                                }
+                        }
-        if (time_after(jiffies, maple_pnp_time))
                maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL;
-        mutex_lock(&maple_wlist_lock);
-        if (!list_empty(&maple_waitq) && list_empty(&maple_sentq)) {
-                mutex_unlock(&maple_wlist_lock);
-                maple_send();
-        } else {
-                mutex_unlock(&maple_wlist_lock);
        }
-        maplebus_dma_reset();
+finish:
+        maple_send();
 }
-/* handle devices added via hotplugs - placing them on queue for DEVINFO*/
+/* handle devices added via hotplugs - placing them on queue for DEVINFO */
 static void maple_map_subunits(struct maple_device *mdev, int submask)
 {
        int retval, k, devcheck;
@@ -533,7 +499,7 @@ static void maple_map_subunits(struct maple_device *mdev, int submask)
                ds.unit = k + 1;
                retval =
                    bus_for_each_dev(&maple_bus_type, NULL, &ds,
-                                     detach_maple_device);
+                                     check_maple_device);
                if (retval) {
                        submask = submask >> 1;
                        continue;
@@ -543,6 +509,7 @@ static void maple_map_subunits(struct maple_device *mdev, int submask)
                        mdev_add = maple_alloc_dev(mdev->port, k + 1);
                        if (!mdev_add)
                                return;
+                        atomic_set(&mdev_add->busy, 1);
                        maple_add_packet(mdev_add, 0, MAPLE_COMMAND_DEVINFO,
                                0, NULL);
                        /* mark that we are checking sub devices */
@@ -564,27 +531,45 @@ static void maple_clean_submap(struct maple_device *mdev)
 }
 /* handle empty port or hotplug removal */
-static void maple_response_none(struct maple_device *mdev,
+static void maple_response_none(struct maple_device *mdev)
-                                struct mapleq *mq)
+{
-{
+        maple_clean_submap(mdev);
-        if (mdev->unit != 0) {
-                list_del(&mq->list);
+        if (likely(mdev->unit != 0)) {
-                maple_clean_submap(mdev);
+                /*
-                printk(KERN_INFO
+                * Block devices play up
-                       "Maple bus device detaching at (%d, %d)\n",
+                * and give the impression they have
-                       mdev->port, mdev->unit);
+                * been removed even when still in place or
+                * trip the mtd layer when they have
+                * really gone - this code traps that eventuality
+                * and ensures we aren't overloaded with useless
+                * error messages
+                */
+                if (mdev->can_unload) {
+                        if (!mdev->can_unload(mdev)) {
+                                atomic_set(&mdev->busy, 2);
+                                wake_up(&mdev->maple_wait);
+                                return;
+                        }
+                }
+                dev_info(&mdev->dev, "detaching device at (%d, %d)\n",
+                        mdev->port, mdev->unit);
                maple_detach_driver(mdev);
                return;
-        }
+        } else {
-        if (!started || !fullscan) {
+                if (!started || !fullscan) {
-                if (checked[mdev->port] == false) {
+                        if (checked[mdev->port] == false) {
-                        checked[mdev->port] = true;
+                                checked[mdev->port] = true;
-                        printk(KERN_INFO "No maple devices attached"
+                                empty[mdev->port] = true;
-                                " to port %d\n", mdev->port);
+                                dev_info(&mdev->dev, "no devices"
+                                        " to port %d\n", mdev->port);
+                        }
+                        return;
                }
-                return;
        }
-        maple_clean_submap(mdev);
+        /* Some hardware devices generate false detach messages on unit 0 */
+        atomic_set(&mdev->busy, 0);
 }
 /* preprocess hotplugs or scans */
@@ -599,8 +584,11 @@ static void maple_response_devinfo(struct maple_device *mdev,
                } else {
                        if (mdev->unit != 0)
                                maple_attach_driver(mdev);
+                        if (mdev->unit == 0) {
+                                empty[mdev->port] = false;
+                                maple_attach_driver(mdev);
+                        }
                }
-                return;
        }
        if (mdev->unit == 0) {
                submask = recvbuf[2] & 0x1F;
@@ -611,6 +599,17 @@ static void maple_response_devinfo(struct maple_device *mdev,
        }
 }
+static void maple_response_fileerr(struct maple_device *mdev, void *recvbuf)
+{
+        if (mdev->fileerr_handler) {
+                mdev->fileerr_handler(mdev, recvbuf);
+                return;
+        } else
+                dev_warn(&mdev->dev, "device at (%d, %d) reports"
+                        "file error 0x%X\n", mdev->port, mdev->unit,
+                        ((int *)recvbuf)[1]);
+}
 static void maple_port_rescan(void)
 {
        int i;
@@ -621,12 +620,6 @@ static void maple_port_rescan(void)
                if (checked[i] == false) {
                        fullscan = 0;
                        mdev = baseunits[i];
-                        /*
-                         *  test lock in case scan has failed
-                         *  but device is still locked
-                         */
-                        if (mutex_is_locked(&mdev->mq->mutex))
-                                mutex_unlock(&mdev->mq->mutex);
                        maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO,
                                0, NULL);
                }
@@ -637,7 +630,7 @@ static void maple_port_rescan(void)
 static void maple_dma_handler(struct work_struct *work)
 {
        struct mapleq *mq, *nmq;
-        struct maple_device *dev;
+        struct maple_device *mdev;
        char *recvbuf;
        enum maple_code code;
@@ -646,43 +639,56 @@ static void maple_dma_handler(struct work_struct *work)
        ctrl_outl(0, MAPLE_ENABLE);
        if (!list_empty(&maple_sentq)) {
                list_for_each_entry_safe(mq, nmq, &maple_sentq, list) {
-                        recvbuf = mq->recvbuf;
+                        mdev = mq->dev;
+                        recvbuf = mq->recvbuf->buf;
+                        dma_cache_sync(&mdev->dev, recvbuf, 0x400,
+                                DMA_FROM_DEVICE);
                        code = recvbuf[0];
-                        dev = mq->dev;
                        kfree(mq->sendbuf);
-                        mutex_unlock(&mq->mutex);
                        list_del_init(&mq->list);
                        switch (code) {
                        case MAPLE_RESPONSE_NONE:
-                                maple_response_none(dev, mq);
+                                maple_response_none(mdev);
                                break;
                        case MAPLE_RESPONSE_DEVINFO:
-                                maple_response_devinfo(dev, recvbuf);
+                                maple_response_devinfo(mdev, recvbuf);
+                                atomic_set(&mdev->busy, 0);
                                break;
                        case MAPLE_RESPONSE_DATATRF:
-                                if (dev->callback)
+                                if (mdev->callback)
-                                        dev->callback(mq);
+                                        mdev->callback(mq);
+                                atomic_set(&mdev->busy, 0);
+                                wake_up(&mdev->maple_wait);
                                break;
                        case MAPLE_RESPONSE_FILEERR:
+                                maple_response_fileerr(mdev, recvbuf);
+                                atomic_set(&mdev->busy, 0);
+                                wake_up(&mdev->maple_wait);
+                                break;
                        case MAPLE_RESPONSE_AGAIN:
                        case MAPLE_RESPONSE_BADCMD:
                        case MAPLE_RESPONSE_BADFUNC:
-                                printk(KERN_DEBUG
+                                dev_warn(&mdev->dev, "non-fatal error"
-                                       "Maple non-fatal error 0x%X\n",
+                                        " 0x%X at (%d, %d)\n", code,
-                                       code);
+                                        mdev->port, mdev->unit);
+                                atomic_set(&mdev->busy, 0);
                                break;
                        case MAPLE_RESPONSE_ALLINFO:
-                                printk(KERN_DEBUG
+                                dev_notice(&mdev->dev, "extended"
-                                       "Maple - extended device information"
+                                " device information request for (%d, %d)"
-                                        " not supported\n");
+                                " but call is not supported\n", mdev->port,
+                                mdev->unit);
+                                atomic_set(&mdev->busy, 0);
                                break;
                        case MAPLE_RESPONSE_OK:
+                                atomic_set(&mdev->busy, 0);
+                                wake_up(&mdev->maple_wait);
                                break;
                        default:
@@ -699,20 +705,19 @@ static void maple_dma_handler(struct work_struct *work)
                if (!fullscan)
                        maple_port_rescan();
                /* mark that we have been through the first scan */
-                if (started == 0)
+                started = 1;
-                        started = 1;
        }
-        maplebus_dma_reset();
+        maple_send();
 }
-static irqreturn_t maplebus_dma_interrupt(int irq, void *dev_id)
+static irqreturn_t maple_dma_interrupt(int irq, void *dev_id)
 {
        /* Load everything into the bottom half */
        schedule_work(&maple_dma_process);
        return IRQ_HANDLED;
 }
-static irqreturn_t maplebus_vblank_interrupt(int irq, void *dev_id)
+static irqreturn_t maple_vblank_interrupt(int irq, void *dev_id)
 {
        schedule_work(&maple_vblank_process);
        return IRQ_HANDLED;
@@ -720,14 +725,14 @@ static irqreturn_t maplebus_vblank_interrupt(int irq, void *dev_id)
 static int maple_set_dma_interrupt_handler(void)
 {
-        return request_irq(HW_EVENT_MAPLE_DMA, maplebus_dma_interrupt,
+        return request_irq(HW_EVENT_MAPLE_DMA, maple_dma_interrupt,
-                IRQF_SHARED, "maple bus DMA", &maple_dummy_driver);
+                IRQF_SHARED, "maple bus DMA", &maple_unsupported_device);
 }
 static int maple_set_vblank_interrupt_handler(void)
 {
-        return request_irq(HW_EVENT_VSYNC, maplebus_vblank_interrupt,
+        return request_irq(HW_EVENT_VSYNC, maple_vblank_interrupt,
-                IRQF_SHARED, "maple bus VBLANK", &maple_dummy_driver);
+                IRQF_SHARED, "maple bus VBLANK", &maple_unsupported_device);
 }
 static int maple_get_dma_buffer(void)
@@ -740,7 +745,7 @@ static int maple_get_dma_buffer(void)
        return 0;
 }
-static int match_maple_bus_driver(struct device *devptr,
+static int maple_match_bus_driver(struct device *devptr,
                                  struct device_driver *drvptr)
 {
        struct maple_driver *maple_drv = to_maple_driver(drvptr);
@@ -765,22 +770,24 @@ static void maple_bus_release(struct device *dev)
 {
 }
-static struct maple_driver maple_dummy_driver = {
+static struct maple_driver maple_unsupported_device = {
        .drv = {
-                .name = "maple_dummy_driver",
+                .name = "maple_unsupported_device",
                .bus = &maple_bus_type,
        },
 };
+/**
+ * maple_bus_type - core maple bus structure
+ */
 struct bus_type maple_bus_type = {
        .name = "maple",
-        .match = match_maple_bus_driver,
+        .match = maple_match_bus_driver,
        .uevent = maple_bus_uevent,
 };
 EXPORT_SYMBOL_GPL(maple_bus_type);
 static struct device maple_bus = {
-        .bus_id = "maple",
+        .init_name = "maple",
        .release = maple_bus_release,
 };
@@ -788,7 +795,8 @@ static int __init maple_bus_init(void)
 {
        int retval, i;
        struct maple_device *mdev[MAPLE_PORTS];
-        ctrl_outl(0, MAPLE_STATE);
+        ctrl_outl(0, MAPLE_ENABLE);
        retval = device_register(&maple_bus);
        if (retval)
@@ -798,36 +806,33 @@ static int __init maple_bus_init(void)
        if (retval)
                goto cleanup_device;
-        retval = driver_register(&maple_dummy_driver.drv);
+        retval = driver_register(&maple_unsupported_device.drv);
        if (retval)
                goto cleanup_bus;
        /* allocate memory for maple bus dma */
        retval = maple_get_dma_buffer();
        if (retval) {
-                printk(KERN_INFO
+                dev_err(&maple_bus, "failed to allocate DMA buffers\n");
-                       "Maple bus: Failed to allocate Maple DMA buffers\n");
                goto cleanup_basic;
        }
        /* set up DMA interrupt handler */
        retval = maple_set_dma_interrupt_handler();
        if (retval) {
-                printk(KERN_INFO
+                dev_err(&maple_bus, "bus failed to grab maple "
-                       "Maple bus: Failed to grab maple DMA IRQ\n");
+                        "DMA IRQ\n");
                goto cleanup_dma;
        }
        /* set up VBLANK interrupt handler */
        retval = maple_set_vblank_interrupt_handler();
        if (retval) {
-                printk(KERN_INFO "Maple bus: Failed to grab VBLANK IRQ\n");
+                dev_err(&maple_bus, "bus failed to grab VBLANK IRQ\n");
                goto cleanup_irq;
        }
-        maple_queue_cache =
+        maple_queue_cache = KMEM_CACHE(maple_buffer, SLAB_HWCACHE_ALIGN);
-            kmem_cache_create("maple_queue_cache", 0x400, 0,
-                              SLAB_HWCACHE_ALIGN, NULL);
        if (!maple_queue_cache)
                goto cleanup_bothirqs;
@@ -838,23 +843,23 @@ static int __init maple_bus_init(void)
        /* setup maple ports */
        for (i = 0; i < MAPLE_PORTS; i++) {
                checked[i] = false;
+                empty[i] = false;
                mdev[i] = maple_alloc_dev(i, 0);
-                baseunits[i] = mdev[i];
                if (!mdev[i]) {
                        while (i-- > 0)
                                maple_free_dev(mdev[i]);
                        goto cleanup_cache;
                }
+                baseunits[i] = mdev[i];
+                atomic_set(&mdev[i]->busy, 1);
                maple_add_packet(mdev[i], 0, MAPLE_COMMAND_DEVINFO, 0, NULL);
                subdevice_map[i] = 0;
        }
-        /* setup maplebus hardware */
+        maple_pnp_time = jiffies + HZ;
-        maplebus_dma_reset();
+        /* prepare initial queue */
-        /* initial detection */
        maple_send();
-        maple_pnp_time = jiffies;
+        dev_info(&maple_bus, "bus core now registered\n");
-        printk(KERN_INFO "Maple bus core now registered.\n");
        return 0;
@@ -871,7 +876,7 @@ cleanup_dma:
        free_pages((unsigned long) maple_sendbuf, MAPLE_DMA_PAGES);
 cleanup_basic:
-        driver_unregister(&maple_dummy_driver.drv);
+        driver_unregister(&maple_unsupported_device.drv);
 cleanup_bus:
        bus_unregister(&maple_bus_type);
@@ -880,7 +885,7 @@ cleanup_device:
        device_unregister(&maple_bus);
 cleanup:
-        printk(KERN_INFO "Maple bus registration failed\n");
+        printk(KERN_ERR "Maple bus registration failed\n");
        return retval;
 }
 /* Push init to later to ensure hardware gets detected */
diff --git a/drivers/sh/superhyway/superhyway.c b/drivers/sh/superhyway/superhyway.c
index 4d0282b821b5..2d9e7f3d5611 100644
--- a/drivers/sh/superhyway/superhyway.c
+++ b/drivers/sh/superhyway/superhyway.c
@@ -22,7 +22,7 @@
 static int superhyway_devices;
 static struct device superhyway_bus_device = {
-        .bus_id = "superhyway",
+        .init_name = "superhyway",
 };
 static void superhyway_device_release(struct device *dev)
@@ -83,7 +83,7 @@ int superhyway_add_device(unsigned long base, struct superhyway_device *sdev,
        dev->id.id              = dev->vcr.mod_id;
        sprintf(dev->name, "SuperHyway device %04x", dev->id.id);
-        sprintf(dev->dev.bus_id, "%02x", superhyway_devices);
+        dev_set_name(&dev->dev, "%02x", superhyway_devices);
        superhyway_devices++;
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index 56ff3e6864ea..12e443cc4ac9 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -322,7 +322,7 @@ static void atmel_spi_next_message(struct spi_master *master)
        spi = msg->spi;
        dev_dbg(master->dev.parent, "start message %p for %s\n",
-                        msg, spi->dev.bus_id);
+                        msg, dev_name(&spi->dev));
        /* select chip if it's not still active */
        if (as->stay) {
@@ -627,7 +627,7 @@ static int atmel_spi_setup(struct spi_device *spi)
                if (!asd)
                        return -ENOMEM;
-                ret = gpio_request(npcs_pin, spi->dev.bus_id);
+                ret = gpio_request(npcs_pin, dev_name(&spi->dev));
                if (ret) {
                        kfree(asd);
                        return ret;
@@ -668,7 +668,7 @@ static int atmel_spi_transfer(struct spi_device *spi, struct spi_message *msg)
        as = spi_master_get_devdata(spi->master);
        dev_dbg(controller, "new message %p submitted for %s\n",
-                        msg, spi->dev.bus_id);
+                        msg, dev_name(&spi->dev));
        if (unlikely(list_empty(&msg->transfers)))
                return -EINVAL;
@@ -803,7 +803,7 @@ static int __init atmel_spi_probe(struct platform_device *pdev)
        as->clk = clk;
        ret = request_irq(irq, atmel_spi_interrupt, 0,
-                        pdev->dev.bus_id, master);
+                        dev_name(&pdev->dev), master);
        if (ret)
                goto out_unmap_regs;
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index 3b97803e1d11..68c77a911595 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -429,7 +429,7 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
        INIT_LIST_HEAD(&mps->queue);
        mps->workqueue = create_singlethread_workqueue(
-                master->dev.parent->bus_id);
+                dev_name(master->dev.parent));
        if (mps->workqueue == NULL) {
                ret = -EBUSY;
                goto free_irq;
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index 454a2712e629..1c65e380c845 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -1003,7 +1003,7 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
                goto err1;
        }
        if (!request_mem_region(r->start, (r->end - r->start) + 1,
-                        pdev->dev.bus_id)) {
+                        dev_name(&pdev->dev))) {
                status = -EBUSY;
                goto err1;
        }
diff --git a/drivers/spi/omap_uwire.c b/drivers/spi/omap_uwire.c
index bab6ff061e91..60b5381c65c4 100644
--- a/drivers/spi/omap_uwire.c
+++ b/drivers/spi/omap_uwire.c
@@ -245,7 +245,7 @@ static int uwire_txrx(struct spi_device *spi, struct spi_transfer *t)
 #ifdef  VERBOSE
                        pr_debug("%s: write-%d =%04x\n",
-                                        spi->dev.bus_id, bits, val);
+                                        dev_name(&spi->dev), bits, val);
 #endif
                        if (wait_uwire_csr_flag(CSRB, 0, 0))
                                goto eio;
@@ -305,7 +305,7 @@ static int uwire_txrx(struct spi_device *spi, struct spi_transfer *t)
                        status += bytes;
 #ifdef  VERBOSE
                        pr_debug("%s: read-%d =%04x\n",
-                                        spi->dev.bus_id, bits, val);
+                                        dev_name(&spi->dev), bits, val);
 #endif
                }
@@ -331,7 +331,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        uwire = spi_master_get_devdata(spi->master);
        if (spi->chip_select > 3) {
-                pr_debug("%s: cs%d?\n", spi->dev.bus_id, spi->chip_select);
+                pr_debug("%s: cs%d?\n", dev_name(&spi->dev), spi->chip_select);
                status = -ENODEV;
                goto done;
        }
@@ -343,7 +343,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                bits = 8;
        if (bits > 16) {
-                pr_debug("%s: wordsize %d?\n", spi->dev.bus_id, bits);
+                pr_debug("%s: wordsize %d?\n", dev_name(&spi->dev), bits);
                status = -ENODEV;
                goto done;
        }
@@ -378,7 +378,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                hz = t->speed_hz;
        if (!hz) {
-                pr_debug("%s: zero speed?\n", spi->dev.bus_id);
+                pr_debug("%s: zero speed?\n", dev_name(&spi->dev));
                status = -EINVAL;
                goto done;
        }
@@ -406,7 +406,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        }
        if (div1_idx == 4) {
                pr_debug("%s: lowest clock %ld, need %d\n",
-                        spi->dev.bus_id, rate / 10 / 8, hz);
+                        dev_name(&spi->dev), rate / 10 / 8, hz);
                status = -EDOM;
                goto done;
        }
diff --git a/drivers/spi/orion_spi.c b/drivers/spi/orion_spi.c
index 014becb7d530..c8b0babdc2a6 100644
--- a/drivers/spi/orion_spi.c
+++ b/drivers/spi/orion_spi.c
@@ -496,7 +496,7 @@ static int __init orion_spi_probe(struct platform_device *pdev)
        }
        if (!request_mem_region(r->start, (r->end - r->start) + 1,
-                                pdev->dev.bus_id)) {
+                                dev_name(&pdev->dev))) {
                status = -EBUSY;
                goto out;
        }
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index d0fc4ca2f656..ec24f2d16f3c 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -1333,7 +1333,7 @@ static int __init init_queue(struct driver_data *drv_data)
        INIT_WORK(&drv_data->pump_messages, pump_messages);
        drv_data->workqueue = create_singlethread_workqueue(
-                                        drv_data->master->dev.parent->bus_id);
+                                dev_name(drv_data->master->dev.parent));
        if (drv_data->workqueue == NULL)
                return -EBUSY;
@@ -1462,7 +1462,7 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
                drv_data->mask_sr = SSSR_TINT | SSSR_RFS | SSSR_TFS | SSSR_ROR;
        }
-        status = request_irq(ssp->irq, ssp_int, 0, dev->bus_id, drv_data);
+        status = request_irq(ssp->irq, ssp_int, 0, dev_name(dev), drv_data);
        if (status < 0) {
                dev_err(&pdev->dev, "cannot get IRQ %d\n", ssp->irq);
                goto out_error_master_alloc;
diff --git a/drivers/spi/spi_bfin5xx.c b/drivers/spi/spi_bfin5xx.c
index 7fea3cf4588a..3410b0c55ed2 100644
--- a/drivers/spi/spi_bfin5xx.c
+++ b/drivers/spi/spi_bfin5xx.c
@@ -1160,8 +1160,8 @@ static inline int init_queue(struct driver_data *drv_data)
        /* init messages workqueue */
        INIT_WORK(&drv_data->pump_messages, pump_messages);
-        drv_data->workqueue =
+        drv_data->workqueue = create_singlethread_workqueue(
-            create_singlethread_workqueue(drv_data->master->dev.parent->bus_id);
+                                dev_name(drv_data->master->dev.parent));
        if (drv_data->workqueue == NULL)
                return -EBUSY;
diff --git a/drivers/spi/spi_gpio.c b/drivers/spi/spi_gpio.c
index f5ed9721aabb..d2866c293dee 100644
--- a/drivers/spi/spi_gpio.c
+++ b/drivers/spi/spi_gpio.c
@@ -191,7 +191,7 @@ static int spi_gpio_setup(struct spi_device *spi)
                return -EINVAL;
        if (!spi->controller_state) {
-                status = gpio_request(cs, spi->dev.bus_id);
+                status = gpio_request(cs, dev_name(&spi->dev));
                if (status)
                        return status;
                status = gpio_direction_output(cs, spi->mode & SPI_CS_HIGH);
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 269a55ec52ef..0480d8bb19d3 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -1381,7 +1381,7 @@ static int __init init_queue(struct driver_data *drv_data)
        INIT_WORK(&drv_data->work, pump_messages);
        drv_data->workqueue = create_singlethread_workqueue(
-                                        drv_data->master->dev.parent->bus_id);
+                                dev_name(drv_data->master->dev.parent));
        if (drv_data->workqueue == NULL)
                return -EBUSY;
@@ -1525,7 +1525,8 @@ static int __init spi_imx_probe(struct platform_device *pdev)
                status = -ENODEV;
                goto err_no_irqres;
        }
-        status = request_irq(irq, spi_int, IRQF_DISABLED, dev->bus_id, drv_data);
+        status = request_irq(irq, spi_int, IRQF_DISABLED,
+                             dev_name(dev), drv_data);
        if (status < 0) {
                dev_err(&pdev->dev, "probe - cannot get IRQ (%d)\n", status);
                goto err_no_irqres;
diff --git a/drivers/spi/spi_mpc83xx.c b/drivers/spi/spi_mpc83xx.c
index ac0e3e4b3c54..44a2b46ccb79 100644
--- a/drivers/spi/spi_mpc83xx.c
+++ b/drivers/spi/spi_mpc83xx.c
@@ -637,7 +637,7 @@ static int __init mpc83xx_spi_probe(struct platform_device *dev)
        INIT_LIST_HEAD(&mpc83xx_spi->queue);
        mpc83xx_spi->workqueue = create_singlethread_workqueue(
-                master->dev.parent->bus_id);
+                dev_name(master->dev.parent));
        if (mpc83xx_spi->workqueue == NULL) {
                ret = -EBUSY;
                goto free_irq;
@@ -649,7 +649,7 @@ static int __init mpc83xx_spi_probe(struct platform_device *dev)
        printk(KERN_INFO
               "%s: MPC83xx SPI Controller driver at 0x%p (irq = %d)\n",
-               dev->dev.bus_id, mpc83xx_spi->base, mpc83xx_spi->irq);
+               dev_name(&dev->dev), mpc83xx_spi->base, mpc83xx_spi->irq);
        return ret;
diff --git a/drivers/spi/spi_txx9.c b/drivers/spi/spi_txx9.c
index 2296f37ea3c6..29cbb065618a 100644
--- a/drivers/spi/spi_txx9.c
+++ b/drivers/spi/spi_txx9.c
@@ -404,7 +404,8 @@ static int __init txx9spi_probe(struct platform_device *dev)
        if (ret)
                goto exit;
-        c->workqueue = create_singlethread_workqueue(master->dev.parent->bus_id);
+        c->workqueue = create_singlethread_workqueue(
+                                dev_name(master->dev.parent));
        if (!c->workqueue)
                goto exit_busy;
        c->last_chipselect = -1;
diff --git a/drivers/staging/go7007/snd-go7007.c b/drivers/staging/go7007/snd-go7007.c
index a7de401f61ab..cd19be6c00e0 100644
--- a/drivers/staging/go7007/snd-go7007.c
+++ b/drivers/staging/go7007/snd-go7007.c
@@ -248,10 +248,11 @@ int go7007_snd_init(struct go7007 *go)
        spin_lock_init(&gosnd->lock);
        gosnd->hw_ptr = gosnd->w_idx = gosnd->avail = 0;
        gosnd->capturing = 0;
-        gosnd->card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
+        ret = snd_card_create(index[dev], id[dev], THIS_MODULE, 0,
-        if (gosnd->card == NULL) {
+                              &gosnd->card);
+        if (ret < 0) {
                kfree(gosnd);
-                return -ENOMEM;
+                return ret;
        }
        ret = snd_device_new(gosnd->card, SNDRV_DEV_LOWLEVEL, go,
                        &go7007_snd_device_ops);
diff --git a/drivers/tc/tc.c b/drivers/tc/tc.c
index f77f62a4b325..e5bd4470a570 100644
--- a/drivers/tc/tc.c
+++ b/drivers/tc/tc.c
@@ -86,7 +86,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                               slot);
                        goto out_err;
                }
-                sprintf(tdev->dev.bus_id, "tc%x", slot);
+                dev_set_name(&tdev->dev, "tc%x", slot);
                tdev->bus = tbus;
                tdev->dev.parent = &tbus->dev;
                tdev->dev.bus = &tc_bus_type;
@@ -104,7 +104,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                tdev->vendor[8] = 0;
                tdev->name[8] = 0;
-                pr_info("%s: %s %s %s\n", tdev->dev.bus_id, tdev->vendor,
+                pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
                        tdev->name, tdev->firmware);
                devsize = readb(module + offset + TC_SLOT_SIZE);
@@ -118,7 +118,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                } else {
                        printk(KERN_ERR "%s: Cannot provide slot space "
                               "(%dMiB required, up to %dMiB supported)\n",
-                               tdev->dev.bus_id, devsize >> 20,
+                               dev_name(&tdev->dev), devsize >> 20,
                               max(slotsize, extslotsize) >> 20);
                        kfree(tdev);
                        goto out_err;
@@ -146,7 +146,7 @@ static int __init tc_init(void)
                return 0;
        INIT_LIST_HEAD(&tc_bus.devices);
-        strcpy(tc_bus.dev.bus_id, "tc");
+        dev_set_name(&tc_bus.dev, "tc");
        device_register(&tc_bus.dev);
        if (tc_bus.info.slot_size) {
diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index 04b954cfce76..7f86534de269 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -58,6 +58,24 @@ config UIO_SMX
          If you compile this as a module, it will be called uio_smx.
+config UIO_AEC
+        tristate "AEC video timestamp device"
+        depends on PCI
+        default n
+        help
+          UIO driver for the Adrienne Electronics Corporation PCI time
+          code device.
+          This device differs from other UIO devices since it uses I/O
+          ports instead of memory mapped I/O. In order to make it
+          possible for UIO to work with this device a utility, uioport,
+          can be used to read and write the ports:
+            git clone git://ifup.org/philips/uioport.git
+          If you compile this as a module, it will be called uio_aec.
 config UIO_SERCOS3
        tristate "Automata Sercos III PCI card driver"
        default n
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index e69558149859..5c2586d75797 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -3,4 +3,5 @@ obj-$(CONFIG_UIO_CIF)	+= uio_cif.o
 obj-$(CONFIG_UIO_PDRV)  += uio_pdrv.o
 obj-$(CONFIG_UIO_PDRV_GENIRQ)   += uio_pdrv_genirq.o
 obj-$(CONFIG_UIO_SMX)   += uio_smx.o
+obj-$(CONFIG_UIO_AEC)   += uio_aec.o
 obj-$(CONFIG_UIO_SERCOS3)       += uio_sercos3.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 4ca85a113aa2..03efb065455f 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -61,6 +61,14 @@ struct uio_map {
 };
 #define to_map(map) container_of(map, struct uio_map, kobj)
+static ssize_t map_name_show(struct uio_mem *mem, char *buf)
+{
+        if (unlikely(!mem->name))
+                mem->name = "";
+        return sprintf(buf, "%s\n", mem->name);
+}
 static ssize_t map_addr_show(struct uio_mem *mem, char *buf)
 {
        return sprintf(buf, "0x%lx\n", mem->addr);
@@ -82,6 +90,8 @@ struct map_sysfs_entry {
        ssize_t (*store)(struct uio_mem *, const char *, size_t);
 };
+static struct map_sysfs_entry name_attribute =
+        __ATTR(name, S_IRUGO, map_name_show, NULL);
 static struct map_sysfs_entry addr_attribute =
        __ATTR(addr, S_IRUGO, map_addr_show, NULL);
 static struct map_sysfs_entry size_attribute =
@@ -90,6 +100,7 @@ static struct map_sysfs_entry offset_attribute =
        __ATTR(offset, S_IRUGO, map_offset_show, NULL);
 static struct attribute *attrs[] = {
+        &name_attribute.attr,
        &addr_attribute.attr,
        &size_attribute.attr,
        &offset_attribute.attr,
@@ -133,6 +144,14 @@ struct uio_portio {
 };
 #define to_portio(portio) container_of(portio, struct uio_portio, kobj)
+static ssize_t portio_name_show(struct uio_port *port, char *buf)
+{
+        if (unlikely(!port->name))
+                port->name = "";
+        return sprintf(buf, "%s\n", port->name);
+}
 static ssize_t portio_start_show(struct uio_port *port, char *buf)
 {
        return sprintf(buf, "0x%lx\n", port->start);
@@ -159,6 +178,8 @@ struct portio_sysfs_entry {
        ssize_t (*store)(struct uio_port *, const char *, size_t);
 };
+static struct portio_sysfs_entry portio_name_attribute =
+        __ATTR(name, S_IRUGO, portio_name_show, NULL);
 static struct portio_sysfs_entry portio_start_attribute =
        __ATTR(start, S_IRUGO, portio_start_show, NULL);
 static struct portio_sysfs_entry portio_size_attribute =
@@ -167,6 +188,7 @@ static struct portio_sysfs_entry portio_porttype_attribute =
        __ATTR(porttype, S_IRUGO, portio_porttype_show, NULL);
 static struct attribute *portio_attrs[] = {
+        &portio_name_attribute.attr,
        &portio_start_attribute.attr,
        &portio_size_attribute.attr,
        &portio_porttype_attribute.attr,
@@ -686,7 +708,8 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
                return -EINVAL;
        requested_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
-        actual_pages = (idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
+        actual_pages = ((idev->info->mem[mi].addr & ~PAGE_MASK)
+                        + idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
        if (requested_pages > actual_pages)
                return -EINVAL;
diff --git a/drivers/uio/uio_aec.c b/drivers/uio/uio_aec.c
new file mode 100644
index 000000000000..b7830e9a3baa
--- /dev/null
+++ b/drivers/uio/uio_aec.c
@@ -0,0 +1,175 @@
+/*
+ * uio_aec.c -- simple driver for Adrienne Electronics Corp time code PCI device
+ *
+ * Copyright (C) 2008 Brandon Philips <brandon@ifup.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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc., 59
+ *   Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/cdev.h>
+#include <linux/fs.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/uio_driver.h>
+#define PCI_VENDOR_ID_AEC 0xaecb
+#define PCI_DEVICE_ID_AEC_VITCLTC 0x6250
+#define INT_ENABLE_ADDR         0xFC
+#define INT_ENABLE              0x10
+#define INT_DISABLE             0x0
+#define INT_MASK_ADDR           0x2E
+#define INT_MASK_ALL            0x3F
+#define INTA_DRVR_ADDR          0xFE
+#define INTA_ENABLED_FLAG       0x08
+#define INTA_FLAG               0x01
+#define MAILBOX                 0x0F
+static struct pci_device_id ids[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_AEC, PCI_DEVICE_ID_AEC_VITCLTC), },
+        { 0, }
+};
+MODULE_DEVICE_TABLE(pci, ids);
+static irqreturn_t aectc_irq(int irq, struct uio_info *dev_info)
+{
+        void __iomem *int_flag = dev_info->priv + INTA_DRVR_ADDR;
+        unsigned char status = ioread8(int_flag);
+        if ((status & INTA_ENABLED_FLAG) && (status & INTA_FLAG)) {
+                /* application writes 0x00 to 0x2F to get next interrupt */
+                status = ioread8(dev_info->priv + MAILBOX);
+                return IRQ_HANDLED;
+        }
+        return IRQ_NONE;
+}
+static void print_board_data(struct pci_dev *pdev, struct uio_info *i)
+{
+        dev_info(&pdev->dev, "PCI-TC board vendor: %x%x number: %x%x"
+                " revision: %c%c\n",
+                ioread8(i->priv + 0x01),
+                ioread8(i->priv + 0x00),
+                ioread8(i->priv + 0x03),
+                ioread8(i->priv + 0x02),
+                ioread8(i->priv + 0x06),
+                ioread8(i->priv + 0x07));
+}
+static int __devinit probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct uio_info *info;
+        int ret;
+        info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        if (pci_enable_device(pdev))
+                goto out_free;
+        if (pci_request_regions(pdev, "aectc"))
+                goto out_disable;
+        info->name = "aectc";
+        info->port[0].start = pci_resource_start(pdev, 0);
+        if (!info->port[0].start)
+                goto out_release;
+        info->priv = pci_iomap(pdev, 0, 0);
+        if (!info->priv)
+                goto out_release;
+        info->port[0].size = pci_resource_len(pdev, 0);
+        info->port[0].porttype = UIO_PORT_GPIO;
+        info->version = "0.0.1";
+        info->irq = pdev->irq;
+        info->irq_flags = IRQF_SHARED;
+        info->handler = aectc_irq;
+        print_board_data(pdev, info);
+        ret = uio_register_device(&pdev->dev, info);
+        if (ret)
+                goto out_unmap;
+        iowrite32(INT_ENABLE, info->priv + INT_ENABLE_ADDR);
+        iowrite8(INT_MASK_ALL, info->priv + INT_MASK_ADDR);
+        if (!(ioread8(info->priv + INTA_DRVR_ADDR)
+                        & INTA_ENABLED_FLAG))
+                dev_err(&pdev->dev, "aectc: interrupts not enabled\n");
+        pci_set_drvdata(pdev, info);
+        return 0;
+out_unmap:
+        pci_iounmap(pdev, info->priv);
+out_release:
+        pci_release_regions(pdev);
+out_disable:
+        pci_disable_device(pdev);
+out_free:
+        kfree(info);
+        return -ENODEV;
+}
+static void remove(struct pci_dev *pdev)
+{
+        struct uio_info *info = pci_get_drvdata(pdev);
+        /* disable interrupts */
+        iowrite8(INT_DISABLE, info->priv + INT_MASK_ADDR);
+        iowrite32(INT_DISABLE, info->priv + INT_ENABLE_ADDR);
+        /* read mailbox to ensure board drops irq */
+        ioread8(info->priv + MAILBOX);
+        uio_unregister_device(info);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
+        iounmap(info->priv);
+        kfree(info);
+}
+static struct pci_driver pci_driver = {
+        .name = "aectc",
+        .id_table = ids,
+        .probe = probe,
+        .remove = remove,
+};
+static int __init aectc_init(void)
+{
+        return pci_register_driver(&pci_driver);
+}
+static void __exit aectc_exit(void)
+{
+        pci_unregister_driver(&pci_driver);
+}
+MODULE_LICENSE("GPL");
+module_init(aectc_init);
+module_exit(aectc_exit);
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 83babb0a1df7..c6c816b7ecb5 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -47,6 +47,7 @@ config USB_ARCH_HAS_OHCI
        default y if CPU_SUBTYPE_SH7720
        default y if CPU_SUBTYPE_SH7721
        default y if CPU_SUBTYPE_SH7763
+        default y if CPU_SUBTYPE_SH7786
        # more:
        default PCI
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index b2ceb4aff233..89299a5ce168 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -19,6 +19,7 @@ obj-$(CONFIG_USB_SL811_HCD)	+= host/
 obj-$(CONFIG_USB_U132_HCD)      += host/
 obj-$(CONFIG_USB_R8A66597_HCD)  += host/
 obj-$(CONFIG_USB_HWA_HCD)       += host/
+obj-$(CONFIG_USB_ISP1760_HCD)   += host/
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 3f3ee1351930..d2747a49b974 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -880,16 +880,19 @@ static int usblp_wwait(struct usblp *usblp, int nonblock)
                if (rc <= 0)
                        break;
-                if (usblp->flags & LP_ABORT) {
+                if (schedule_timeout(msecs_to_jiffies(1500)) == 0) {
-                        if (schedule_timeout(msecs_to_jiffies(5000)) == 0) {
+                        if (usblp->flags & LP_ABORT) {
                                err = usblp_check_status(usblp, err);
                                if (err == 1) { /* Paper out */
                                        rc = -ENOSPC;
                                        break;
                                }
+                        } else {
+                                /* Prod the printer, Gentoo#251237. */
+                                mutex_lock(&usblp->mut);
+                                usblp_read_status(usblp, usblp->statusbuf);
+                                mutex_unlock(&usblp->mut);
                        }
-                } else {
-                        schedule();
                }
        }
        set_current_state(TASK_RUNNING);
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 6ec38175a817..73c108d117b4 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -187,7 +187,7 @@ static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
        }
        /* this isn't checking for illegal values */
-        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(desc)) {
        case USB_ENDPOINT_XFER_CONTROL:
                type = "Ctrl";
                if (speed == USB_SPEED_HIGH)    /* uframes per NAK */
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 6585f527e381..df3c539f652a 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -104,7 +104,7 @@ MODULE_PARM_DESC(usbfs_snoop, "true to log all usbfs traffic");
 #define MAX_USBFS_BUFFER_SIZE   16384
-static inline int connected(struct dev_state *ps)
+static int connected(struct dev_state *ps)
 {
        return (!list_empty(&ps->list) &&
                        ps->dev->state != USB_STATE_NOTATTACHED);
@@ -248,7 +248,7 @@ static void free_async(struct async *as)
        kfree(as);
 }
-static inline void async_newpending(struct async *as)
+static void async_newpending(struct async *as)
 {
        struct dev_state *ps = as->ps;
        unsigned long flags;
@@ -258,7 +258,7 @@ static inline void async_newpending(struct async *as)
        spin_unlock_irqrestore(&ps->lock, flags);
 }
-static inline void async_removepending(struct async *as)
+static void async_removepending(struct async *as)
 {
        struct dev_state *ps = as->ps;
        unsigned long flags;
@@ -268,7 +268,7 @@ static inline void async_removepending(struct async *as)
        spin_unlock_irqrestore(&ps->lock, flags);
 }
-static inline struct async *async_getcompleted(struct dev_state *ps)
+static struct async *async_getcompleted(struct dev_state *ps)
 {
        unsigned long flags;
        struct async *as = NULL;
@@ -283,7 +283,7 @@ static inline struct async *async_getcompleted(struct dev_state *ps)
        return as;
 }
-static inline struct async *async_getpending(struct dev_state *ps,
+static struct async *async_getpending(struct dev_state *ps,
                                             void __user *userurb)
 {
        unsigned long flags;
@@ -302,7 +302,7 @@ static inline struct async *async_getpending(struct dev_state *ps,
 static void snoop_urb(struct urb *urb, void __user *userurb)
 {
-        int j;
+        unsigned j;
        unsigned char *data = urb->transfer_buffer;
        if (!usbfs_snoop)
@@ -311,9 +311,9 @@ static void snoop_urb(struct urb *urb, void __user *userurb)
        dev_info(&urb->dev->dev, "direction=%s\n",
                        usb_urb_dir_in(urb) ? "IN" : "OUT");
        dev_info(&urb->dev->dev, "userurb=%p\n", userurb);
-        dev_info(&urb->dev->dev, "transfer_buffer_length=%d\n",
+        dev_info(&urb->dev->dev, "transfer_buffer_length=%u\n",
                 urb->transfer_buffer_length);
-        dev_info(&urb->dev->dev, "actual_length=%d\n", urb->actual_length);
+        dev_info(&urb->dev->dev, "actual_length=%u\n", urb->actual_length);
        dev_info(&urb->dev->dev, "data: ");
        for (j = 0; j < urb->transfer_buffer_length; ++j)
                printk("%02x ", data[j]);
@@ -376,7 +376,7 @@ static void destroy_async_on_interface(struct dev_state *ps,
        destroy_async(ps, &hitlist);
 }
-static inline void destroy_all_async(struct dev_state *ps)
+static void destroy_all_async(struct dev_state *ps)
 {
        destroy_async(ps, &ps->async_pending);
 }
@@ -525,7 +525,8 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype,
 {
        int ret = 0;
-        if (ps->dev->state != USB_STATE_ADDRESS
+        if (ps->dev->state != USB_STATE_UNAUTHENTICATED
+         && ps->dev->state != USB_STATE_ADDRESS
         && ps->dev->state != USB_STATE_CONFIGURED)
                return -EHOSTUNREACH;
        if (USB_TYPE_VENDOR == (USB_TYPE_MASK & requesttype))
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index e1710f260b4f..40dee2ac0133 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -66,7 +66,7 @@ static ssize_t show_ep_type(struct device *dev, struct device_attribute *attr,
        struct ep_device *ep = to_ep_device(dev);
        char *type = "unknown";
-        switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(ep->desc)) {
        case USB_ENDPOINT_XFER_CONTROL:
                type = "Control";
                break;
@@ -94,7 +94,7 @@ static ssize_t show_ep_interval(struct device *dev,
        in = (ep->desc->bEndpointAddress & USB_DIR_IN);
-        switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(ep->desc)) {
        case USB_ENDPOINT_XFER_CONTROL:
                if (ep->udev->speed == USB_SPEED_HIGH)  /* uframes per NAK */
                        interval = ep->desc->bInterval;
@@ -131,10 +131,9 @@ static ssize_t show_ep_direction(struct device *dev,
        struct ep_device *ep = to_ep_device(dev);
        char *direction;
-        if ((ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+        if (usb_endpoint_xfer_control(ep->desc))
-                        USB_ENDPOINT_XFER_CONTROL)
                direction = "both";
-        else if (ep->desc->bEndpointAddress & USB_DIR_IN)
+        else if (usb_endpoint_dir_in(ep->desc))
                direction = "in";
        else
                direction = "out";
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 3c711db55d86..81fa8506825d 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -279,9 +279,9 @@ static const u8 hs_rh_config_descriptor [] = {
 * helper routine for returning string descriptors in UTF-16LE
 * input can actually be ISO-8859-1; ASCII is its 7-bit subset
 */
-static int ascii2utf (char *s, u8 *utf, int utfmax)
+static unsigned ascii2utf(char *s, u8 *utf, int utfmax)
 {
-        int retval;
+        unsigned retval;
        for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
                *utf++ = *s++;
@@ -304,19 +304,15 @@ static int ascii2utf (char *s, u8 *utf, int utfmax)
 * Produces either a manufacturer, product or serial number string for the
 * virtual root hub device.
 */
-static int rh_string (
+static unsigned rh_string(int id, struct usb_hcd *hcd, u8 *data, unsigned len)
-        int             id,
+{
-        struct usb_hcd  *hcd,
-        u8              *data,
-        int             len
-) {
        char buf [100];
        // language ids
        if (id == 0) {
                buf[0] = 4;    buf[1] = 3;      /* 4 bytes string data */
                buf[2] = 0x09; buf[3] = 0x04;   /* MSFT-speak for "en-us" */
-                len = min (len, 4);
+                len = min_t(unsigned, len, 4);
                memcpy (data, buf, len);
                return len;
@@ -332,10 +328,7 @@ static int rh_string (
        } else if (id == 3) {
                snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
                        init_utsname()->release, hcd->driver->description);
+        }
-        // unsupported IDs --> "protocol stall"
-        } else
-                return -EPIPE;
        switch (len) {          /* All cases fall through */
        default:
@@ -360,9 +353,8 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
        u8              tbuf [sizeof (struct usb_hub_descriptor)]
                __attribute__((aligned(4)));
        const u8        *bufp = tbuf;
-        int             len = 0;
+        unsigned        len = 0;
        int             status;
-        int             n;
        u8              patch_wakeup = 0;
        u8              patch_protocol = 0;
@@ -456,10 +448,11 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
                                patch_wakeup = 1;
                        break;
                case USB_DT_STRING << 8:
-                        n = rh_string (wValue & 0xff, hcd, ubuf, wLength);
+                        if ((wValue & 0xff) < 4)
-                        if (n < 0)
+                                urb->actual_length = rh_string(wValue & 0xff,
+                                                hcd, ubuf, wLength);
+                        else /* unsupported IDs --> "protocol stall" */
                                goto error;
-                        urb->actual_length = n;
                        break;
                default:
                        goto error;
@@ -629,7 +622,7 @@ static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
 {
        int             retval;
        unsigned long   flags;
-        int             len = 1 + (urb->dev->maxchild / 8);
+        unsigned        len = 1 + (urb->dev->maxchild / 8);
        spin_lock_irqsave (&hcd_root_hub_lock, flags);
        if (hcd->status_urb || urb->transfer_buffer_length < len) {
@@ -901,7 +894,7 @@ static int register_root_hub(struct usb_hcd *hcd)
        mutex_lock(&usb_bus_list_lock);
-        usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
+        usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
        retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
        if (retval != sizeof usb_dev->descriptor) {
                mutex_unlock(&usb_bus_list_lock);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index cd50d86029e7..be86ae3f4088 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -392,7 +392,7 @@ static void hub_irq(struct urb *urb)
 {
        struct usb_hub *hub = urb->context;
        int status = urb->status;
-        int i;
+        unsigned i;
        unsigned long bits;
        switch (status) {
@@ -1305,6 +1305,7 @@ void usb_set_device_state(struct usb_device *udev,
                recursively_mark_NOTATTACHED(udev);
        spin_unlock_irqrestore(&device_state_lock, flags);
 }
+EXPORT_SYMBOL_GPL(usb_set_device_state);
 /*
 * WUSB devices are simple: they have no hubs behind, so the mapping
@@ -2471,20 +2472,20 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         */
        switch (udev->speed) {
        case USB_SPEED_VARIABLE:        /* fixed at 512 */
-                udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(512);
+                udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
                break;
        case USB_SPEED_HIGH:            /* fixed at 64 */
-                udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
+                udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
                break;
        case USB_SPEED_FULL:            /* 8, 16, 32, or 64 */
                /* to determine the ep0 maxpacket size, try to read
                 * the device descriptor to get bMaxPacketSize0 and
                 * then correct our initial guess.
                 */
-                udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
+                udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
                break;
        case USB_SPEED_LOW:             /* fixed at 8 */
-                udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8);
+                udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
                break;
        default:
                goto fail;
@@ -3392,10 +3393,10 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                udev->descriptor = descriptor;  /* for disconnect() calls */
                goto re_enumerate;
        }
-  
+        /* Restore the device's previous configuration */
        if (!udev->actconfig)
                goto done;
        ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                        USB_REQ_SET_CONFIGURATION, 0,
                        udev->actconfig->desc.bConfigurationValue, 0,
@@ -3408,16 +3409,25 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
        }
        usb_set_device_state(udev, USB_STATE_CONFIGURED);
+        /* Put interfaces back into the same altsettings as before.
+         * Don't bother to send the Set-Interface request for interfaces
+         * that were already in altsetting 0; besides being unnecessary,
+         * many devices can't handle it.  Instead just reset the host-side
+         * endpoint state.
+         */
        for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                struct usb_interface *intf = udev->actconfig->interface[i];
                struct usb_interface_descriptor *desc;
-                /* set_interface resets host side toggle even
-                 * for altsetting zero.  the interface may have no driver.
-                 */
                desc = &intf->cur_altsetting->desc;
-                ret = usb_set_interface(udev, desc->bInterfaceNumber,
+                if (desc->bAlternateSetting == 0) {
-                        desc->bAlternateSetting);
+                        usb_disable_interface(udev, intf, true);
+                        usb_enable_interface(udev, intf, true);
+                        ret = 0;
+                } else {
+                        ret = usb_set_interface(udev, desc->bInterfaceNumber,
+                                        desc->bAlternateSetting);
+                }
                if (ret < 0) {
                        dev_err(&udev->dev, "failed to restore interface %d "
                                "altsetting %d (error=%d)\n",
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 49e7f56e0d7f..30a0690f3683 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -59,7 +59,7 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
                retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status);
                dev_dbg(&urb->dev->dev,
-                        "%s timed out on ep%d%s len=%d/%d\n",
+                        "%s timed out on ep%d%s len=%u/%u\n",
                        current->comm,
                        usb_endpoint_num(&urb->ep->desc),
                        usb_urb_dir_in(urb) ? "in" : "out",
@@ -804,18 +804,16 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
                        dev_err(&dev->dev,
                                "string descriptor 0 read error: %d\n",
                                err);
-                        goto errout;
                } else if (err < 4) {
                        dev_err(&dev->dev, "string descriptor 0 too short\n");
-                        err = -EINVAL;
-                        goto errout;
                } else {
-                        dev->have_langid = 1;
                        dev->string_langid = tbuf[2] | (tbuf[3] << 8);
                        /* always use the first langid listed */
                        dev_dbg(&dev->dev, "default language 0x%04x\n",
                                dev->string_langid);
                }
+                dev->have_langid = 1;
        }
        err = usb_string_sub(dev, dev->string_langid, index, tbuf);
@@ -1719,7 +1717,8 @@ free_interfaces:
        }
        kfree(new_interfaces);
-        if (cp->string == NULL)
+        if (cp->string == NULL &&
+                        !(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
                cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
        /* Now that all the interfaces are set up, register them
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index c070b34b669d..ab93918d9207 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -54,6 +54,10 @@ static const struct usb_device_id usb_quirk_list[] = {
        { USB_DEVICE(0x0638, 0x0a13), .driver_info =
          USB_QUIRK_STRING_FETCH_255 },
+        /* Saitek Cyborg Gold Joystick */
+        { USB_DEVICE(0x06a3, 0x0006), .driver_info =
+                        USB_QUIRK_CONFIG_INTF_STRINGS },
        /* M-Systems Flash Disk Pioneers */
        { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 4cc2456ef3be..c66789197927 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -13,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/usb.h>
+#include <linux/usb/quirks.h>
 #include "usb.h"
 /* Active configuration fields */
@@ -813,7 +814,8 @@ int usb_create_sysfs_intf_files(struct usb_interface *intf)
        if (intf->sysfs_files_created || intf->unregistering)
                return 0;
-        if (alt->string == NULL)
+        if (alt->string == NULL &&
+                        !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
                alt->string = usb_cache_string(udev, alt->desc.iInterface);
        if (alt->string)
                retval = device_create_file(&intf->dev, &dev_attr_interface);
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 58bc5e3c2560..3376055f36e7 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -295,7 +295,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
        if (!urb || urb->hcpriv || !urb->complete)
                return -EINVAL;
        dev = urb->dev;
-        if ((!dev) || (dev->state < USB_STATE_DEFAULT))
+        if ((!dev) || (dev->state < USB_STATE_UNAUTHENTICATED))
                return -ENODEV;
        /* For now, get the endpoint from the pipe.  Eventually drivers
@@ -370,7 +370,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
        }
        /* the I/O buffer must be mapped/unmapped, except when length=0 */
-        if (urb->transfer_buffer_length < 0)
+        if (urb->transfer_buffer_length > INT_MAX)
                return -EMSGSIZE;
 #ifdef DEBUG
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index e55fef52a5dc..770b3eaa9184 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -254,6 +254,7 @@ config USB_PXA25X_SMALL
 config USB_GADGET_PXA27X
        boolean "PXA 27x"
        depends on ARCH_PXA && PXA27x
+        select USB_OTG_UTILS
        help
           Intel's PXA 27x series XScale ARM v5TE processors include
           an integrated full speed USB 1.1 device controller.
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index abf8192f89e8..826f3adde5d8 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -551,7 +551,7 @@ udc_alloc_request(struct usb_ep *usbep, gfp_t gfp)
                dma_desc->status = AMD_ADDBITS(dma_desc->status,
                                                UDC_DMA_STP_STS_BS_HOST_BUSY,
                                                UDC_DMA_STP_STS_BS);
-                dma_desc->bufptr = __constant_cpu_to_le32(DMA_DONT_USE);
+                dma_desc->bufptr = cpu_to_le32(DMA_DONT_USE);
                req->td_data = dma_desc;
                req->td_data_last = NULL;
                req->chain_len = 1;
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 65b03e3445a1..c22fab164113 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1017,7 +1017,7 @@ static struct usb_endpoint_descriptor usba_ep0_desc = {
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = 0,
        .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
-        .wMaxPacketSize = __constant_cpu_to_le16(64),
+        .wMaxPacketSize = cpu_to_le16(64),
        /* FIXME: I have no idea what to put here */
        .bInterval = 1,
 };
@@ -1207,21 +1207,21 @@ static int do_test_mode(struct usba_udc *udc)
 /* Avoid overly long expressions */
 static inline bool feature_is_dev_remote_wakeup(struct usb_ctrlrequest *crq)
 {
-        if (crq->wValue == __constant_cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP))
+        if (crq->wValue == cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP))
                return true;
        return false;
 }
 static inline bool feature_is_dev_test_mode(struct usb_ctrlrequest *crq)
 {
-        if (crq->wValue == __constant_cpu_to_le16(USB_DEVICE_TEST_MODE))
+        if (crq->wValue == cpu_to_le16(USB_DEVICE_TEST_MODE))
                return true;
        return false;
 }
 static inline bool feature_is_ep_halt(struct usb_ctrlrequest *crq)
 {
-        if (crq->wValue == __constant_cpu_to_le16(USB_ENDPOINT_HALT))
+        if (crq->wValue == cpu_to_le16(USB_ENDPOINT_HALT))
                return true;
        return false;
 }
@@ -1239,7 +1239,7 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                        status = cpu_to_le16(udc->devstatus);
                } else if (crq->bRequestType
                                == (USB_DIR_IN | USB_RECIP_INTERFACE)) {
-                        status = __constant_cpu_to_le16(0);
+                        status = cpu_to_le16(0);
                } else if (crq->bRequestType
                                == (USB_DIR_IN | USB_RECIP_ENDPOINT)) {
                        struct usba_ep *target;
@@ -1250,12 +1250,12 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                        status = 0;
                        if (is_stalled(udc, target))
-                                status |= __constant_cpu_to_le16(1);
+                                status |= cpu_to_le16(1);
                } else
                        goto delegate;
                /* Write directly to the FIFO. No queueing is done. */
-                if (crq->wLength != __constant_cpu_to_le16(sizeof(status)))
+                if (crq->wLength != cpu_to_le16(sizeof(status)))
                        goto stall;
                ep->state = DATA_STAGE_IN;
                __raw_writew(status, ep->fifo);
@@ -1274,7 +1274,7 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
                        struct usba_ep *target;
-                        if (crq->wLength != __constant_cpu_to_le16(0)
+                        if (crq->wLength != cpu_to_le16(0)
                                        || !feature_is_ep_halt(crq))
                                goto stall;
                        target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
@@ -1308,7 +1308,7 @@ static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
                        struct usba_ep *target;
-                        if (crq->wLength != __constant_cpu_to_le16(0)
+                        if (crq->wLength != cpu_to_le16(0)
                                        || !feature_is_ep_halt(crq))
                                goto stall;
@@ -1514,7 +1514,7 @@ restart:
                         */
                        ep->state = DATA_STAGE_IN;
                } else {
-                        if (crq.crq.wLength != __constant_cpu_to_le16(0))
+                        if (crq.crq.wLength != cpu_to_le16(0))
                                ep->state = DATA_STAGE_OUT;
                        else
                                ep->state = STATUS_STAGE_IN;
diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
index 5495b171cf29..928137d3dbdc 100644
--- a/drivers/usb/gadget/cdc2.c
+++ b/drivers/usb/gadget/cdc2.c
@@ -66,7 +66,7 @@ static struct usb_device_descriptor device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_COMM,
        .bDeviceSubClass =      0,
@@ -74,8 +74,8 @@ static struct usb_device_descriptor device_desc = {
        /* .bMaxPacketSize0 = f(hardware) */
        /* Vendor and product id can be overridden by module parameters.  */
-        .idVendor =             __constant_cpu_to_le16(CDC_VENDOR_NUM),
+        .idVendor =             cpu_to_le16(CDC_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16(CDC_PRODUCT_NUM),
+        .idProduct =            cpu_to_le16(CDC_PRODUCT_NUM),
        /* .bcdDevice = f(hardware) */
        /* .iManufacturer = DYNAMIC */
        /* .iProduct = DYNAMIC */
@@ -193,7 +193,7 @@ static int __init cdc_bind(struct usb_composite_dev *cdev)
                                gadget->name,
                                cdc_config_driver.label);
                device_desc.bcdDevice =
-                        __constant_cpu_to_le16(0x0300 | 0x0099);
+                        cpu_to_le16(0x0300 | 0x0099);
        }
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index bebf911c7e5f..22c65960c429 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -56,7 +56,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/kernel.h>
@@ -2626,7 +2625,7 @@ static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
        INIT_LIST_HEAD(&udc->gadget.ep_list);
        udc->gadget.ep0 = NULL;
-        strcpy(udc->gadget.dev.bus_id, "gadget");
+        dev_set_name(&udc->gadget.dev, "gadget");
        udc->gadget.dev.dma_mask = dev->dma_mask;
        udc->gadget.dev.parent   = dev;
        udc->gadget.dev.release  = udc_release;
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 5d11c291f1ad..59e85234fa0a 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -149,16 +149,17 @@ done:
 int usb_function_deactivate(struct usb_function *function)
 {
        struct usb_composite_dev        *cdev = function->config->cdev;
+        unsigned long                   flags;
        int                             status = 0;
-        spin_lock(&cdev->lock);
+        spin_lock_irqsave(&cdev->lock, flags);
        if (cdev->deactivations == 0)
                status = usb_gadget_disconnect(cdev->gadget);
        if (status == 0)
                cdev->deactivations++;
-        spin_unlock(&cdev->lock);
+        spin_unlock_irqrestore(&cdev->lock, flags);
        return status;
 }
@@ -1013,7 +1014,7 @@ composite_suspend(struct usb_gadget *gadget)
        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
        struct usb_function             *f;
-        /* REVISIT:  should we have config and device level
+        /* REVISIT:  should we have config level
         * suspend/resume callbacks?
         */
        DBG(cdev, "suspend\n");
@@ -1023,6 +1024,8 @@ composite_suspend(struct usb_gadget *gadget)
                                f->suspend(f);
                }
        }
+        if (composite->suspend)
+                composite->suspend(cdev);
 }
 static void
@@ -1031,10 +1034,12 @@ composite_resume(struct usb_gadget *gadget)
        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
        struct usb_function             *f;
-        /* REVISIT:  should we have config and device level
+        /* REVISIT:  should we have config level
         * suspend/resume callbacks?
         */
        DBG(cdev, "resume\n");
+        if (composite->resume)
+                composite->resume(cdev);
        if (cdev->config) {
                list_for_each_entry(f, &cdev->config->functions, list) {
                        if (f->resume)
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 9064696636ac..a56b24d305f8 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -1437,7 +1437,7 @@ restart:
                                        }
                                        if (urb->transfer_buffer_length > 1)
                                                buf [1] = 0;
-                                        urb->actual_length = min (2,
+                                        urb->actual_length = min_t(u32, 2,
                                                urb->transfer_buffer_length);
                                        value = 0;
                                        status = 0;
@@ -1626,7 +1626,7 @@ static int dummy_hub_control (
                hub_descriptor ((struct usb_hub_descriptor *) buf);
                break;
        case GetHubStatus:
-                *(__le32 *) buf = __constant_cpu_to_le32 (0);
+                *(__le32 *) buf = cpu_to_le32 (0);
                break;
        case GetPortStatus:
                if (wIndex != 1)
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index a36b1175b18d..cd0914ec898e 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -148,7 +148,7 @@ ep_matches (
                        return 0;
                /* BOTH:  "high bandwidth" works only at high speed */
-                if ((desc->wMaxPacketSize & __constant_cpu_to_le16(3<<11))) {
+                if ((desc->wMaxPacketSize & cpu_to_le16(3<<11))) {
                        if (!gadget->is_dualspeed)
                                return 0;
                        /* configure your hardware with enough buffering!! */
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 37252d0012a7..d006dc652e02 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -156,7 +156,7 @@ static struct usb_device_descriptor device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
+        .bcdUSB =               cpu_to_le16 (0x0200),
        .bDeviceClass =         USB_CLASS_COMM,
        .bDeviceSubClass =      0,
@@ -167,8 +167,8 @@ static struct usb_device_descriptor device_desc = {
         * we support.  (As does bNumConfigurations.)  These values can
         * also be overridden by module parameters.
         */
-        .idVendor =             __constant_cpu_to_le16 (CDC_VENDOR_NUM),
+        .idVendor =             cpu_to_le16 (CDC_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16 (CDC_PRODUCT_NUM),
+        .idProduct =            cpu_to_le16 (CDC_PRODUCT_NUM),
        /* .bcdDevice = f(hardware) */
        /* .iManufacturer = DYNAMIC */
        /* .iProduct = DYNAMIC */
@@ -318,7 +318,7 @@ static int __init eth_bind(struct usb_composite_dev *cdev)
                                gadget->name,
                                eth_config_driver.label);
                device_desc.bcdDevice =
-                        __constant_cpu_to_le16(0x0300 | 0x0099);
+                        cpu_to_le16(0x0300 | 0x0099);
        }
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index c1d34df0b157..7953948bfe4a 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -125,7 +125,7 @@ static struct usb_cdc_header_desc acm_header_desc __initdata = {
        .bLength =              sizeof(acm_header_desc),
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+        .bcdCDC =               cpu_to_le16(0x0110),
 };
 static struct usb_cdc_call_mgmt_descriptor
@@ -159,7 +159,7 @@ static struct usb_endpoint_descriptor acm_fs_notify_desc __initdata = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+        .wMaxPacketSize =       cpu_to_le16(GS_NOTIFY_MAXPACKET),
        .bInterval =            1 << GS_LOG2_NOTIFY_INTERVAL,
 };
@@ -197,7 +197,7 @@ static struct usb_endpoint_descriptor acm_hs_notify_desc __initdata = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+        .wMaxPacketSize =       cpu_to_le16(GS_NOTIFY_MAXPACKET),
        .bInterval =            GS_LOG2_NOTIFY_INTERVAL+4,
 };
@@ -205,14 +205,14 @@ static struct usb_endpoint_descriptor acm_hs_in_desc __initdata = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor acm_hs_out_desc __initdata = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *acm_hs_function[] __initdata = {
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index 4ae579948e54..ecf5bdd0ae06 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -130,7 +130,7 @@ static struct usb_cdc_header_desc ecm_header_desc __initdata = {
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+        .bcdCDC =               cpu_to_le16(0x0110),
 };
 static struct usb_cdc_union_desc ecm_union_desc __initdata = {
@@ -148,9 +148,9 @@ static struct usb_cdc_ether_desc ecm_desc __initdata = {
        /* this descriptor actually adds value, surprise! */
        /* .iMACAddress = DYNAMIC */
-        .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
+        .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */
-        .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
+        .wMaxSegmentSize =      cpu_to_le16(ETH_FRAME_LEN),
-        .wNumberMCFilters =     __constant_cpu_to_le16(0),
+        .wNumberMCFilters =     cpu_to_le16(0),
        .bNumberPowerFilters =  0,
 };
@@ -192,7 +192,7 @@ static struct usb_endpoint_descriptor fs_ecm_notify_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(ECM_STATUS_BYTECOUNT),
+        .wMaxPacketSize =       cpu_to_le16(ECM_STATUS_BYTECOUNT),
        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
 };
@@ -236,7 +236,7 @@ static struct usb_endpoint_descriptor hs_ecm_notify_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(ECM_STATUS_BYTECOUNT),
+        .wMaxPacketSize =       cpu_to_le16(ECM_STATUS_BYTECOUNT),
        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
 };
 static struct usb_endpoint_descriptor hs_ecm_in_desc __initdata = {
@@ -245,7 +245,7 @@ static struct usb_endpoint_descriptor hs_ecm_in_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_ecm_out_desc __initdata = {
@@ -254,7 +254,7 @@ static struct usb_endpoint_descriptor hs_ecm_out_desc __initdata = {
        .bEndpointAddress =     USB_DIR_OUT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *ecm_hs_function[] __initdata = {
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
index 8affe1dfc2c1..eb6ddfc20857 100644
--- a/drivers/usb/gadget/f_loopback.c
+++ b/drivers/usb/gadget/f_loopback.c
@@ -100,7 +100,7 @@ static struct usb_endpoint_descriptor hs_loop_source_desc = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_loop_sink_desc = {
@@ -108,7 +108,7 @@ static struct usb_endpoint_descriptor hs_loop_sink_desc = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *hs_loopback_descs[] = {
@@ -359,7 +359,7 @@ static struct usb_configuration loopback_driver = {
 * loopback_add - add a loopback testing configuration to a device
 * @cdev: the device to support the loopback configuration
 */
-int __init loopback_add(struct usb_composite_dev *cdev)
+int __init loopback_add(struct usb_composite_dev *cdev, bool autoresume)
 {
        int id;
@@ -372,6 +372,10 @@ int __init loopback_add(struct usb_composite_dev *cdev)
        loopback_intf.iInterface = id;
        loopback_driver.iConfiguration = id;
+        /* support autoresume for remote wakeup testing */
+        if (autoresume)
+                sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
        /* support OTG systems */
        if (gadget_is_otg(cdev->gadget)) {
                loopback_driver.descriptors = otg_desc;
diff --git a/drivers/usb/gadget/f_obex.c b/drivers/usb/gadget/f_obex.c
index 38aa896cc5db..46d6266f30ec 100644
--- a/drivers/usb/gadget/f_obex.c
+++ b/drivers/usb/gadget/f_obex.c
@@ -123,7 +123,7 @@ static struct usb_cdc_header_desc obex_cdc_header_desc __initdata = {
        .bLength                = sizeof(obex_cdc_header_desc),
        .bDescriptorType        = USB_DT_CS_INTERFACE,
        .bDescriptorSubType     = USB_CDC_HEADER_TYPE,
-        .bcdCDC                 = __constant_cpu_to_le16(0x0120),
+        .bcdCDC                 = cpu_to_le16(0x0120),
 };
 static struct usb_cdc_union_desc obex_cdc_union_desc __initdata = {
@@ -138,7 +138,7 @@ static struct usb_cdc_obex_desc obex_desc __initdata = {
        .bLength                = sizeof(obex_desc),
        .bDescriptorType        = USB_DT_CS_INTERFACE,
        .bDescriptorSubType     = USB_CDC_OBEX_TYPE,
-        .bcdVersion             = __constant_cpu_to_le16(0x0100),
+        .bcdVersion             = cpu_to_le16(0x0100),
 };
 /* High-Speed Support */
@@ -149,7 +149,7 @@ static struct usb_endpoint_descriptor obex_hs_ep_out_desc __initdata = {
        .bEndpointAddress       = USB_DIR_OUT,
        .bmAttributes           = USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize         = __constant_cpu_to_le16(512),
+        .wMaxPacketSize         = cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor obex_hs_ep_in_desc __initdata = {
@@ -158,7 +158,7 @@ static struct usb_endpoint_descriptor obex_hs_ep_in_desc __initdata = {
        .bEndpointAddress       = USB_DIR_IN,
        .bmAttributes           = USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize         = __constant_cpu_to_le16(512),
+        .wMaxPacketSize         = cpu_to_le16(512),
 };
 static struct usb_descriptor_header *hs_function[] __initdata = {
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index c0916c7b217e..c1abeb89b413 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -79,7 +79,7 @@ pn_header_desc = {
        .bLength =              sizeof pn_header_desc,
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+        .bcdCDC =               cpu_to_le16(0x0110),
 };
 static const struct usb_cdc_header_desc
@@ -87,7 +87,7 @@ pn_phonet_desc = {
        .bLength =              sizeof pn_phonet_desc,
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_PHONET_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x1505), /* ??? */
+        .bcdCDC =               cpu_to_le16(0x1505), /* ??? */
 };
 static struct usb_cdc_union_desc
@@ -138,7 +138,7 @@ pn_hs_sink_desc = {
        .bEndpointAddress =     USB_DIR_OUT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor
@@ -157,7 +157,7 @@ pn_hs_source_desc = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *fs_pn_function[] = {
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 3a8bb53fc473..3279a4726042 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -137,7 +137,7 @@ static struct usb_cdc_header_desc header_desc __initdata = {
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+        .bcdCDC =               cpu_to_le16(0x0110),
 };
 static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor __initdata = {
@@ -187,7 +187,7 @@ static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .wMaxPacketSize =       cpu_to_le16(STATUS_BYTECOUNT),
        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
 };
@@ -230,7 +230,7 @@ static struct usb_endpoint_descriptor hs_notify_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .wMaxPacketSize =       cpu_to_le16(STATUS_BYTECOUNT),
        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
 };
 static struct usb_endpoint_descriptor hs_in_desc __initdata = {
@@ -239,7 +239,7 @@ static struct usb_endpoint_descriptor hs_in_desc __initdata = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_out_desc __initdata = {
@@ -248,7 +248,7 @@ static struct usb_endpoint_descriptor hs_out_desc __initdata = {
        .bEndpointAddress =     USB_DIR_OUT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *eth_hs_function[] __initdata = {
@@ -437,7 +437,7 @@ invalid:
                DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
                        ctrl->bRequestType, ctrl->bRequest,
                        w_value, w_index, w_length);
-                req->zero = 0;
+                req->zero = (value < w_length);
                req->length = value;
                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
                if (value < 0)
diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
index fe5674db344b..db0aa93606ef 100644
--- a/drivers/usb/gadget/f_serial.c
+++ b/drivers/usb/gadget/f_serial.c
@@ -89,14 +89,14 @@ static struct usb_endpoint_descriptor gser_hs_in_desc __initdata = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor gser_hs_out_desc __initdata = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *gser_hs_function[] __initdata = {
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
index dc84d26d2835..bffe91d525f9 100644
--- a/drivers/usb/gadget/f_sourcesink.c
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -59,7 +59,6 @@ struct f_sourcesink {
        struct usb_ep           *in_ep;
        struct usb_ep           *out_ep;
-        struct timer_list       resume;
 };
 static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
@@ -67,10 +66,6 @@ static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
        return container_of(f, struct f_sourcesink, function);
 }
-static unsigned autoresume;
-module_param(autoresume, uint, 0);
-MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
 static unsigned pattern;
 module_param(pattern, uint, 0);
 MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63 ");
@@ -118,7 +113,7 @@ static struct usb_endpoint_descriptor hs_source_desc = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_sink_desc = {
@@ -126,7 +121,7 @@ static struct usb_endpoint_descriptor hs_sink_desc = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *hs_source_sink_descs[] = {
@@ -155,21 +150,6 @@ static struct usb_gadget_strings *sourcesink_strings[] = {
 /*-------------------------------------------------------------------------*/
-static void sourcesink_autoresume(unsigned long _c)
-{
-        struct usb_composite_dev *cdev = (void *)_c;
-        struct usb_gadget       *g = cdev->gadget;
-        /* Normally the host would be woken up for something
-         * more significant than just a timer firing; likely
-         * because of some direct user request.
-         */
-        if (g->speed != USB_SPEED_UNKNOWN) {
-                int status = usb_gadget_wakeup(g);
-                DBG(cdev, "%s --> %d\n", __func__, status);
-        }
-}
 static int __init
 sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
 {
@@ -198,9 +178,6 @@ autoconf_fail:
                goto autoconf_fail;
        ss->out_ep->driver_data = cdev; /* claim */
-        setup_timer(&ss->resume, sourcesink_autoresume,
-                        (unsigned long) c->cdev);
        /* support high speed hardware */
        if (gadget_is_dualspeed(c->cdev->gadget)) {
                hs_source_desc.bEndpointAddress =
@@ -359,7 +336,6 @@ static void disable_source_sink(struct f_sourcesink *ss)
        cdev = ss->function.config->cdev;
        disable_endpoints(cdev, ss->in_ep, ss->out_ep);
-        del_timer(&ss->resume);
        VDBG(cdev, "%s disabled\n", ss->function.name);
 }
@@ -426,30 +402,6 @@ static void sourcesink_disable(struct usb_function *f)
        disable_source_sink(ss);
 }
-static void sourcesink_suspend(struct usb_function *f)
-{
-        struct f_sourcesink     *ss = func_to_ss(f);
-        struct usb_composite_dev *cdev = f->config->cdev;
-        if (cdev->gadget->speed == USB_SPEED_UNKNOWN)
-                return;
-        if (autoresume) {
-                mod_timer(&ss->resume, jiffies + (HZ * autoresume));
-                DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
-        } else
-                DBG(cdev, "%s\n", __func__);
-}
-static void sourcesink_resume(struct usb_function *f)
-{
-        struct f_sourcesink     *ss = func_to_ss(f);
-        struct usb_composite_dev *cdev = f->config->cdev;
-        DBG(cdev, "%s\n", __func__);
-        del_timer(&ss->resume);
-}
 /*-------------------------------------------------------------------------*/
 static int __init sourcesink_bind_config(struct usb_configuration *c)
@@ -467,8 +419,6 @@ static int __init sourcesink_bind_config(struct usb_configuration *c)
        ss->function.unbind = sourcesink_unbind;
        ss->function.set_alt = sourcesink_set_alt;
        ss->function.disable = sourcesink_disable;
-        ss->function.suspend = sourcesink_suspend;
-        ss->function.resume = sourcesink_resume;
        status = usb_add_function(c, &ss->function);
        if (status)
@@ -559,7 +509,7 @@ static struct usb_configuration sourcesink_driver = {
 * sourcesink_add - add a source/sink testing configuration to a device
 * @cdev: the device to support the configuration
 */
-int __init sourcesink_add(struct usb_composite_dev *cdev)
+int __init sourcesink_add(struct usb_composite_dev *cdev, bool autoresume)
 {
        int id;
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index fe1832875771..a9c98fdb626d 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -108,7 +108,7 @@ static struct usb_cdc_header_desc mdlm_header_desc __initdata = {
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+        .bcdCDC =               cpu_to_le16(0x0110),
 };
 static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
@@ -116,7 +116,7 @@ static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
-        .bcdVersion =           __constant_cpu_to_le16(0x0100),
+        .bcdVersion =           cpu_to_le16(0x0100),
        .bGUID = {
                0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
                0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
@@ -144,9 +144,9 @@ static struct usb_cdc_ether_desc ether_desc __initdata = {
        /* this descriptor actually adds value, surprise! */
        /* .iMACAddress = DYNAMIC */
-        .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
+        .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */
-        .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
+        .wMaxSegmentSize =      cpu_to_le16(ETH_FRAME_LEN),
-        .wNumberMCFilters =     __constant_cpu_to_le16(0),
+        .wNumberMCFilters =     cpu_to_le16(0),
        .bNumberPowerFilters =  0,
 };
@@ -186,7 +186,7 @@ static struct usb_endpoint_descriptor hs_subset_in_desc __initdata = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_subset_out_desc __initdata = {
@@ -194,7 +194,7 @@ static struct usb_endpoint_descriptor hs_subset_out_desc __initdata = {
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_descriptor_header *hs_eth_function[] __initdata = {
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 1ab9dac7e12d..d3c2464dee82 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -847,13 +847,13 @@ device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
        /* The next three values can be overridden by module parameters */
-        .idVendor =             __constant_cpu_to_le16(DRIVER_VENDOR_ID),
+        .idVendor =             cpu_to_le16(DRIVER_VENDOR_ID),
-        .idProduct =            __constant_cpu_to_le16(DRIVER_PRODUCT_ID),
+        .idProduct =            cpu_to_le16(DRIVER_PRODUCT_ID),
-        .bcdDevice =            __constant_cpu_to_le16(0xffff),
+        .bcdDevice =            cpu_to_le16(0xffff),
        .iManufacturer =        STRING_MANUFACTURER,
        .iProduct =             STRING_PRODUCT,
@@ -926,7 +926,7 @@ fs_intr_in_desc = {
        .bEndpointAddress =     USB_DIR_IN,
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(2),
+        .wMaxPacketSize =       cpu_to_le16(2),
        .bInterval =            32,     // frames -> 32 ms
 };
@@ -954,7 +954,7 @@ dev_qualifier = {
        .bLength =              sizeof dev_qualifier,
        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
        .bNumConfigurations =   1,
@@ -967,7 +967,7 @@ hs_bulk_in_desc = {
        /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor
@@ -977,7 +977,7 @@ hs_bulk_out_desc = {
        /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+        .wMaxPacketSize =       cpu_to_le16(512),
        .bInterval =            1,      // NAK every 1 uframe
 };
@@ -988,7 +988,7 @@ hs_intr_in_desc = {
        /* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(2),
+        .wMaxPacketSize =       cpu_to_le16(2),
        .bInterval =            9,      // 2**(9-1) = 256 uframes -> 32 ms
 };
@@ -2646,7 +2646,7 @@ static int send_status(struct fsg_dev *fsg)
                struct bulk_cs_wrap     *csw = bh->buf;
                /* Store and send the Bulk-only CSW */
-                csw->Signature = __constant_cpu_to_le32(USB_BULK_CS_SIG);
+                csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
                csw->Tag = fsg->tag;
                csw->Residue = cpu_to_le32(fsg->residue);
                csw->Status = status;
@@ -3089,7 +3089,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
        /* Is the CBW valid? */
        if (req->actual != USB_BULK_CB_WRAP_LEN ||
-                        cbw->Signature != __constant_cpu_to_le32(
+                        cbw->Signature != cpu_to_le32(
                                USB_BULK_CB_SIG)) {
                DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
                                req->actual,
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index d8d9a52a44b3..9d7b95d4e3d2 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -1802,7 +1802,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 out:
        if (retval)
-                printk("gadget driver register failed %d\n", retval);
+                printk(KERN_WARNING "gadget driver register failed %d\n",
+                       retval);
        return retval;
 }
 EXPORT_SYMBOL(usb_gadget_register_driver);
@@ -1847,7 +1848,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
        udc_controller->gadget.dev.driver = NULL;
        udc_controller->driver = NULL;
-        printk("unregistered gadget driver '%s'\n", driver->driver.name);
+        printk(KERN_WARNING "unregistered gadget driver '%s'\n",
+               driver->driver.name);
        return 0;
 }
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
@@ -2455,7 +2457,7 @@ module_init(udc_init);
 static void __exit udc_exit(void)
 {
        platform_driver_unregister(&udc_driver);
-        printk("%s unregistered\n", driver_desc);
+        printk(KERN_WARNING "%s unregistered\n", driver_desc);
 }
 module_exit(udc_exit);
diff --git a/drivers/usb/gadget/g_zero.h b/drivers/usb/gadget/g_zero.h
index dd2f16ad5a88..e84b3c47ed3c 100644
--- a/drivers/usb/gadget/g_zero.h
+++ b/drivers/usb/gadget/g_zero.h
@@ -19,7 +19,7 @@ void disable_endpoints(struct usb_composite_dev *cdev,
                struct usb_ep *in, struct usb_ep *out);
 /* configuration-specific linkup */
-int sourcesink_add(struct usb_composite_dev *cdev);
+int sourcesink_add(struct usb_composite_dev *cdev, bool autoresume);
-int loopback_add(struct usb_composite_dev *cdev);
+int loopback_add(struct usb_composite_dev *cdev, bool autoresume);
 #endif /* __G_ZERO_H */
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 60d3f9e9b51f..b9312dc6e041 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -199,10 +199,10 @@ DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(1);
 static struct usb_device_descriptor device_desc = {
        .bLength =              USB_DT_DEVICE_SIZE,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
-        .idVendor =             __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
+        .idVendor =             cpu_to_le16(DRIVER_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
+        .idProduct =            cpu_to_le16(DRIVER_PRODUCT_NUM),
        .iManufacturer =        STRING_MANUFACTURER,
        .iProduct =             STRING_PRODUCT,
        .bNumConfigurations =   1,
@@ -241,8 +241,8 @@ static const struct usb_ac_header_descriptor_1 ac_header_desc = {
        .bLength =              USB_DT_AC_HEADER_SIZE(1),
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubtype =   USB_MS_HEADER,
-        .bcdADC =               __constant_cpu_to_le16(0x0100),
+        .bcdADC =               cpu_to_le16(0x0100),
-        .wTotalLength =         __constant_cpu_to_le16(USB_DT_AC_HEADER_SIZE(1)),
+        .wTotalLength =         cpu_to_le16(USB_DT_AC_HEADER_SIZE(1)),
        .bInCollection =        1,
        .baInterfaceNr = {
                [0] =           GMIDI_MS_INTERFACE,
@@ -265,8 +265,8 @@ static const struct usb_ms_header_descriptor ms_header_desc = {
        .bLength =              USB_DT_MS_HEADER_SIZE,
        .bDescriptorType =      USB_DT_CS_INTERFACE,
        .bDescriptorSubtype =   USB_MS_HEADER,
-        .bcdMSC =               __constant_cpu_to_le16(0x0100),
+        .bcdMSC =               cpu_to_le16(0x0100),
-        .wTotalLength =         __constant_cpu_to_le16(USB_DT_MS_HEADER_SIZE
+        .wTotalLength =         cpu_to_le16(USB_DT_MS_HEADER_SIZE
                                + 2*USB_DT_MIDI_IN_SIZE
                                + 2*USB_DT_MIDI_OUT_SIZE(1)),
 };
@@ -1099,10 +1099,9 @@ static int gmidi_register_card(struct gmidi_device *dev)
                .dev_free = gmidi_snd_free,
        };
-        card = snd_card_new(index, id, THIS_MODULE, 0);
+        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
-        if (!card) {
+        if (err < 0) {
-                ERROR(dev, "snd_card_new failed\n");
+                ERROR(dev, "snd_card_create failed\n");
-                err = -ENOMEM;
                goto fail;
        }
        dev->card = card;
@@ -1227,7 +1226,7 @@ autoconf_fail:
                 */
                pr_warning("%s: controller '%s' not recognized\n",
                        shortname, gadget->name);
-                device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
+                device_desc.bcdDevice = cpu_to_le16(0x9999);
        }
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 63419c4d503c..de010c939dbb 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1472,7 +1472,7 @@ static void ep0_setup(struct goku_udc *dev)
                                /* active endpoint */
                                if (tmp > 3 || (!dev->ep[tmp].desc && tmp != 0))
                                        goto stall;
-                                if (ctrl.wIndex & __constant_cpu_to_le16(
+                                if (ctrl.wIndex & cpu_to_le16(
                                                USB_DIR_IN)) {
                                        if (!dev->ep[tmp].is_in)
                                                goto stall;
@@ -1480,7 +1480,7 @@ static void ep0_setup(struct goku_udc *dev)
                                        if (dev->ep[tmp].is_in)
                                                goto stall;
                                }
-                                if (ctrl.wValue != __constant_cpu_to_le16(
+                                if (ctrl.wValue != cpu_to_le16(
                                                USB_ENDPOINT_HALT))
                                        goto stall;
                                if (tmp)
@@ -1493,7 +1493,7 @@ succeed:
                                return;
                        case USB_RECIP_DEVICE:
                                /* device remote wakeup: always clear */
-                                if (ctrl.wValue != __constant_cpu_to_le16(1))
+                                if (ctrl.wValue != cpu_to_le16(1))
                                        goto stall;
                                VDBG(dev, "clear dev remote wakeup\n");
                                goto succeed;
@@ -1519,7 +1519,7 @@ succeed:
        dev->req_config = (ctrl.bRequest == USB_REQ_SET_CONFIGURATION
                                && ctrl.bRequestType == USB_RECIP_DEVICE);
        if (unlikely(dev->req_config))
-                dev->configured = (ctrl.wValue != __constant_cpu_to_le16(0));
+                dev->configured = (ctrl.wValue != cpu_to_le16(0));
        /* delegate everything to the gadget driver.
         * it may respond after this irq handler returns.
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index 77c5d0a8a06e..168658b4b4e2 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -1,7 +1,7 @@
 /*
 *      driver/usb/gadget/imx_udc.c
 *
- *      Copyright (C) 2005 Mike Lee(eemike@gmail.com)
+ *      Copyright (C) 2005 Mike Lee <eemike@gmail.com>
 *      Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
 *
 *      This program is free software; you can redistribute it and/or modify
@@ -28,6 +28,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <linux/delay.h>
+#include <linux/timer.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -51,7 +52,8 @@ void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
 void imx_udc_enable(struct imx_udc_struct *imx_usb)
 {
        int temp = __raw_readl(imx_usb->base + USB_CTRL);
-        __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA, imx_usb->base + USB_CTRL);
+        __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA,
+                                                imx_usb->base + USB_CTRL);
        imx_usb->gadget.speed = USB_SPEED_FULL;
 }
@@ -126,7 +128,8 @@ void imx_udc_config(struct imx_udc_struct *imx_usb)
                        for (j = 0; j < 5; j++) {
                                __raw_writeb(ep_conf[j],
                                        imx_usb->base + USB_DDAT);
-                                do {} while (__raw_readl(imx_usb->base + USB_DADR)
+                                do {} while (__raw_readl(imx_usb->base
+                                                                + USB_DADR)
                                        & DADR_BSY);
                        }
                }
@@ -183,7 +186,8 @@ void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
                temp = (EP_DIR(imx_ep) << 7) | (max << 5)
                        | (imx_ep->bmAttributes << 3);
                __raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
-                __raw_writel(temp | EPSTAT_FLUSH, imx_usb->base + USB_EP_STAT(i));
+                __raw_writel(temp | EPSTAT_FLUSH,
+                                                imx_usb->base + USB_EP_STAT(i));
                D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
                        __raw_readl(imx_usb->base + USB_EP_STAT(i)));
        }
@@ -278,15 +282,18 @@ void imx_ep_stall(struct imx_ep_struct *imx_ep)
        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
        int temp, i;
-        D_ERR(imx_usb->dev, "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
+        D_ERR(imx_usb->dev,
+                "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
        imx_flush(imx_ep);
        /* Special care for ep0 */
-        if (EP_NO(imx_ep)) {
+        if (!EP_NO(imx_ep)) {
                temp = __raw_readl(imx_usb->base + USB_CTRL);
-                __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR, imx_usb->base + USB_CTRL);
+                __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR,
-                do { } while (__raw_readl(imx_usb->base + USB_CTRL) & CTRL_CMDOVER);
+                                                imx_usb->base + USB_CTRL);
+                do { } while (__raw_readl(imx_usb->base + USB_CTRL)
+                                                & CTRL_CMDOVER);
                temp = __raw_readl(imx_usb->base + USB_CTRL);
                __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
        }
@@ -296,12 +303,13 @@ void imx_ep_stall(struct imx_ep_struct *imx_ep)
                        imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
                for (i = 0; i < 100; i ++) {
-                        temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                        temp = __raw_readl(imx_usb->base
+                                                + USB_EP_STAT(EP_NO(imx_ep)));
                        if (!(temp & EPSTAT_STALL))
                                break;
                        udelay(20);
                }
-                if (i == 50)
+                if (i == 100)
                        D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
                                __func__, imx_ep->ep.name);
        }
@@ -325,7 +333,8 @@ static int imx_udc_wakeup(struct usb_gadget *_gadget)
 *******************************************************************************
 */
-static void ep_add_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+static void ep_add_request(struct imx_ep_struct *imx_ep,
+                                                        struct imx_request *req)
 {
        if (unlikely(!req))
                return;
@@ -334,7 +343,8 @@ static void ep_add_request(struct imx_ep_struct *imx_ep, struct imx_request *req
        list_add_tail(&req->queue, &imx_ep->queue);
 }
-static void ep_del_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+static void ep_del_request(struct imx_ep_struct *imx_ep,
+                                                        struct imx_request *req)
 {
        if (unlikely(!req))
                return;
@@ -343,7 +353,8 @@ static void ep_del_request(struct imx_ep_struct *imx_ep, struct imx_request *req
        req->in_use = 0;
 }
-static void done(struct imx_ep_struct *imx_ep, struct imx_request *req, int status)
+static void done(struct imx_ep_struct *imx_ep,
+                                        struct imx_request *req, int status)
 {
        ep_del_request(imx_ep, req);
@@ -494,7 +505,8 @@ static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
                                __func__, imx_ep->ep.name, req,
                                completed ? "completed" : "not completed");
                        if (!EP_NO(imx_ep))
-                                ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
+                                ep0_chg_stat(__func__,
+                                                imx_ep->imx_usb, EP0_IDLE);
                }
        }
@@ -539,10 +551,9 @@ static int handle_ep0(struct imx_ep_struct *imx_ep)
        struct imx_request *req = NULL;
        int ret = 0;
-        if (!list_empty(&imx_ep->queue))
+        if (!list_empty(&imx_ep->queue)) {
                req = list_entry(imx_ep->queue.next, struct imx_request, queue);
-        if (req) {
                switch (imx_ep->imx_usb->ep0state) {
                case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR */
@@ -561,6 +572,10 @@ static int handle_ep0(struct imx_ep_struct *imx_ep)
                }
        }
+        else
+                D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
+                                                __func__, imx_ep->ep.name);
        return ret;
 }
@@ -583,7 +598,8 @@ static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
                                "<%s> no setup packet received\n", __func__);
                        goto stall;
                }
-                u.word[i] = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
+                u.word[i] = __raw_readl(imx_usb->base
+                                                + USB_EP_FDAT(EP_NO(imx_ep)));
        }
        temp = imx_ep_empty(imx_ep);
@@ -759,7 +775,7 @@ static int imx_ep_queue
        */
        if (imx_usb->set_config && !EP_NO(imx_ep)) {
                imx_usb->set_config = 0;
-                D_EPX(imx_usb->dev,
+                D_ERR(imx_usb->dev,
                        "<%s> gadget reply set config\n", __func__);
                return 0;
        }
@@ -779,28 +795,29 @@ static int imx_ep_queue
                return -ESHUTDOWN;
        }
-        local_irq_save(flags);
        /* Debug */
        D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
                __func__, EP_NO(imx_ep),
-                ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
-                || (EP_NO(imx_ep) && EP_DIR(imx_ep))) ? "IN" : "OUT", usb_req->length);
+                                                        == EP0_IN_DATA_PHASE)
+                || (EP_NO(imx_ep) && EP_DIR(imx_ep)))
+                                        ? "IN" : "OUT", usb_req->length);
        dump_req(__func__, imx_ep, usb_req);
        if (imx_ep->stopped) {
                usb_req->status = -ESHUTDOWN;
-                ret = -ESHUTDOWN;
+                return -ESHUTDOWN;
-                goto out;
        }
        if (req->in_use) {
                D_ERR(imx_usb->dev,
                        "<%s> refusing to queue req %p (already queued)\n",
                        __func__, req);
-                goto out;
+                return 0;
        }
+        local_irq_save(flags);
        usb_req->status = -EINPROGRESS;
        usb_req->actual = 0;
@@ -810,7 +827,7 @@ static int imx_ep_queue
                ret = handle_ep0(imx_ep);
        else
                ret = handle_ep(imx_ep);
-out:
        local_irq_restore(flags);
        return ret;
 }
@@ -997,71 +1014,32 @@ static void udc_stop_activity(struct imx_udc_struct *imx_usb,
 *******************************************************************************
 */
-static irqreturn_t imx_udc_irq(int irq, void *dev)
+/*
+ * Called when timer expires.
+ * Timer is started when CFG_CHG is received.
+ */
+static void handle_config(unsigned long data)
 {
-        struct imx_udc_struct *imx_usb = dev;
+        struct imx_udc_struct *imx_usb = (void *)data;
        struct usb_ctrlrequest u;
        int temp, cfg, intf, alt;
-        int intr = __raw_readl(imx_usb->base + USB_INTR);
-        if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
+        local_irq_disable();
-                        | INTR_RESET_STOP | INTR_CFG_CHG)) {
-                                dump_intr(__func__, intr, imx_usb->dev);
-                                dump_usb_stat(__func__, imx_usb);
-        }
-        if (!imx_usb->driver) {
+        temp = __raw_readl(imx_usb->base + USB_STAT);
-                /*imx_udc_disable(imx_usb);*/
+        cfg  = (temp & STAT_CFG) >> 5;
-                goto end_irq;
+        intf = (temp & STAT_INTF) >> 3;
-        }
+        alt  =  temp & STAT_ALTSET;
-        if (intr & INTR_WAKEUP) {
+        D_REQ(imx_usb->dev,
-                if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
+                "<%s> orig config C=%d, I=%d, A=%d / "
-                        && imx_usb->driver && imx_usb->driver->resume)
+                "req config C=%d, I=%d, A=%d\n",
-                                imx_usb->driver->resume(&imx_usb->gadget);
+                __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
-                imx_usb->set_config = 0;
+                cfg, intf, alt);
-                imx_usb->gadget.speed = USB_SPEED_FULL;
-        }
-        if (intr & INTR_SUSPEND) {
-                if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
-                        && imx_usb->driver && imx_usb->driver->suspend)
-                                imx_usb->driver->suspend(&imx_usb->gadget);
-                imx_usb->set_config = 0;
-                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
-        }
-        if (intr & INTR_RESET_START) {
-                __raw_writel(intr, imx_usb->base + USB_INTR);
-                udc_stop_activity(imx_usb, imx_usb->driver);
-                imx_usb->set_config = 0;
-                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
-        }
-        if (intr & INTR_RESET_STOP)
+        if (cfg == 1 || cfg == 2) {
-                imx_usb->gadget.speed = USB_SPEED_FULL;
-        if (intr & INTR_CFG_CHG) {
-                __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
-                temp = __raw_readl(imx_usb->base + USB_STAT);
-                cfg  = (temp & STAT_CFG) >> 5;
-                intf = (temp & STAT_INTF) >> 3;
-                alt  =  temp & STAT_ALTSET;
-                D_REQ(imx_usb->dev,
-                        "<%s> orig config C=%d, I=%d, A=%d / "
-                        "req config C=%d, I=%d, A=%d\n",
-                        __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
-                        cfg, intf, alt);
-                if (cfg != 1 && cfg != 2)
-                        goto end_irq;
-                imx_usb->set_config = 0;
-                /* Config setup */
                if (imx_usb->cfg != cfg) {
-                        D_REQ(imx_usb->dev, "<%s> Change config start\n",__func__);
                        u.bRequest = USB_REQ_SET_CONFIGURATION;
                        u.bRequestType = USB_DIR_OUT |
                                        USB_TYPE_STANDARD |
@@ -1070,14 +1048,10 @@ static irqreturn_t imx_udc_irq(int irq, void *dev)
                        u.wIndex = 0;
                        u.wLength = 0;
                        imx_usb->cfg = cfg;
-                        imx_usb->set_config = 1;
                        imx_usb->driver->setup(&imx_usb->gadget, &u);
-                        imx_usb->set_config = 0;
-                        D_REQ(imx_usb->dev, "<%s> Change config done\n",__func__);
                }
                if (imx_usb->intf != intf || imx_usb->alt != alt) {
-                        D_REQ(imx_usb->dev, "<%s> Change interface start\n",__func__);
                        u.bRequest = USB_REQ_SET_INTERFACE;
                        u.bRequestType = USB_DIR_OUT |
                                          USB_TYPE_STANDARD |
@@ -1087,20 +1061,92 @@ static irqreturn_t imx_udc_irq(int irq, void *dev)
                        u.wLength = 0;
                        imx_usb->intf = intf;
                        imx_usb->alt = alt;
-                        imx_usb->set_config = 1;
                        imx_usb->driver->setup(&imx_usb->gadget, &u);
-                        imx_usb->set_config = 0;
-                        D_REQ(imx_usb->dev, "<%s> Change interface done\n",__func__);
                }
        }
+        imx_usb->set_config = 0;
+        local_irq_enable();
+}
+static irqreturn_t imx_udc_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        int intr = __raw_readl(imx_usb->base + USB_INTR);
+        int temp;
+        if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
+                        | INTR_RESET_STOP | INTR_CFG_CHG)) {
+                                dump_intr(__func__, intr, imx_usb->dev);
+                                dump_usb_stat(__func__, imx_usb);
+        }
+        if (!imx_usb->driver)
+                goto end_irq;
        if (intr & INTR_SOF) {
+                /* Copy from Freescale BSP.
+                   We must enable SOF intr and set CMDOVER.
+                   Datasheet don't specifiy this action, but it
+                   is done in Freescale BSP, so just copy it.
+                */
                if (imx_usb->ep0state == EP0_IDLE) {
                        temp = __raw_readl(imx_usb->base + USB_CTRL);
-                        __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
+                        __raw_writel(temp | CTRL_CMDOVER,
+                                                imx_usb->base + USB_CTRL);
                }
        }
+        if (intr & INTR_CFG_CHG) {
+                /* A workaround of serious IMX UDC bug.
+                   Handling of CFG_CHG should be delayed for some time, because
+                   IMX does not NACK the host when CFG_CHG interrupt is pending.
+                   There is no time to handle current CFG_CHG
+                   if next CFG_CHG or SETUP packed is send immediately.
+                   We have to clear CFG_CHG, start the timer and
+                   NACK the host by setting CTRL_CMDOVER
+                   if it sends any SETUP packet.
+                   When timer expires, handler is called to handle configuration
+                   changes. While CFG_CHG is not handled (set_config=1),
+                   we must NACK the host to every SETUP packed.
+                   This delay prevents from going out of sync with host.
+                 */
+                __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
+                imx_usb->set_config = 1;
+                mod_timer(&imx_usb->timer, jiffies + 5);
+                goto end_irq;
+        }
+        if (intr & INTR_WAKEUP) {
+                if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->resume)
+                                imx_usb->driver->resume(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                del_timer(&imx_usb->timer);
+                imx_usb->gadget.speed = USB_SPEED_FULL;
+        }
+        if (intr & INTR_SUSPEND) {
+                if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->suspend)
+                                imx_usb->driver->suspend(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                del_timer(&imx_usb->timer);
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+        if (intr & INTR_RESET_START) {
+                __raw_writel(intr, imx_usb->base + USB_INTR);
+                udc_stop_activity(imx_usb, imx_usb->driver);
+                imx_usb->set_config = 0;
+                del_timer(&imx_usb->timer);
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+        if (intr & INTR_RESET_STOP)
+                imx_usb->gadget.speed = USB_SPEED_FULL;
 end_irq:
        __raw_writel(intr, imx_usb->base + USB_INTR);
        return IRQ_HANDLED;
@@ -1109,6 +1155,7 @@ end_irq:
 static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
 {
        struct imx_udc_struct *imx_usb = dev;
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
        int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
        dump_ep_intr(__func__, 0, intr, imx_usb->dev);
@@ -1118,16 +1165,15 @@ static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
                return IRQ_HANDLED;
        }
-        /* DEVREQ IRQ has highest priority */
+        /* DEVREQ has highest priority */
        if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
                handle_ep0_devreq(imx_usb);
        /* Seem i.MX is missing EOF interrupt sometimes.
-         * Therefore we monitor both EOF and FIFO_EMPTY interrups
+         * Therefore we don't monitor EOF.
-         * when transmiting, and both EOF and FIFO_FULL when
+         * We call handle_ep0() only if a request is queued for ep0.
-         * receiving data.
         */
-        else if (intr & (EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL))
+        else if (!list_empty(&imx_ep->queue))
-                handle_ep0(&imx_usb->imx_ep[0]);
+                handle_ep0(imx_ep);
        __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
@@ -1186,8 +1232,8 @@ static struct imx_udc_struct controller = {
                .ep0            = &controller.imx_ep[0].ep,
                .name           = driver_name,
                .dev = {
-                         .bus_id        = "gadget",
+                        .init_name      = "gadget",
-                 },
+                },
        },
        .imx_ep[0] = {
@@ -1318,6 +1364,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
        udc_stop_activity(imx_usb, driver);
        imx_udc_disable(imx_usb);
+        del_timer(&imx_usb->timer);
        driver->unbind(&imx_usb->gadget);
        imx_usb->gadget.dev.driver = NULL;
@@ -1435,6 +1482,10 @@ static int __init imx_udc_probe(struct platform_device *pdev)
        usb_init_data(imx_usb);
        imx_udc_init(imx_usb);
+        init_timer(&imx_usb->timer);
+        imx_usb->timer.function = handle_config;
+        imx_usb->timer.data = (unsigned long)imx_usb;
        return 0;
 fail3:
@@ -1457,6 +1508,7 @@ static int __exit imx_udc_remove(struct platform_device *pdev)
        int i;
        imx_udc_disable(imx_usb);
+        del_timer(&imx_usb->timer);
        for (i = 0; i < IMX_USB_NB_EP + 1; i++)
                free_irq(imx_usb->usbd_int[i], imx_usb);
diff --git a/drivers/usb/gadget/imx_udc.h b/drivers/usb/gadget/imx_udc.h
index 850076937d8d..b48ad59603d1 100644
--- a/drivers/usb/gadget/imx_udc.h
+++ b/drivers/usb/gadget/imx_udc.h
@@ -23,7 +23,8 @@
 /* Helper macros */
 #define EP_NO(ep)       ((ep->bEndpointAddress) & ~USB_DIR_IN) /* IN:1, OUT:0 */
 #define EP_DIR(ep)      ((ep->bEndpointAddress) & USB_DIR_IN ? 1 : 0)
-#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
+#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) \
+                ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
 #define ep_to_irq(ep)   (EP_NO((ep)) + USBD_INT0)
 #define IMX_USB_NB_EP   6
@@ -58,6 +59,7 @@ struct imx_udc_struct {
        struct device                           *dev;
        struct imx_ep_struct                    imx_ep[IMX_USB_NB_EP];
        struct clk                              *clk;
+        struct timer_list                       timer;
        enum ep0_state                          ep0state;
        struct resource                         *res;
        void __iomem                            *base;
@@ -88,8 +90,8 @@ struct imx_udc_struct {
 #define  USB_EP_FDAT3(x)        (0x3F + (x*0x30)) /* USB FIFO data */
 #define  USB_EP_FSTAT(x)        (0x40 + (x*0x30)) /* USB FIFO status */
 #define  USB_EP_FCTRL(x)        (0x44 + (x*0x30)) /* USB FIFO control */
-#define  USB_EP_LRFP(x)         (0x48 + (x*0x30)) /* USB last read frame pointer */
+#define  USB_EP_LRFP(x)         (0x48 + (x*0x30)) /* USB last rd f. pointer */
-#define  USB_EP_LWFP(x)         (0x4C + (x*0x30)) /* USB last write frame pointer */
+#define  USB_EP_LWFP(x)         (0x4C + (x*0x30)) /* USB last wr f. pointer */
 #define  USB_EP_FALRM(x)        (0x50 + (x*0x30)) /* USB FIFO alarm */
 #define  USB_EP_FRDP(x)         (0x54 + (x*0x30)) /* USB FIFO read pointer */
 #define  USB_EP_FWRP(x)         (0x58 + (x*0x30)) /* USB FIFO write pointer */
@@ -170,7 +172,7 @@ struct imx_udc_struct {
 /* #define DEBUG_IRQ */
 /* #define DEBUG_EPIRQ */
 /* #define DEBUG_DUMP */
-#define DEBUG_ERR
+/* #define DEBUG_ERR */
 #ifdef DEBUG_REQ
        #define D_REQ(dev, args...)     dev_dbg(dev, ## args)
@@ -228,7 +230,8 @@ struct imx_udc_struct {
 #endif /* DEBUG_IRQ */
 #ifdef DEBUG_EPIRQ
-        static void dump_ep_intr(const char *label, int nr, int irqreg, struct device *dev)
+        static void dump_ep_intr(const char *label, int nr, int irqreg,
+                                                        struct device *dev)
        {
                dev_dbg(dev, "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, nr,
                        (irqreg & EPINTR_FIFO_FULL) ? " full" : "",
@@ -246,7 +249,8 @@ struct imx_udc_struct {
 #endif /* DEBUG_IRQ */
 #ifdef DEBUG_DUMP
-        static void dump_usb_stat(const char *label, struct imx_udc_struct *imx_usb)
+        static void dump_usb_stat(const char *label,
+                                                struct imx_udc_struct *imx_usb)
        {
                int temp = __raw_readl(imx_usb->base + USB_STAT);
@@ -259,12 +263,15 @@ struct imx_udc_struct {
                        (temp & STAT_ALTSET));
        }
-        static void dump_ep_stat(const char *label, struct imx_ep_struct *imx_ep)
+        static void dump_ep_stat(const char *label,
+                                                struct imx_ep_struct *imx_ep)
        {
-                int temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+                int temp = __raw_readl(imx_ep->imx_usb->base
+                                                + USB_EP_INTR(EP_NO(imx_ep)));
                dev_dbg(imx_ep->imx_usb->dev,
-                        "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n",
+                        label, EP_NO(imx_ep),
                        (temp & EPINTR_FIFO_FULL) ? " full" : "",
                        (temp & EPINTR_FIFO_EMPTY) ? " fempty" : "",
                        (temp & EPINTR_FIFO_ERROR) ? " ferr" : "",
@@ -275,18 +282,22 @@ struct imx_udc_struct {
                        (temp & EPINTR_DEVREQ) ? " devreq" : "",
                        (temp & EPINTR_EOT) ? " eot" : "");
-                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                temp = __raw_readl(imx_ep->imx_usb->base
+                                                + USB_EP_STAT(EP_NO(imx_ep)));
                dev_dbg(imx_ep->imx_usb->dev,
-                        "<%s> EP%d_STAT=[%s%s bcount=%d]\n", label, EP_NO(imx_ep),
+                        "<%s> EP%d_STAT=[%s%s bcount=%d]\n",
+                        label, EP_NO(imx_ep),
                        (temp & EPSTAT_SIP) ? " sip" : "",
                        (temp & EPSTAT_STALL) ? " stall" : "",
                        (temp & EPSTAT_BCOUNT) >> 16);
-                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)));
+                temp = __raw_readl(imx_ep->imx_usb->base
+                                                + USB_EP_FSTAT(EP_NO(imx_ep)));
                dev_dbg(imx_ep->imx_usb->dev,
-                        "<%s> EP%d_FSTAT=[%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        "<%s> EP%d_FSTAT=[%s%s%s%s%s%s%s]\n",
+                        label, EP_NO(imx_ep),
                        (temp & FSTAT_ERR) ? " ferr" : "",
                        (temp & FSTAT_UF) ? " funder" : "",
                        (temp & FSTAT_OF) ? " fover" : "",
@@ -296,19 +307,23 @@ struct imx_udc_struct {
                        (temp & FSTAT_EMPTY) ? " fempty" : "");
        }
-        static void dump_req(const char *label, struct imx_ep_struct *imx_ep, struct usb_request *req)
+        static void dump_req(const char *label, struct imx_ep_struct *imx_ep,
+                                                        struct usb_request *req)
        {
                int i;
                if (!req || !req->buf) {
-                        dev_dbg(imx_ep->imx_usb->dev, "<%s> req or req buf is free\n", label);
+                        dev_dbg(imx_ep->imx_usb->dev,
+                                        "<%s> req or req buf is free\n", label);
                        return;
                }
-                if ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                if ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
+                        == EP0_IN_DATA_PHASE)
                        || (EP_NO(imx_ep) && EP_DIR(imx_ep))) {
-                        dev_dbg(imx_ep->imx_usb->dev, "<%s> request dump <", label);
+                        dev_dbg(imx_ep->imx_usb->dev,
+                                                "<%s> request dump <", label);
                        for (i = 0; i < req->length; i++)
                                printk("%02x-", *((u8 *)req->buf + i));
                        printk(">\n");
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index 317b48fdbf01..d20937f28a19 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1334,7 +1334,7 @@ static void make_qualifier (struct dev_data *dev)
        qual.bLength = sizeof qual;
        qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
-        qual.bcdUSB = __constant_cpu_to_le16 (0x0200);
+        qual.bcdUSB = cpu_to_le16 (0x0200);
        desc = dev->dev;
        qual.bDeviceClass = desc->bDeviceClass;
@@ -1908,7 +1908,7 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
                        || dev->dev->bNumConfigurations != 1)
                goto fail;
        dev->dev->bNumConfigurations = 1;
-        dev->dev->bcdUSB = __constant_cpu_to_le16 (0x0200);
+        dev->dev->bcdUSB = cpu_to_le16 (0x0200);
        /* triggers gadgetfs_bind(); then we can enumerate. */
        spin_unlock_irq (&dev->lock);
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
index d554b0895603..6cd3d54f5640 100644
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ b/drivers/usb/gadget/lh7a40x_udc.c
@@ -432,8 +432,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
        device_add(&dev->gadget.dev);
        retval = driver->bind(&dev->gadget);
        if (retval) {
-                printk("%s: bind to driver %s --> error %d\n", dev->gadget.name,
+                printk(KERN_WARNING "%s: bind to driver %s --> error %d\n",
-                       driver->driver.name, retval);
+                       dev->gadget.name, driver->driver.name, retval);
                device_del(&dev->gadget.dev);
                dev->driver = 0;
@@ -445,8 +445,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         * for set_configuration as well as eventual disconnect.
         * NOTE:  this shouldn't power up until later.
         */
-        printk("%s: registered gadget driver '%s'\n", dev->gadget.name,
+        printk(KERN_WARNING "%s: registered gadget driver '%s'\n",
-               driver->driver.name);
+               dev->gadget.name, driver->driver.name);
        udc_enable(dev);
@@ -581,7 +581,8 @@ static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
                         * discard the extra data.
                         */
                        if (req->req.status != -EOVERFLOW)
-                                printk("%s overflow %d\n", ep->ep.name, count);
+                                printk(KERN_WARNING "%s overflow %d\n",
+                                       ep->ep.name, count);
                        req->req.status = -EOVERFLOW;
                } else {
                        *buf++ = byte;
@@ -831,7 +832,8 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
                                                       queue);
                                if (!req) {
-                                        printk("%s: NULL REQ %d\n",
+                                        printk(KERN_WARNING
+                                               "%s: NULL REQ %d\n",
                                               __func__, ep_idx);
                                        flush(ep);
                                        break;
@@ -844,7 +846,7 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
        } else {
                /* Throw packet away.. */
-                printk("%s: No descriptor?!?\n", __func__);
+                printk(KERN_WARNING "%s: No descriptor?!?\n", __func__);
                flush(ep);
        }
 }
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 12c6d83b218c..9498be87a724 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -142,8 +142,8 @@ static char *type_string (u8 bmAttributes)
 #include "net2280.h"
-#define valid_bit       __constant_cpu_to_le32 (1 << VALID_BIT)
+#define valid_bit       cpu_to_le32 (1 << VALID_BIT)
-#define dma_done_ie     __constant_cpu_to_le32 (1 << DMA_DONE_INTERRUPT_ENABLE)
+#define dma_done_ie     cpu_to_le32 (1 << DMA_DONE_INTERRUPT_ENABLE)
 /*-------------------------------------------------------------------------*/
@@ -425,7 +425,7 @@ net2280_alloc_request (struct usb_ep *_ep, gfp_t gfp_flags)
                        return NULL;
                }
                td->dmacount = 0;       /* not VALID */
-                td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
+                td->dmaaddr = cpu_to_le32 (DMA_ADDR_INVALID);
                td->dmadesc = td->dmaaddr;
                req->td = td;
        }
@@ -775,7 +775,7 @@ static void start_dma (struct net2280_ep *ep, struct net2280_request *req)
        fill_dma_desc (ep, req, 1);
        if (!use_dma_chaining)
-                req->td->dmacount |= __constant_cpu_to_le32 (1 << END_OF_CHAIN);
+                req->td->dmacount |= cpu_to_le32 (1 << END_OF_CHAIN);
        start_queue (ep, tmp, req->td_dma);
 }
@@ -2407,9 +2407,9 @@ static void handle_stat0_irqs (struct net2280 *dev, u32 stat)
                        if (readl (&e->regs->ep_rsp)
                                        & (1 << SET_ENDPOINT_HALT))
-                                status = __constant_cpu_to_le32 (1);
+                                status = cpu_to_le32 (1);
                        else
-                                status = __constant_cpu_to_le32 (0);
+                                status = cpu_to_le32 (0);
                        /* don't bother with a request object! */
                        writel (0, &dev->epregs [0].ep_irqenb);
@@ -2667,7 +2667,7 @@ static void handle_stat1_irqs (struct net2280 *dev, u32 stat)
                                req = list_entry (ep->queue.next,
                                                struct net2280_request, queue);
                                dmacount = req->td->dmacount;
-                                dmacount &= __constant_cpu_to_le32 (
+                                dmacount &= cpu_to_le32 (
                                                (1 << VALID_BIT)
                                                | DMA_BYTE_COUNT_MASK);
                                if (dmacount && (dmacount & valid_bit) == 0)
@@ -2881,7 +2881,7 @@ static int net2280_probe (struct pci_dev *pdev, const struct pci_device_id *id)
                        goto done;
                }
                td->dmacount = 0;       /* not VALID */
-                td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
+                td->dmaaddr = cpu_to_le32 (DMA_ADDR_INVALID);
                td->dmadesc = td->dmaaddr;
                dev->ep [i].dummy = td;
        }
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 5a3034fdfe47..29500154d00c 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -225,12 +225,12 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR);
 static struct usb_device_descriptor device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
        .bDeviceSubClass =      0,
        .bDeviceProtocol =      0,
-        .idVendor =             __constant_cpu_to_le16(PRINTER_VENDOR_NUM),
+        .idVendor =             cpu_to_le16(PRINTER_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16(PRINTER_PRODUCT_NUM),
+        .idProduct =            cpu_to_le16(PRINTER_PRODUCT_NUM),
        .iManufacturer =        STRING_MANUFACTURER,
        .iProduct =             STRING_PRODUCT,
        .iSerialNumber =        STRING_SERIALNUM,
@@ -299,20 +299,20 @@ static struct usb_endpoint_descriptor hs_ep_in_desc = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512)
+        .wMaxPacketSize =       cpu_to_le16(512)
 };
 static struct usb_endpoint_descriptor hs_ep_out_desc = {
        .bLength =              USB_DT_ENDPOINT_SIZE,
        .bDescriptorType =      USB_DT_ENDPOINT,
        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512)
+        .wMaxPacketSize =       cpu_to_le16(512)
 };
 static struct usb_qualifier_descriptor dev_qualifier = {
        .bLength =              sizeof dev_qualifier,
        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_PRINTER,
        .bNumConfigurations =   1
 };
@@ -1406,16 +1406,16 @@ printer_bind(struct usb_gadget *gadget)
                        gadget->name);
                /* unrecognized, but safe unless bulk is REALLY quirky */
                device_desc.bcdDevice =
-                        __constant_cpu_to_le16(0xFFFF);
+                        cpu_to_le16(0xFFFF);
        }
        snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
                init_utsname()->sysname, init_utsname()->release,
                gadget->name);
        device_desc.idVendor =
-                __constant_cpu_to_le16(PRINTER_VENDOR_NUM);
+                cpu_to_le16(PRINTER_VENDOR_NUM);
        device_desc.idProduct =
-                __constant_cpu_to_le16(PRINTER_PRODUCT_NUM);
+                cpu_to_le16(PRINTER_PRODUCT_NUM);
        /* support optional vendor/distro customization */
        if (idVendor) {
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 990f40f988d4..8cc676ecbb23 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -30,6 +30,7 @@
 #include <linux/proc_fs.h>
 #include <linux/clk.h>
 #include <linux/irq.h>
+#include <linux/gpio.h>
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
@@ -278,7 +279,7 @@ static void pxa_init_debugfs(struct pxa_udc *udc)
                goto err_queues;
        eps = debugfs_create_file("epstate", 0400, root, udc,
                        &eps_dbg_fops);
-        if (!queues)
+        if (!eps)
                goto err_eps;
        udc->debugfs_root = root;
@@ -747,13 +748,13 @@ static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status)
 }
 /**
- * ep_end_out_req - Ends control endpoint in request
+ * ep_end_out_req - Ends endpoint OUT request
 * @ep: physical endpoint
 * @req: pxa request
 *
 * Context: ep->lock held
 *
- * Ends endpoint in request (completes usb request).
+ * Ends endpoint OUT request (completes usb request).
 */
 static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
 {
@@ -762,13 +763,13 @@ static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
 }
 /**
- * ep0_end_out_req - Ends control endpoint in request (ends data stage)
+ * ep0_end_out_req - Ends control endpoint OUT request (ends data stage)
 * @ep: physical endpoint
 * @req: pxa request
 *
 * Context: ep->lock held
 *
- * Ends control endpoint in request (completes usb request), and puts
+ * Ends control endpoint OUT request (completes usb request), and puts
 * control endpoint into idle state
 */
 static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
@@ -779,13 +780,13 @@ static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
 }
 /**
- * ep_end_in_req - Ends endpoint out request
+ * ep_end_in_req - Ends endpoint IN request
 * @ep: physical endpoint
 * @req: pxa request
 *
 * Context: ep->lock held
 *
- * Ends endpoint out request (completes usb request).
+ * Ends endpoint IN request (completes usb request).
 */
 static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
 {
@@ -794,20 +795,18 @@ static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
 }
 /**
- * ep0_end_in_req - Ends control endpoint out request (ends data stage)
+ * ep0_end_in_req - Ends control endpoint IN request (ends data stage)
 * @ep: physical endpoint
 * @req: pxa request
 *
 * Context: ep->lock held
 *
- * Ends control endpoint out request (completes usb request), and puts
+ * Ends control endpoint IN request (completes usb request), and puts
 * control endpoint into status state
 */
 static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
 {
-        struct pxa_udc *udc = ep->dev;
+        set_ep0state(ep->dev, IN_STATUS_STAGE);
-        set_ep0state(udc, IN_STATUS_STAGE);
        ep_end_in_req(ep, req);
 }
@@ -1167,7 +1166,7 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
                                ep_end_in_req(ep, req);
                        } else {
                                ep_err(ep, "got a request of %d bytes while"
-                                        "in state WATI_ACK_SET_CONF_INTERF\n",
+                                        "in state WAIT_ACK_SET_CONF_INTERF\n",
                                        length);
                                ep_del_request(ep, req);
                                rc = -EL2HLT;
@@ -1213,30 +1212,26 @@ static int pxa_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
        struct udc_usb_ep       *udc_usb_ep;
        struct pxa27x_request   *req;
        unsigned long           flags;
-        int                     rc;
+        int                     rc = -EINVAL;
        if (!_ep)
-                return -EINVAL;
+                return rc;
        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
        ep = udc_usb_ep->pxa_ep;
        if (!ep || is_ep0(ep))
-                return -EINVAL;
+                return rc;
        spin_lock_irqsave(&ep->lock, flags);
        /* make sure it's actually queued on this endpoint */
        list_for_each_entry(req, &ep->queue, queue) {
-                if (&req->req == _req)
+                if (&req->req == _req) {
+                        req_done(ep, req, -ECONNRESET);
+                        rc = 0;
                        break;
+                }
        }
-        rc = -EINVAL;
-        if (&req->req != _req)
-                goto out;
-        rc = 0;
-        req_done(ep, req, -ECONNRESET);
-out:
        spin_unlock_irqrestore(&ep->lock, flags);
        return rc;
 }
@@ -1471,6 +1466,32 @@ static struct usb_ep_ops pxa_ep_ops = {
        .fifo_flush     = pxa_ep_fifo_flush,
 };
+/**
+ * dplus_pullup - Connect or disconnect pullup resistor to D+ pin
+ * @udc: udc device
+ * @on: 0 if disconnect pullup resistor, 1 otherwise
+ * Context: any
+ *
+ * Handle D+ pullup resistor, make the device visible to the usb bus, and
+ * declare it as a full speed usb device
+ */
+static void dplus_pullup(struct pxa_udc *udc, int on)
+{
+        if (on) {
+                if (gpio_is_valid(udc->mach->gpio_pullup))
+                        gpio_set_value(udc->mach->gpio_pullup,
+                                       !udc->mach->gpio_pullup_inverted);
+                if (udc->mach->udc_command)
+                        udc->mach->udc_command(PXA2XX_UDC_CMD_CONNECT);
+        } else {
+                if (gpio_is_valid(udc->mach->gpio_pullup))
+                        gpio_set_value(udc->mach->gpio_pullup,
+                                       udc->mach->gpio_pullup_inverted);
+                if (udc->mach->udc_command)
+                        udc->mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
+        }
+        udc->pullup_on = on;
+}
 /**
 * pxa_udc_get_frame - Returns usb frame number
@@ -1500,21 +1521,145 @@ static int pxa_udc_wakeup(struct usb_gadget *_gadget)
        return 0;
 }
+static void udc_enable(struct pxa_udc *udc);
+static void udc_disable(struct pxa_udc *udc);
+/**
+ * should_enable_udc - Tells if UDC should be enabled
+ * @udc: udc device
+ * Context: any
+ *
+ * The UDC should be enabled if :
+ *  - the pullup resistor is connected
+ *  - and a gadget driver is bound
+ *  - and vbus is sensed (or no vbus sense is available)
+ *
+ * Returns 1 if UDC should be enabled, 0 otherwise
+ */
+static int should_enable_udc(struct pxa_udc *udc)
+{
+        int put_on;
+        put_on = ((udc->pullup_on) && (udc->driver));
+        put_on &= ((udc->vbus_sensed) || (!udc->transceiver));
+        return put_on;
+}
+/**
+ * should_disable_udc - Tells if UDC should be disabled
+ * @udc: udc device
+ * Context: any
+ *
+ * The UDC should be disabled if :
+ *  - the pullup resistor is not connected
+ *  - or no gadget driver is bound
+ *  - or no vbus is sensed (when vbus sesing is available)
+ *
+ * Returns 1 if UDC should be disabled
+ */
+static int should_disable_udc(struct pxa_udc *udc)
+{
+        int put_off;
+        put_off = ((!udc->pullup_on) || (!udc->driver));
+        put_off |= ((!udc->vbus_sensed) && (udc->transceiver));
+        return put_off;
+}
+/**
+ * pxa_udc_pullup - Offer manual D+ pullup control
+ * @_gadget: usb gadget using the control
+ * @is_active: 0 if disconnect, else connect D+ pullup resistor
+ * Context: !in_interrupt()
+ *
+ * Returns 0 if OK, -EOPNOTSUPP if udc driver doesn't handle D+ pullup
+ */
+static int pxa_udc_pullup(struct usb_gadget *_gadget, int is_active)
+{
+        struct pxa_udc *udc = to_gadget_udc(_gadget);
+        if (!gpio_is_valid(udc->mach->gpio_pullup) && !udc->mach->udc_command)
+                return -EOPNOTSUPP;
+        dplus_pullup(udc, is_active);
+        if (should_enable_udc(udc))
+                udc_enable(udc);
+        if (should_disable_udc(udc))
+                udc_disable(udc);
+        return 0;
+}
+static void udc_enable(struct pxa_udc *udc);
+static void udc_disable(struct pxa_udc *udc);
+/**
+ * pxa_udc_vbus_session - Called by external transceiver to enable/disable udc
+ * @_gadget: usb gadget
+ * @is_active: 0 if should disable the udc, 1 if should enable
+ *
+ * Enables the udc, and optionnaly activates D+ pullup resistor. Or disables the
+ * udc, and deactivates D+ pullup resistor.
+ *
+ * Returns 0
+ */
+static int pxa_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
+{
+        struct pxa_udc *udc = to_gadget_udc(_gadget);
+        udc->vbus_sensed = is_active;
+        if (should_enable_udc(udc))
+                udc_enable(udc);
+        if (should_disable_udc(udc))
+                udc_disable(udc);
+        return 0;
+}
+/**
+ * pxa_udc_vbus_draw - Called by gadget driver after SET_CONFIGURATION completed
+ * @_gadget: usb gadget
+ * @mA: current drawn
+ *
+ * Context: !in_interrupt()
+ *
+ * Called after a configuration was chosen by a USB host, to inform how much
+ * current can be drawn by the device from VBus line.
+ *
+ * Returns 0 or -EOPNOTSUPP if no transceiver is handling the udc
+ */
+static int pxa_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
+{
+        struct pxa_udc *udc;
+        udc = to_gadget_udc(_gadget);
+        if (udc->transceiver)
+                return otg_set_power(udc->transceiver, mA);
+        return -EOPNOTSUPP;
+}
 static const struct usb_gadget_ops pxa_udc_ops = {
        .get_frame      = pxa_udc_get_frame,
        .wakeup         = pxa_udc_wakeup,
-        /* current versions must always be self-powered */
+        .pullup         = pxa_udc_pullup,
+        .vbus_session   = pxa_udc_vbus_session,
+        .vbus_draw      = pxa_udc_vbus_draw,
 };
 /**
 * udc_disable - disable udc device controller
 * @udc: udc device
+ * Context: any
 *
 * Disables the udc device : disables clocks, udc interrupts, control endpoint
 * interrupts.
 */
 static void udc_disable(struct pxa_udc *udc)
 {
+        if (!udc->enabled)
+                return;
        udc_writel(udc, UDCICR0, 0);
        udc_writel(udc, UDCICR1, 0);
@@ -1523,8 +1668,8 @@ static void udc_disable(struct pxa_udc *udc)
        ep0_idle(udc);
        udc->gadget.speed = USB_SPEED_UNKNOWN;
-        if (udc->mach->udc_command)
-                udc->mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
+        udc->enabled = 0;
 }
 /**
@@ -1555,10 +1700,9 @@ static __init void udc_init_data(struct pxa_udc *dev)
        }
        /* USB endpoints init */
-        for (i = 0; i < NR_USB_ENDPOINTS; i++)
+        for (i = 1; i < NR_USB_ENDPOINTS; i++)
-                if (i != 0)
+                list_add_tail(&dev->udc_usb_ep[i].usb_ep.ep_list,
-                        list_add_tail(&dev->udc_usb_ep[i].usb_ep.ep_list,
+                                &dev->gadget.ep_list);
-                                        &dev->gadget.ep_list);
 }
 /**
@@ -1570,6 +1714,9 @@ static __init void udc_init_data(struct pxa_udc *dev)
 */
 static void udc_enable(struct pxa_udc *udc)
 {
+        if (udc->enabled)
+                return;
        udc_writel(udc, UDCICR0, 0);
        udc_writel(udc, UDCICR1, 0);
        udc_clear_mask_UDCCR(udc, UDCCR_UDE);
@@ -1598,9 +1745,7 @@ static void udc_enable(struct pxa_udc *udc)
        /* enable ep0 irqs */
        pio_irq_enable(&udc->pxa_ep[0]);
-        dev_info(udc->dev, "UDC connecting\n");
+        udc->enabled = 1;
-        if (udc->mach->udc_command)
-                udc->mach->udc_command(PXA2XX_UDC_CMD_CONNECT);
 }
 /**
@@ -1612,6 +1757,9 @@ static void udc_enable(struct pxa_udc *udc)
 * usb traffic follows until a disconnect is reported.  Then a host may connect
 * again, or the driver might get unbound.
 *
+ * Note that the udc is not automatically enabled. Check function
+ * should_enable_udc().
+ *
 * Returns 0 if no error, -EINVAL, -ENODEV, -EBUSY otherwise
 */
 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
@@ -1630,6 +1778,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
        /* first hook up the driver ... */
        udc->driver = driver;
        udc->gadget.dev.driver = &driver->driver;
+        dplus_pullup(udc, 1);
        retval = device_add(&udc->gadget.dev);
        if (retval) {
@@ -1645,9 +1794,21 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
        dev_dbg(udc->dev, "registered gadget driver '%s'\n",
                driver->driver.name);
-        udc_enable(udc);
+        if (udc->transceiver) {
+                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                if (retval) {
+                        dev_err(udc->dev, "can't bind to transceiver\n");
+                        goto transceiver_fail;
+                }
+        }
+        if (should_enable_udc(udc))
+                udc_enable(udc);
        return 0;
+transceiver_fail:
+        if (driver->unbind)
+                driver->unbind(&udc->gadget);
 bind_fail:
        device_del(&udc->gadget.dev);
 add_fail:
@@ -1699,14 +1860,17 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
        stop_activity(udc, driver);
        udc_disable(udc);
+        dplus_pullup(udc, 0);
        driver->unbind(&udc->gadget);
        udc->driver = NULL;
        device_del(&udc->gadget.dev);
        dev_info(udc->dev, "unregistered gadget driver '%s'\n",
                 driver->driver.name);
+        if (udc->transceiver)
+                return otg_set_peripheral(udc->transceiver, NULL);
        return 0;
 }
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
@@ -1823,14 +1987,14 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq)
        struct pxa27x_request   *req = NULL;
        int                     completed = 0;
+        if (!list_empty(&ep->queue))
+                req = list_entry(ep->queue.next, struct pxa27x_request, queue);
        udccsr0 = udc_ep_readl(ep, UDCCSR);
        ep_dbg(ep, "state=%s, req=%p, udccsr0=0x%03x, udcbcr=%d, irq_msk=%x\n",
                EP0_STNAME(udc), req, udccsr0, udc_ep_readl(ep, UDCBCR),
                (fifo_irq << 1 | opc_irq));
-        if (!list_empty(&ep->queue))
-                req = list_entry(ep->queue.next, struct pxa27x_request, queue);
        if (udccsr0 & UDCCSR0_SST) {
                ep_dbg(ep, "clearing stall status\n");
                nuke(ep, -EPIPE);
@@ -2212,7 +2376,7 @@ static int __init pxa_udc_probe(struct platform_device *pdev)
 {
        struct resource *regs;
        struct pxa_udc *udc = &memory;
-        int retval;
+        int retval = 0, gpio;
        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!regs)
@@ -2223,6 +2387,20 @@ static int __init pxa_udc_probe(struct platform_device *pdev)
        udc->dev = &pdev->dev;
        udc->mach = pdev->dev.platform_data;
+        udc->transceiver = otg_get_transceiver();
+        gpio = udc->mach->gpio_pullup;
+        if (gpio_is_valid(gpio)) {
+                retval = gpio_request(gpio, "USB D+ pullup");
+                if (retval == 0)
+                        gpio_direction_output(gpio,
+                                       udc->mach->gpio_pullup_inverted);
+        }
+        if (retval) {
+                dev_err(&pdev->dev, "Couldn't request gpio %d : %d\n",
+                        gpio, retval);
+                return retval;
+        }
        udc->clk = clk_get(&pdev->dev, NULL);
        if (IS_ERR(udc->clk)) {
@@ -2240,6 +2418,7 @@ static int __init pxa_udc_probe(struct platform_device *pdev)
        device_initialize(&udc->gadget.dev);
        udc->gadget.dev.parent = &pdev->dev;
        udc->gadget.dev.dma_mask = NULL;
+        udc->vbus_sensed = 0;
        the_controller = udc;
        platform_set_drvdata(pdev, udc);
@@ -2273,14 +2452,21 @@ err_clk:
 static int __exit pxa_udc_remove(struct platform_device *_dev)
 {
        struct pxa_udc *udc = platform_get_drvdata(_dev);
+        int gpio = udc->mach->gpio_pullup;
        usb_gadget_unregister_driver(udc->driver);
        free_irq(udc->irq, udc);
        pxa_cleanup_debugfs(udc);
+        if (gpio_is_valid(gpio))
+                gpio_free(gpio);
+        otg_put_transceiver(udc->transceiver);
+        udc->transceiver = NULL;
        platform_set_drvdata(_dev, NULL);
        the_controller = NULL;
        clk_put(udc->clk);
+        iounmap(udc->regs);
        return 0;
 }
@@ -2319,6 +2505,8 @@ static int pxa_udc_suspend(struct platform_device *_dev, pm_message_t state)
        }
        udc_disable(udc);
+        udc->pullup_resume = udc->pullup_on;
+        dplus_pullup(udc, 0);
        return 0;
 }
@@ -2346,7 +2534,9 @@ static int pxa_udc_resume(struct platform_device *_dev)
                                ep->udccsr_value, ep->udccr_value);
        }
-        udc_enable(udc);
+        dplus_pullup(udc, udc->pullup_resume);
+        if (should_enable_udc(udc))
+                udc_enable(udc);
        /*
         * We do not handle OTG yet.
         *
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
index 1d1b7936ee11..db58125331da 100644
--- a/drivers/usb/gadget/pxa27x_udc.h
+++ b/drivers/usb/gadget/pxa27x_udc.h
@@ -26,6 +26,7 @@
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <linux/io.h>
+#include <linux/usb/otg.h>
 /*
 * Register definitions
@@ -421,10 +422,14 @@ struct udc_stats {
 * @driver: bound gadget (zero, g_ether, g_file_storage, ...)
 * @dev: device
 * @mach: machine info, used to activate specific GPIO
+ * @transceiver: external transceiver to handle vbus sense and D+ pullup
 * @ep0state: control endpoint state machine state
 * @stats: statistics on udc usage
 * @udc_usb_ep: array of usb endpoints offered by the gadget
 * @pxa_ep: array of pxa available endpoints
+ * @enabled: UDC was enabled by a previous udc_enable()
+ * @pullup_on: if pullup resistor connected to D+ pin
+ * @pullup_resume: if pullup resistor should be connected to D+ pin on resume
 * @config: UDC active configuration
 * @last_interface: UDC interface of the last SET_INTERFACE host request
 * @last_alternate: UDC altsetting of the last SET_INTERFACE host request
@@ -443,6 +448,7 @@ struct pxa_udc {
        struct usb_gadget_driver                *driver;
        struct device                           *dev;
        struct pxa2xx_udc_mach_info             *mach;
+        struct otg_transceiver                  *transceiver;
        enum ep0_state                          ep0state;
        struct udc_stats                        stats;
@@ -450,6 +456,10 @@ struct pxa_udc {
        struct udc_usb_ep                       udc_usb_ep[NR_USB_ENDPOINTS];
        struct pxa_ep                           pxa_ep[NR_PXA_ENDPOINTS];
+        unsigned                                enabled:1;
+        unsigned                                pullup_on:1;
+        unsigned                                pullup_resume:1;
+        unsigned                                vbus_sensed:1;
        unsigned                                config:2;
        unsigned                                last_interface:3;
        unsigned                                last_alternate:3;
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 37879af1c433..f46a60962dab 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -87,12 +87,12 @@ static struct usb_gadget_strings *dev_strings[] = {
 static struct usb_device_descriptor device_desc = {
        .bLength =              USB_DT_DEVICE_SIZE,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        /* .bDeviceClass = f(use_acm) */
        .bDeviceSubClass =      0,
        .bDeviceProtocol =      0,
        /* .bMaxPacketSize0 = f(hardware) */
-        .idVendor =             __constant_cpu_to_le16(GS_VENDOR_ID),
+        .idVendor =             cpu_to_le16(GS_VENDOR_ID),
        /* .idProduct = f(use_acm) */
        /* .bcdDevice = f(hardware) */
        /* .iManufacturer = DYNAMIC */
@@ -216,7 +216,7 @@ static int __init gs_bind(struct usb_composite_dev *cdev)
                pr_warning("gs_bind: controller '%s' not recognized\n",
                        gadget->name);
                device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM | 0x0099);
+                        cpu_to_le16(GS_VERSION_NUM | 0x0099);
        }
        if (gadget_is_otg(cdev->gadget)) {
@@ -255,19 +255,19 @@ static int __init init(void)
                serial_config_driver.bConfigurationValue = 2;
                device_desc.bDeviceClass = USB_CLASS_COMM;
                device_desc.idProduct =
-                                __constant_cpu_to_le16(GS_CDC_PRODUCT_ID);
+                                cpu_to_le16(GS_CDC_PRODUCT_ID);
        } else if (use_obex) {
                serial_config_driver.label = "CDC OBEX config";
                serial_config_driver.bConfigurationValue = 3;
                device_desc.bDeviceClass = USB_CLASS_COMM;
                device_desc.idProduct =
-                        __constant_cpu_to_le16(GS_CDC_OBEX_PRODUCT_ID);
+                        cpu_to_le16(GS_CDC_OBEX_PRODUCT_ID);
        } else {
                serial_config_driver.label = "Generic Serial config";
                serial_config_driver.bConfigurationValue = 1;
                device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
                device_desc.idProduct =
-                                __constant_cpu_to_le16(GS_PRODUCT_ID);
+                                cpu_to_le16(GS_PRODUCT_ID);
        }
        strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index 53d59287f2bc..0a4d99ab40d8 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -1092,7 +1092,7 @@ int __init gserial_setup(struct usb_gadget *g, unsigned count)
        gs_tty_driver->init_termios.c_ispeed = 9600;
        gs_tty_driver->init_termios.c_ospeed = 9600;
-        coding.dwDTERate = __constant_cpu_to_le32(9600);
+        coding.dwDTERate = cpu_to_le32(9600);
        coding.bCharFormat = 8;
        coding.bParityType = USB_CDC_NO_PARITY;
        coding.bDataBits = USB_CDC_1_STOP_BITS;
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 361d9659ac48..2d772401b7ad 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -102,22 +102,32 @@ module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
 #ifndef CONFIG_USB_ZERO_HNPTEST
 #define DRIVER_VENDOR_NUM       0x0525          /* NetChip */
 #define DRIVER_PRODUCT_NUM      0xa4a0          /* Linux-USB "Gadget Zero" */
+#define DEFAULT_AUTORESUME      0
 #else
 #define DRIVER_VENDOR_NUM       0x1a0a          /* OTG test device IDs */
 #define DRIVER_PRODUCT_NUM      0xbadd
+#define DEFAULT_AUTORESUME      5
 #endif
+/* If the optional "autoresume" mode is enabled, it provides good
+ * functional coverage for the "USBCV" test harness from USB-IF.
+ * It's always set if OTG mode is enabled.
+ */
+unsigned autoresume = DEFAULT_AUTORESUME;
+module_param(autoresume, uint, S_IRUGO);
+MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
 /*-------------------------------------------------------------------------*/
 static struct usb_device_descriptor device_desc = {
        .bLength =              sizeof device_desc,
        .bDescriptorType =      USB_DT_DEVICE,
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        .bcdUSB =               cpu_to_le16(0x0200),
        .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
-        .idVendor =             __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
+        .idVendor =             cpu_to_le16(DRIVER_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
+        .idProduct =            cpu_to_le16(DRIVER_PRODUCT_NUM),
        .bNumConfigurations =   2,
 };
@@ -212,6 +222,47 @@ void disable_endpoints(struct usb_composite_dev *cdev,
 /*-------------------------------------------------------------------------*/
+static struct timer_list        autoresume_timer;
+static void zero_autoresume(unsigned long _c)
+{
+        struct usb_composite_dev        *cdev = (void *)_c;
+        struct usb_gadget               *g = cdev->gadget;
+        /* unconfigured devices can't issue wakeups */
+        if (!cdev->config)
+                return;
+        /* Normally the host would be woken up for something
+         * more significant than just a timer firing; likely
+         * because of some direct user request.
+         */
+        if (g->speed != USB_SPEED_UNKNOWN) {
+                int status = usb_gadget_wakeup(g);
+                INFO(cdev, "%s --> %d\n", __func__, status);
+        }
+}
+static void zero_suspend(struct usb_composite_dev *cdev)
+{
+        if (cdev->gadget->speed == USB_SPEED_UNKNOWN)
+                return;
+        if (autoresume) {
+                mod_timer(&autoresume_timer, jiffies + (HZ * autoresume));
+                DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
+        } else
+                DBG(cdev, "%s\n", __func__);
+}
+static void zero_resume(struct usb_composite_dev *cdev)
+{
+        DBG(cdev, "%s\n", __func__);
+        del_timer(&autoresume_timer);
+}
+/*-------------------------------------------------------------------------*/
 static int __init zero_bind(struct usb_composite_dev *cdev)
 {
        int                     gcnum;
@@ -239,17 +290,19 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
        strings_dev[STRING_SERIAL_IDX].id = id;
        device_desc.iSerialNumber = id;
+        setup_timer(&autoresume_timer, zero_autoresume, (unsigned long) cdev);
        /* Register primary, then secondary configuration.  Note that
         * SH3 only allows one config...
         */
        if (loopdefault) {
-                loopback_add(cdev);
+                loopback_add(cdev, autoresume != 0);
                if (!gadget_is_sh(gadget))
-                        sourcesink_add(cdev);
+                        sourcesink_add(cdev, autoresume != 0);
        } else {
-                sourcesink_add(cdev);
+                sourcesink_add(cdev, autoresume != 0);
                if (!gadget_is_sh(gadget))
-                        loopback_add(cdev);
+                        loopback_add(cdev, autoresume != 0);
        }
        gcnum = usb_gadget_controller_number(gadget);
@@ -265,7 +318,7 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
                 */
                pr_warning("%s: controller '%s' not recognized\n",
                        longname, gadget->name);
-                device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
+                device_desc.bcdDevice = cpu_to_le16(0x9999);
        }
@@ -278,11 +331,20 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
        return 0;
 }
+static int zero_unbind(struct usb_composite_dev *cdev)
+{
+        del_timer_sync(&autoresume_timer);
+        return 0;
+}
 static struct usb_composite_driver zero_driver = {
        .name           = "zero",
        .dev            = &device_desc,
        .strings        = dev_strings,
        .bind           = zero_bind,
+        .unbind         = zero_unbind,
+        .suspend        = zero_suspend,
+        .resume         = zero_resume,
 };
 MODULE_AUTHOR("David Brownell");
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 2c63bfb1f8d9..845479f7c707 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -24,10 +24,7 @@ config USB_EHCI_HCD
          The Enhanced Host Controller Interface (EHCI) is standard for USB 2.0
          "high speed" (480 Mbit/sec, 60 Mbyte/sec) host controller hardware.
          If your USB host controller supports USB 2.0, you will likely want to
-          configure this Host Controller Driver.  At the time of this writing, 
+          configure this Host Controller Driver.
-          the primary implementation of EHCI is a chip from NEC, widely available
-          in add-on PCI cards, but implementations are in the works from other 
-          vendors including Intel and Philips.  Motherboard support is appearing.
          EHCI controllers are packaged with "companion" host controllers (OHCI
          or UHCI) to handle USB 1.1 devices connected to root hub ports.  Ports
@@ -123,7 +120,7 @@ config USB_ISP116X_HCD
 config USB_ISP1760_HCD
        tristate "ISP 1760 HCD support"
-        depends on USB && EXPERIMENTAL && (PCI || PPC_OF)
+        depends on USB && EXPERIMENTAL
        ---help---
          The ISP1760 chip is a USB 2.0 host controller.
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index e551bb38852b..f2618d17710d 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -110,6 +110,42 @@ MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
 /*-------------------------------------------------------------------------*/
+static void
+timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
+{
+        /* Don't override timeouts which shrink or (later) disable
+         * the async ring; just the I/O watchdog.  Note that if a
+         * SHRINK were pending, OFF would never be requested.
+         */
+        if (timer_pending(&ehci->watchdog)
+                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                                & ehci->actions))
+                return;
+        if (!test_and_set_bit(action, &ehci->actions)) {
+                unsigned long t;
+                switch (action) {
+                case TIMER_IO_WATCHDOG:
+                        t = EHCI_IO_JIFFIES;
+                        break;
+                case TIMER_ASYNC_OFF:
+                        t = EHCI_ASYNC_JIFFIES;
+                        break;
+                /* case TIMER_ASYNC_SHRINK: */
+                default:
+                        /* add a jiffie since we synch against the
+                         * 8 KHz uframe counter.
+                         */
+                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
+                        break;
+                }
+                mod_timer(&ehci->watchdog, t + jiffies);
+        }
+}
+/*-------------------------------------------------------------------------*/
 /*
 * handshake - spin reading hc until handshake completes or fails
 * @ptr: address of hc register to be read
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index ecc9b66c03cd..1976b1b3778c 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -333,12 +333,40 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                token = hc32_to_cpu(ehci, qtd->hw_token);
                /* always clean up qtds the hc de-activated */
+ retry_xacterr:
                if ((token & QTD_STS_ACTIVE) == 0) {
                        /* on STALL, error, and short reads this urb must
                         * complete and all its qtds must be recycled.
                         */
                        if ((token & QTD_STS_HALT) != 0) {
+                                /* retry transaction errors until we
+                                 * reach the software xacterr limit
+                                 */
+                                if ((token & QTD_STS_XACT) &&
+                                                QTD_CERR(token) == 0 &&
+                                                --qh->xacterrs > 0 &&
+                                                !urb->unlinked) {
+                                        ehci_dbg(ehci,
+        "detected XactErr len %zu/%zu retry %d\n",
+        qtd->length - QTD_LENGTH(token), qtd->length,
+        QH_XACTERR_MAX - qh->xacterrs);
+                                        /* reset the token in the qtd and the
+                                         * qh overlay (which still contains
+                                         * the qtd) so that we pick up from
+                                         * where we left off
+                                         */
+                                        token &= ~QTD_STS_HALT;
+                                        token |= QTD_STS_ACTIVE |
+                                                        (EHCI_TUNE_CERR << 10);
+                                        qtd->hw_token = cpu_to_hc32(ehci,
+                                                        token);
+                                        wmb();
+                                        qh->hw_token = cpu_to_hc32(ehci, token);
+                                        goto retry_xacterr;
+                                }
                                stopped = 1;
                        /* magic dummy for some short reads; qh won't advance.
@@ -421,6 +449,9 @@ halt:
                /* remove qtd; it's recycled after possible urb completion */
                list_del (&qtd->qtd_list);
                last = qtd;
+                /* reinit the xacterr counter for the next qtd */
+                qh->xacterrs = QH_XACTERR_MAX;
        }
        /* last urb's completion might still need calling */
@@ -862,6 +893,7 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
        head->qh_next.qh = qh;
        head->hw_next = dma;
+        qh->xacterrs = QH_XACTERR_MAX;
        qh->qh_state = QH_STATE_LINKED;
        /* qtd completions reported later by interrupt */
 }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 1d0b49e3f192..ada5d2ba297b 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -563,7 +563,7 @@ static int qh_unlink_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
        //   and this qh is active in the current uframe
        //   (and overlay token SplitXstate is false?)
        // THEN
-        //   qh->hw_info1 |= __constant_cpu_to_hc32(1 << 7 /* "ignore" */);
+        //   qh->hw_info1 |= cpu_to_hc32(1 << 7 /* "ignore" */);
        /* high bandwidth, or otherwise part of every microframe */
        if ((period = qh->period) == 0)
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 262b00c9b334..6cff195e1a36 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -190,40 +190,6 @@ timer_action_done (struct ehci_hcd *ehci, enum ehci_timer_action action)
        clear_bit (action, &ehci->actions);
 }
-static inline void
-timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
-{
-        /* Don't override timeouts which shrink or (later) disable
-         * the async ring; just the I/O watchdog.  Note that if a
-         * SHRINK were pending, OFF would never be requested.
-         */
-        if (timer_pending(&ehci->watchdog)
-                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
-                                & ehci->actions))
-                return;
-        if (!test_and_set_bit (action, &ehci->actions)) {
-                unsigned long t;
-                switch (action) {
-                case TIMER_IO_WATCHDOG:
-                        t = EHCI_IO_JIFFIES;
-                        break;
-                case TIMER_ASYNC_OFF:
-                        t = EHCI_ASYNC_JIFFIES;
-                        break;
-                // case TIMER_ASYNC_SHRINK:
-                default:
-                        /* add a jiffie since we synch against the
-                         * 8 KHz uframe counter.
-                         */
-                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
-                        break;
-                }
-                mod_timer(&ehci->watchdog, t + jiffies);
-        }
-}
 static void free_cached_itd_list(struct ehci_hcd *ehci);
 /*-------------------------------------------------------------------------*/
@@ -287,7 +253,7 @@ struct ehci_qtd {
 /*
 * Now the following defines are not converted using the
- * __constant_cpu_to_le32() macro anymore, since we have to support
+ * cpu_to_le32() macro anymore, since we have to support
 * "dynamic" switching between be and le support, so that the driver
 * can be used on one system with SoC EHCI controller using big-endian
 * descriptors as well as a normal little-endian PCI EHCI controller.
@@ -376,6 +342,9 @@ struct ehci_qh {
 #define QH_STATE_UNLINK_WAIT    4               /* LINKED and on reclaim q */
 #define QH_STATE_COMPLETING     5               /* don't touch token.HALT */
+        u8                      xacterrs;       /* XactErr retry counter */
+#define QH_XACTERR_MAX          32              /* XactErr retry limit */
        /* periodic schedule info */
        u8                      usecs;          /* intr bandwidth */
        u8                      gap_uf;         /* uframes split/csplit gap */
diff --git a/drivers/usb/host/fhci-dbg.c b/drivers/usb/host/fhci-dbg.c
index 34e14edf390b..ea8a4255c5da 100644
--- a/drivers/usb/host/fhci-dbg.c
+++ b/drivers/usb/host/fhci-dbg.c
@@ -108,7 +108,7 @@ void fhci_dfs_create(struct fhci_hcd *fhci)
 {
        struct device *dev = fhci_to_hcd(fhci)->self.controller;
-        fhci->dfs_root = debugfs_create_dir(dev->bus_id, NULL);
+        fhci->dfs_root = debugfs_create_dir(dev_name(dev), NULL);
        if (!fhci->dfs_root) {
                WARN_ON(1);
                return;
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index ba622cc8a9ba..0951818ef93b 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -583,7 +583,7 @@ static int __devinit of_fhci_probe(struct of_device *ofdev,
        if (sprop && strcmp(sprop, "host"))
                return -ENODEV;
-        hcd = usb_create_hcd(&fhci_driver, dev, dev->bus_id);
+        hcd = usb_create_hcd(&fhci_driver, dev, dev_name(dev));
        if (!hcd) {
                dev_err(dev, "could not create hcd\n");
                return -ENOMEM;
@@ -650,7 +650,7 @@ static int __devinit of_fhci_probe(struct of_device *ofdev,
                        }
                }
-                ret = gpio_request(gpio, dev->bus_id);
+                ret = gpio_request(gpio, dev_name(dev));
                if (ret) {
                        dev_err(dev, "failed to request gpio %d", i);
                        goto err_gpios;
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index 8582236e4cad..cbf30e515f29 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -464,8 +464,7 @@ static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
                        port_idx << 8 | iface_no,
                        keyd, keyd_len, 1000 /* FIXME: arbitrary */);
-        memset(keyd, 0, sizeof(*keyd)); /* clear keys etc. */
+        kzfree(keyd); /* clear keys etc. */
-        kfree(keyd);
        return result;
 }
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 4dda31b26892..a2b305477afe 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -772,7 +772,7 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
                break;
        case PIPE_INTERRUPT:
                urb->interval = ep->period;
-                ep->length = min((int)ep->maxpacket,
+                ep->length = min_t(u32, ep->maxpacket,
                                 urb->transfer_buffer_length);
                /* urb submitted for already existing endpoint */
diff --git a/drivers/usb/host/isp116x.h b/drivers/usb/host/isp116x.h
index aa211bafcff9..12db961acdfb 100644
--- a/drivers/usb/host/isp116x.h
+++ b/drivers/usb/host/isp116x.h
@@ -563,7 +563,7 @@ static void urb_dbg(struct urb *urb, char *msg)
 */
 static inline void dump_ptd(struct ptd *ptd)
 {
-        printk("td: %x %d%c%d %d,%d,%d  %x %x%x%x\n",
+        printk(KERN_WARNING "td: %x %d%c%d %d,%d,%d  %x %x%x%x\n",
               PTD_GET_CC(ptd), PTD_GET_FA(ptd),
               PTD_DIR_STR(ptd), PTD_GET_EP(ptd),
               PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
@@ -576,7 +576,7 @@ static inline void dump_ptd_out_data(struct ptd *ptd, u8 * buf)
        int k;
        if (PTD_GET_DIR(ptd) != PTD_DIR_IN && PTD_GET_LEN(ptd)) {
-                printk("-> ");
+                printk(KERN_WARNING "-> ");
                for (k = 0; k < PTD_GET_LEN(ptd); ++k)
                        printk("%02x ", ((u8 *) buf)[k]);
                printk("\n");
@@ -588,13 +588,13 @@ static inline void dump_ptd_in_data(struct ptd *ptd, u8 * buf)
        int k;
        if (PTD_GET_DIR(ptd) == PTD_DIR_IN && PTD_GET_COUNT(ptd)) {
-                printk("<- ");
+                printk(KERN_WARNING "<- ");
                for (k = 0; k < PTD_GET_COUNT(ptd); ++k)
                        printk("%02x ", ((u8 *) buf)[k]);
                printk("\n");
        }
        if (PTD_GET_LAST(ptd))
-                printk("-\n");
+                printk(KERN_WARNING "-\n");
 }
 #else
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index b899f1a59c26..cd07ea3f0c63 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -644,7 +644,7 @@ static void transform_add_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
        if (urb->dev->speed != USB_SPEED_HIGH) {
                /* split */
-                ptd->dw5 = __constant_cpu_to_le32(0x1c);
+                ptd->dw5 = cpu_to_le32(0x1c);
                if (qh->period >= 32)
                        period = qh->period / 2;
@@ -819,6 +819,13 @@ static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
        u32 atl_regs, payload;
        u32 buffstatus;
+        /*
+         * When this function is called from the interrupt handler to enqueue
+         * a follow-up packet, the SKIP register gets written and read back
+         * almost immediately. With ISP1761, this register requires a delay of
+         * 195ns between a write and subsequent read (see section 15.1.1.3).
+         */
+        ndelay(195);
        skip_map = isp1760_readl(hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
        BUG_ON(!skip_map);
@@ -853,6 +860,13 @@ static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
        u32 int_regs, payload;
        u32 buffstatus;
+        /*
+         * When this function is called from the interrupt handler to enqueue
+         * a follow-up packet, the SKIP register gets written and read back
+         * almost immediately. With ISP1761, this register requires a delay of
+         * 195ns between a write and subsequent read (see section 15.1.1.3).
+         */
+        ndelay(195);
        skip_map = isp1760_readl(hcd->regs + HC_INT_PTD_SKIPMAP_REG);
        BUG_ON(!skip_map);
@@ -1054,7 +1068,7 @@ static void do_atl_int(struct usb_hcd *usb_hcd)
                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
                                        atl_regs, sizeof(ptd));
-                        ptd.dw0 |= __constant_cpu_to_le32(PTD_VALID);
+                        ptd.dw0 |= cpu_to_le32(PTD_VALID);
                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
                                        atl_regs, sizeof(ptd));
@@ -2235,9 +2249,10 @@ void deinit_kmem_cache(void)
        kmem_cache_destroy(qh_cachep);
 }
-struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
+struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
-                u64 irqflags, struct device *dev, const char *busname,
+                                 int irq, unsigned long irqflags,
-                unsigned int devflags)
+                                 struct device *dev, const char *busname,
+                                 unsigned int devflags)
 {
        struct usb_hcd *hcd;
        struct isp1760_hcd *priv;
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index a9daea587962..462f4943cb1b 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -2,9 +2,10 @@
 #define _ISP1760_HCD_H_
 /* exports for if */
-struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
+struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
-                u64 irqflags, struct device *dev, const char *busname,
+                                 int irq, unsigned long irqflags,
-                unsigned int devflags);
+                                 struct device *dev, const char *busname,
+                                 unsigned int devflags);
 int init_kmem_once(void);
 void deinit_kmem_cache(void);
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 4cf7ca428b33..3fa3a1702796 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -10,6 +10,7 @@
 #include <linux/usb.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
 #include "../core/hcd.h"
 #include "isp1760-hcd.h"
@@ -300,39 +301,101 @@ static struct pci_driver isp1761_pci_driver = {
 };
 #endif
+static int __devinit isp1760_plat_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct usb_hcd *hcd;
+        struct resource *mem_res;
+        struct resource *irq_res;
+        resource_size_t mem_size;
+        unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED;
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res) {
+                pr_warning("isp1760: Memory resource not available\n");
+                ret = -ENODEV;
+                goto out;
+        }
+        mem_size = resource_size(mem_res);
+        if (!request_mem_region(mem_res->start, mem_size, "isp1760")) {
+                pr_warning("isp1760: Cannot reserve the memory resource\n");
+                ret = -EBUSY;
+                goto out;
+        }
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq_res) {
+                pr_warning("isp1760: IRQ resource not available\n");
+                return -ENODEV;
+        }
+        irqflags |= irq_res->flags & IRQF_TRIGGER_MASK;
+        hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
+                               irqflags, &pdev->dev, dev_name(&pdev->dev), 0);
+        if (IS_ERR(hcd)) {
+                pr_warning("isp1760: Failed to register the HCD device\n");
+                ret = -ENODEV;
+                goto cleanup;
+        }
+        pr_info("ISP1760 USB device initialised\n");
+        return ret;
+cleanup:
+        release_mem_region(mem_res->start, mem_size);
+out:
+        return ret;
+}
+static int __devexit isp1760_plat_remove(struct platform_device *pdev)
+{
+        struct resource *mem_res;
+        resource_size_t mem_size;
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mem_size = resource_size(mem_res);
+        release_mem_region(mem_res->start, mem_size);
+        return 0;
+}
+static struct platform_driver isp1760_plat_driver = {
+        .probe  = isp1760_plat_probe,
+        .remove = isp1760_plat_remove,
+        .driver = {
+                .name   = "isp1760",
+        },
+};
 static int __init isp1760_init(void)
 {
-        int ret;
+        int ret, any_ret = -ENODEV;
        init_kmem_once();
+        ret = platform_driver_register(&isp1760_plat_driver);
+        if (!ret)
+                any_ret = 0;
 #ifdef CONFIG_PPC_OF
        ret = of_register_platform_driver(&isp1760_of_driver);
-        if (ret) {
+        if (!ret)
-                deinit_kmem_cache();
+                any_ret = 0;
-                return ret;
-        }
 #endif
 #ifdef CONFIG_PCI
        ret = pci_register_driver(&isp1761_pci_driver);
-        if (ret)
+        if (!ret)
-                goto unreg_of;
+                any_ret = 0;
 #endif
-        return ret;
-#ifdef CONFIG_PCI
+        if (any_ret)
-unreg_of:
+                deinit_kmem_cache();
-#endif
+        return any_ret;
-#ifdef CONFIG_PPC_OF
-        of_unregister_platform_driver(&isp1760_of_driver);
-#endif
-        deinit_kmem_cache();
-        return ret;
 }
 module_init(isp1760_init);
 static void __exit isp1760_exit(void)
 {
+        platform_driver_unregister(&isp1760_plat_driver);
 #ifdef CONFIG_PPC_OF
        of_unregister_platform_driver(&isp1760_of_driver);
 #endif
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 5cf5f1eca4f4..25db704f3a2a 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -997,7 +997,7 @@ MODULE_LICENSE ("GPL");
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
-#ifdef CONFIG_ARCH_S3C2410
+#if defined(CONFIG_ARCH_S3C2410) || defined(CONFIG_ARCH_S3C64XX)
 #include "ohci-s3c2410.c"
 #define PLATFORM_DRIVER         ohci_hcd_s3c2410_driver
 #endif
@@ -1049,7 +1049,8 @@ MODULE_LICENSE ("GPL");
 #if defined(CONFIG_CPU_SUBTYPE_SH7720) || \
    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7763)
+    defined(CONFIG_CPU_SUBTYPE_SH7763) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7786)
 #include "ohci-sh.c"
 #define PLATFORM_DRIVER         ohci_hcd_sh_driver
 #endif
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index f46af7a718d4..a68af2dd55ca 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -21,9 +21,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <plat/usb-control.h>
-#include <mach/hardware.h>
-#include <mach/usb-control.h>
 #define valid_port(idx) ((idx) == 1 || (idx) == 2)
@@ -372,7 +370,7 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
        usb_clk = clk_get(&dev->dev, "usb-bus-host");
        if (IS_ERR(usb_clk)) {
-                dev_err(&dev->dev, "cannot get usb-host clock\n");
+                dev_err(&dev->dev, "cannot get usb-bus-host clock\n");
                retval = -ENOENT;
                goto err_clk;
        }
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 75548f7c716b..5ac489ee3dab 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -845,14 +845,14 @@ static inline void qh_update(struct oxu_hcd *oxu,
                is_out = !(qtd->hw_token & cpu_to_le32(1 << 8));
                epnum = (le32_to_cpup(&qh->hw_info1) >> 8) & 0x0f;
                if (unlikely(!usb_gettoggle(qh->dev, epnum, is_out))) {
-                        qh->hw_token &= ~__constant_cpu_to_le32(QTD_TOGGLE);
+                        qh->hw_token &= ~cpu_to_le32(QTD_TOGGLE);
                        usb_settoggle(qh->dev, epnum, is_out, 1);
                }
        }
        /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
        wmb();
-        qh->hw_token &= __constant_cpu_to_le32(QTD_TOGGLE | QTD_STS_PING);
+        qh->hw_token &= cpu_to_le32(QTD_TOGGLE | QTD_STS_PING);
 }
 /* If it weren't for a common silicon quirk (writing the dummy into the qh
@@ -937,7 +937,7 @@ __acquires(oxu->lock)
                struct ehci_qh  *qh = (struct ehci_qh *) urb->hcpriv;
                /* S-mask in a QH means it's an interrupt urb */
-                if ((qh->hw_info2 & __constant_cpu_to_le32(QH_SMASK)) != 0) {
+                if ((qh->hw_info2 & cpu_to_le32(QH_SMASK)) != 0) {
                        /* ... update hc-wide periodic stats (for usbfs) */
                        oxu_to_hcd(oxu)->self.bandwidth_int_reqs--;
@@ -981,7 +981,7 @@ static void unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh);
 static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
 static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
-#define HALT_BIT __constant_cpu_to_le32(QTD_STS_HALT)
+#define HALT_BIT cpu_to_le32(QTD_STS_HALT)
 /* Process and free completed qtds for a qh, returning URBs to drivers.
 * Chases up to qh->hw_current.  Returns number of completions called,
@@ -1160,7 +1160,7 @@ halt:
                        /* should be rare for periodic transfers,
                         * except maybe high bandwidth ...
                         */
-                        if ((__constant_cpu_to_le32(QH_SMASK)
+                        if ((cpu_to_le32(QH_SMASK)
                                        & qh->hw_info2) != 0) {
                                intr_deschedule(oxu, qh);
                                (void) qh_schedule(oxu, qh);
@@ -1350,7 +1350,7 @@ static struct list_head *qh_urb_transaction(struct oxu_hcd *oxu,
        }
        /* by default, enable interrupt on urb completion */
-                qtd->hw_token |= __constant_cpu_to_le32(QTD_IOC);
+                qtd->hw_token |= cpu_to_le32(QTD_IOC);
        return head;
 cleanup:
@@ -1539,7 +1539,7 @@ static void qh_link_async(struct oxu_hcd *oxu, struct ehci_qh *qh)
        /* qtd completions reported later by interrupt */
 }
-#define QH_ADDR_MASK    __constant_cpu_to_le32(0x7f)
+#define QH_ADDR_MASK    cpu_to_le32(0x7f)
 /*
 * For control/bulk/interrupt, return QH with these TDs appended.
@@ -2012,7 +2012,7 @@ static void qh_unlink_periodic(struct oxu_hcd *oxu, struct ehci_qh *qh)
         *   and this qh is active in the current uframe
         *   (and overlay token SplitXstate is false?)
         * THEN
-         *   qh->hw_info1 |= __constant_cpu_to_le32(1 << 7 "ignore");
+         *   qh->hw_info1 |= cpu_to_le32(1 << 7 "ignore");
         */
        /* high bandwidth, or otherwise part of every microframe */
@@ -2057,7 +2057,7 @@ static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
         * active high speed queues may need bigger delays...
         */
        if (list_empty(&qh->qtd_list)
-                || (__constant_cpu_to_le32(QH_CMASK) & qh->hw_info2) != 0)
+                || (cpu_to_le32(QH_CMASK) & qh->hw_info2) != 0)
                wait = 2;
        else
                wait = 55;      /* worst case: 3 * 1024 */
@@ -2183,10 +2183,10 @@ static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
                qh->start = frame;
                /* reset S-frame and (maybe) C-frame masks */
-                qh->hw_info2 &= __constant_cpu_to_le32(~(QH_CMASK | QH_SMASK));
+                qh->hw_info2 &= cpu_to_le32(~(QH_CMASK | QH_SMASK));
                qh->hw_info2 |= qh->period
                        ? cpu_to_le32(1 << uframe)
-                        : __constant_cpu_to_le32(QH_SMASK);
+                        : cpu_to_le32(QH_SMASK);
                qh->hw_info2 |= c_mask;
        } else
                oxu_dbg(oxu, "reused qh %p schedule\n", qh);
@@ -2684,7 +2684,7 @@ static int oxu_reset(struct usb_hcd *hcd)
        oxu->urb_len = 0;
        /* FIMXE */
-        hcd->self.controller->dma_mask = 0UL;
+        hcd->self.controller->dma_mask = NULL;
        if (oxu->is_otg) {
                oxu->caps = hcd->regs + OXU_OTG_CAP_OFFSET;
diff --git a/drivers/usb/host/oxu210hp.h b/drivers/usb/host/oxu210hp.h
index 8910e271cc7d..1c216ad9aad2 100644
--- a/drivers/usb/host/oxu210hp.h
+++ b/drivers/usb/host/oxu210hp.h
@@ -235,21 +235,21 @@ struct ehci_qtd {
 } __attribute__ ((aligned(32)));
 /* mask NakCnt+T in qh->hw_alt_next */
-#define QTD_MASK __constant_cpu_to_le32 (~0x1f)
+#define QTD_MASK cpu_to_le32 (~0x1f)
 #define IS_SHORT_READ(token) (QTD_LENGTH(token) != 0 && QTD_PID(token) == 1)
 /* Type tag from {qh, itd, sitd, fstn}->hw_next */
-#define Q_NEXT_TYPE(dma) ((dma) & __constant_cpu_to_le32 (3 << 1))
+#define Q_NEXT_TYPE(dma) ((dma) & cpu_to_le32 (3 << 1))
 /* values for that type tag */
-#define Q_TYPE_QH       __constant_cpu_to_le32 (1 << 1)
+#define Q_TYPE_QH       cpu_to_le32 (1 << 1)
 /* next async queue entry, or pointer to interrupt/periodic QH */
 #define QH_NEXT(dma)    (cpu_to_le32(((u32)dma)&~0x01f)|Q_TYPE_QH)
 /* for periodic/async schedules and qtd lists, mark end of list */
-#define EHCI_LIST_END   __constant_cpu_to_le32(1) /* "null pointer" to hw */
+#define EHCI_LIST_END   cpu_to_le32(1) /* "null pointer" to hw */
 /*
 * Entries in periodic shadow table are pointers to one of four kinds
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 75b69847918e..033c2846ce59 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -234,7 +234,7 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
         */
        hcc_params = readl(base + EHCI_HCC_PARAMS);
        offset = (hcc_params >> 8) & 0xff;
-        while (offset && count--) {
+        while (offset && --count) {
                u32             cap;
                int             msec;
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 319041205b57..f1626e58c141 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -660,9 +660,9 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
        u16 array[R8A66597_MAX_NUM_PIPE], i = 0, min;
        memset(array, 0, sizeof(array));
-        switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(ep)) {
        case USB_ENDPOINT_XFER_BULK:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                if (usb_endpoint_dir_in(ep))
                        array[i++] = 4;
                else {
                        array[i++] = 3;
@@ -670,7 +670,7 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
                }
                break;
        case USB_ENDPOINT_XFER_INT:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
+                if (usb_endpoint_dir_in(ep)) {
                        array[i++] = 6;
                        array[i++] = 7;
                        array[i++] = 8;
@@ -678,7 +678,7 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
                        array[i++] = 9;
                break;
        case USB_ENDPOINT_XFER_ISOC:
-                if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                if (usb_endpoint_dir_in(ep))
                        array[i++] = 2;
                else
                        array[i++] = 1;
@@ -928,10 +928,9 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
        info.pipenum = get_empty_pipenum(r8a66597, ep);
        info.address = get_urb_to_r8a66597_addr(r8a66597, urb);
-        info.epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        info.epnum = usb_endpoint_num(ep);
        info.maxpacket = le16_to_cpu(ep->wMaxPacketSize);
-        info.type = get_r8a66597_type(ep->bmAttributes
+        info.type = get_r8a66597_type(usb_endpoint_type(ep));
-                                      & USB_ENDPOINT_XFERTYPE_MASK);
        info.bufnum = get_bufnum(info.pipenum);
        info.buf_bsize = get_buf_bsize(info.pipenum);
        if (info.type == R8A66597_BULK) {
@@ -941,7 +940,7 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
                info.interval = get_interval(urb, ep->bInterval);
                info.timer_interval = get_timer_interval(urb, ep->bInterval);
        }
-        if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+        if (usb_endpoint_dir_in(ep))
                info.dir_in = 1;
        else
                info.dir_in = 0;
@@ -1014,6 +1013,9 @@ static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
        r8a66597_write(r8a66597, ~DTCH, get_intsts_reg(port));
        r8a66597_bset(r8a66597, DTCHE, get_intenb_reg(port));
+        if (r8a66597->bus_suspended)
+                usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
 }
 /* this function must be called with interrupt disabled */
@@ -1395,7 +1397,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
                           (int)urb->iso_frame_desc[td->iso_cnt].length);
        } else {
                buf = (u16 *)(urb->transfer_buffer + urb->actual_length);
-                size = min((int)bufsize,
+                size = min_t(u32, bufsize,
                           urb->transfer_buffer_length - urb->actual_length);
        }
@@ -1615,6 +1617,11 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
                        r8a66597_bclr(r8a66597, DTCHE, INTENB2);
                        r8a66597_usb_disconnect(r8a66597, 1);
                }
+                if (mask2 & BCHG) {
+                        r8a66597_write(r8a66597, ~BCHG, INTSTS2);
+                        r8a66597_bclr(r8a66597, BCHGE, INTENB2);
+                        usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
+                }
        }
        if (mask1) {
@@ -1630,6 +1637,12 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
                        r8a66597_bclr(r8a66597, DTCHE, INTENB1);
                        r8a66597_usb_disconnect(r8a66597, 0);
                }
+                if (mask1 & BCHG) {
+                        r8a66597_write(r8a66597, ~BCHG, INTSTS1);
+                        r8a66597_bclr(r8a66597, BCHGE, INTENB1);
+                        usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
+                }
                if (mask1 & SIGN) {
                        r8a66597_write(r8a66597, ~SIGN, INTSTS1);
                        status = get_urb_error(r8a66597, 0);
@@ -2141,7 +2154,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                switch (wValue) {
                case USB_PORT_FEAT_ENABLE:
-                        rh->port &= (1 << USB_PORT_FEAT_POWER);
+                        rh->port &= ~(1 << USB_PORT_FEAT_POWER);
                        break;
                case USB_PORT_FEAT_SUSPEND:
                        break;
@@ -2213,6 +2226,68 @@ error:
        return ret;
 }
+#if defined(CONFIG_PM)
+static int r8a66597_bus_suspend(struct usb_hcd *hcd)
+{
+        struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
+        int port;
+        dbg("%s", __func__);
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+                unsigned long dvstctr_reg = get_dvstctr_reg(port);
+                if (!(rh->port & (1 << USB_PORT_FEAT_ENABLE)))
+                        continue;
+                dbg("suspend port = %d", port);
+                r8a66597_bclr(r8a66597, UACT, dvstctr_reg);     /* suspend */
+                rh->port |= 1 << USB_PORT_FEAT_SUSPEND;
+                if (rh->dev->udev->do_remote_wakeup) {
+                        msleep(3);      /* waiting last SOF */
+                        r8a66597_bset(r8a66597, RWUPE, dvstctr_reg);
+                        r8a66597_write(r8a66597, ~BCHG, get_intsts_reg(port));
+                        r8a66597_bset(r8a66597, BCHGE, get_intenb_reg(port));
+                }
+        }
+        r8a66597->bus_suspended = 1;
+        return 0;
+}
+static int r8a66597_bus_resume(struct usb_hcd *hcd)
+{
+        struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
+        int port;
+        dbg("%s", __func__);
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+                unsigned long dvstctr_reg = get_dvstctr_reg(port);
+                if (!(rh->port & (1 << USB_PORT_FEAT_SUSPEND)))
+                        continue;
+                dbg("resume port = %d", port);
+                rh->port &= ~(1 << USB_PORT_FEAT_SUSPEND);
+                rh->port |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
+                msleep(50);
+                r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
+        }
+        return 0;
+}
+#else
+#define r8a66597_bus_suspend    NULL
+#define r8a66597_bus_resume     NULL
+#endif
 static struct hc_driver r8a66597_hc_driver = {
        .description =          hcd_name,
        .hcd_priv_size =        sizeof(struct r8a66597),
@@ -2243,16 +2318,39 @@ static struct hc_driver r8a66597_hc_driver = {
         */
        .hub_status_data =      r8a66597_hub_status_data,
        .hub_control =          r8a66597_hub_control,
+        .bus_suspend =          r8a66597_bus_suspend,
+        .bus_resume =           r8a66597_bus_resume,
 };
 #if defined(CONFIG_PM)
 static int r8a66597_suspend(struct platform_device *pdev, pm_message_t state)
 {
+        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        int port;
+        dbg("%s", __func__);
+        disable_controller(r8a66597);
+        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+                struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
+                rh->port = 0x00000000;
+        }
        return 0;
 }
 static int r8a66597_resume(struct platform_device *pdev)
 {
+        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
+        dbg("%s", __func__);
+        enable_controller(r8a66597);
+        usb_root_hub_lost_power(hcd->self.root_hub);
        return 0;
 }
 #else   /* if defined(CONFIG_PM) */
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index ecacde4d69b0..f49208f1bb74 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -504,6 +504,8 @@ struct r8a66597 {
        struct list_head child_device;
        unsigned long child_connect_map[4];
+        unsigned bus_suspended:1;
 };
 static inline struct r8a66597 *hcd_to_r8a66597(struct usb_hcd *hcd)
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index e106e9d48d4a..a949259f18b9 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -230,7 +230,7 @@ static void in_packet(
        writeb(usb_pipedevice(urb->pipe), data_reg);
        sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
-        ep->length = min((int)len,
+        ep->length = min_t(u32, len,
                        urb->transfer_buffer_length - urb->actual_length);
        PACKET("IN%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
                        !!usb_gettoggle(urb->dev, ep->epnum, 0), ep, len);
@@ -255,7 +255,7 @@ static void out_packet(
        buf = urb->transfer_buffer + urb->actual_length;
        prefetch(buf);
-        len = min((int)ep->maxpacket,
+        len = min_t(u32, ep->maxpacket,
                        urb->transfer_buffer_length - urb->actual_length);
        if (!(control & SL11H_HCTLMASK_ISOCH)
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 20cc58b97807..e52b954dda47 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -118,7 +118,9 @@ static int uhci_show_urbp(struct urb_priv *urbp, char *buf, int len, int space)
        }
        out += sprintf(out, "%s%s", ptype, (urbp->fsbr ? " FSBR" : ""));
-        out += sprintf(out, " Actlen=%d", urbp->urb->actual_length);
+        out += sprintf(out, " Actlen=%d%s", urbp->urb->actual_length,
+                        (urbp->qh->type == USB_ENDPOINT_XFER_CONTROL ?
+                                "-8" : ""));
        if (urbp->urb->unlinked)
                out += sprintf(out, " Unlinked=%d", urbp->urb->unlinked);
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 7d01c5677f92..26bd1b2bcbfc 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -73,11 +73,11 @@
 #define   USBLEGSUP_RWC         0x8f00  /* the R/WC bits */
 #define   USBLEGSUP_RO          0x5040  /* R/O and reserved bits */
-#define UHCI_PTR_BITS           __constant_cpu_to_le32(0x000F)
+#define UHCI_PTR_BITS           cpu_to_le32(0x000F)
-#define UHCI_PTR_TERM           __constant_cpu_to_le32(0x0001)
+#define UHCI_PTR_TERM           cpu_to_le32(0x0001)
-#define UHCI_PTR_QH             __constant_cpu_to_le32(0x0002)
+#define UHCI_PTR_QH             cpu_to_le32(0x0002)
-#define UHCI_PTR_DEPTH          __constant_cpu_to_le32(0x0004)
+#define UHCI_PTR_DEPTH          cpu_to_le32(0x0004)
-#define UHCI_PTR_BREADTH        __constant_cpu_to_le32(0x0000)
+#define UHCI_PTR_BREADTH        cpu_to_le32(0x0000)
 #define UHCI_NUMFRAMES          1024    /* in the frame list [array] */
 #define UHCI_MAX_SOF_NUMBER     2047    /* in an SOF packet */
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 5631d89c8730..3e5807d14ffb 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -402,7 +402,7 @@ static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
                /* Otherwise all the toggles in the URB have to be switched */
                } else {
                        list_for_each_entry(td, &urbp->td_list, list) {
-                                td->token ^= __constant_cpu_to_le32(
+                                td->token ^= cpu_to_le32(
                                                        TD_TOKEN_TOGGLE);
                                toggle ^= 1;
                        }
@@ -883,7 +883,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
        uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
        wmb();
-        qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
        qh->dummy_td = td;
        /* Low-speed transfers get a different queue, and won't hog the bus.
@@ -899,8 +899,6 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
        }
        if (qh->state != QH_STATE_ACTIVE)
                qh->skel = skel;
-        urb->actual_length = -8;        /* Account for the SETUP packet */
        return 0;
 nomem:
@@ -1003,7 +1001,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
         * fast side but not enough to justify delaying an interrupt
         * more than 2 or 3 URBs, so we will ignore the URB_NO_INTERRUPT
         * flag setting. */
-        td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_le32(TD_CTRL_IOC);
        /*
         * Build the new dummy TD and activate the old one
@@ -1015,7 +1013,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
        uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
        wmb();
-        qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
+        qh->dummy_td->status |= cpu_to_le32(TD_CTRL_ACTIVE);
        qh->dummy_td = td;
        usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
@@ -1317,7 +1315,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
        }
        /* Set the interrupt-on-completion flag on the last packet. */
-        td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
+        td->status |= cpu_to_le32(TD_CTRL_IOC);
        /* Add the TDs to the frame list */
        frame = urb->start_frame;
@@ -1494,11 +1492,10 @@ __acquires(uhci->lock)
        if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
-                /* urb->actual_length < 0 means the setup transaction didn't
+                /* Subtract off the length of the SETUP packet from
-                 * complete successfully.  Either it failed or the URB was
+                 * urb->actual_length.
-                 * unlinked first.  Regardless, don't confuse people with a
+                 */
-                 * negative length. */
+                urb->actual_length -= min_t(u32, 8, urb->actual_length);
-                urb->actual_length = max(urb->actual_length, 0);
        }
        /* When giving back the first URB in an Isochronous queue,
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index 972f20b3406c..eca355dccf65 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -188,7 +188,7 @@ static struct usb_endpoint_descriptor mdc800_ed [4] =
                .bDescriptorType =      0,
                .bEndpointAddress =     0x01,
                .bmAttributes =         0x02,
-                .wMaxPacketSize =       __constant_cpu_to_le16(8),
+                .wMaxPacketSize =       cpu_to_le16(8),
                .bInterval =            0,
                .bRefresh =             0,
                .bSynchAddress =        0,
@@ -198,7 +198,7 @@ static struct usb_endpoint_descriptor mdc800_ed [4] =
                .bDescriptorType =      0,
                .bEndpointAddress =     0x82,
                .bmAttributes =         0x03,
-                .wMaxPacketSize =       __constant_cpu_to_le16(8),
+                .wMaxPacketSize =       cpu_to_le16(8),
                .bInterval =            0,
                .bRefresh =             0,
                .bSynchAddress =        0,
@@ -208,7 +208,7 @@ static struct usb_endpoint_descriptor mdc800_ed [4] =
                .bDescriptorType =      0,
                .bEndpointAddress =     0x03,
                .bmAttributes =         0x02,
-                .wMaxPacketSize =       __constant_cpu_to_le16(64),
+                .wMaxPacketSize =       cpu_to_le16(64),
                .bInterval =            0,
                .bRefresh =             0,
                .bSynchAddress =        0,
@@ -218,7 +218,7 @@ static struct usb_endpoint_descriptor mdc800_ed [4] =
                .bDescriptorType =      0,
                .bEndpointAddress =     0x84,
                .bmAttributes =         0x02,
-                .wMaxPacketSize =       __constant_cpu_to_le16(64),
+                .wMaxPacketSize =       cpu_to_le16(64),
                .bInterval =            0,
                .bRefresh =             0,
                .bSynchAddress =        0,
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index e463db5d8188..a68d91a11bee 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -135,45 +135,6 @@ config USB_CYTHERM
          To compile this driver as a module, choose M here: the
          module will be called cytherm.
-config USB_PHIDGET
-        tristate "USB Phidgets drivers"
-        depends on USB
-        help
-          Say Y here to enable the various drivers for devices from
-          Phidgets inc.
-config USB_PHIDGETKIT
-        tristate "USB PhidgetInterfaceKit support"
-        depends on USB_PHIDGET
-        help
-          Say Y here if you want to connect a PhidgetInterfaceKit USB device
-          from Phidgets Inc.
-          To compile this driver as a module, choose M here: the
-          module will be called phidgetkit.
-config USB_PHIDGETMOTORCONTROL
-        tristate "USB PhidgetMotorControl support"
-        depends on USB_PHIDGET
-        help
-          Say Y here if you want to connect a PhidgetMotorControl USB device
-          from Phidgets Inc.
-          To compile this driver as a module, choose M here: the
-          module will be called phidgetmotorcontrol.
-config USB_PHIDGETSERVO
-        tristate "USB PhidgetServo support"
-        depends on USB_PHIDGET
-        help
-          Say Y here if you want to connect an 1 or 4 Motor PhidgetServo 
-          servo controller version 2.0 or 3.0.
-          Phidgets Inc. has a web page at <http://www.phidgets.com/>.
-          To compile this driver as a module, choose M here: the
-          module will be called phidgetservo.
 config USB_IDMOUSE
        tristate "Siemens ID USB Mouse Fingerprint sensor support"
        depends on USB
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 1334f7bdd7be..0826aab8303f 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -18,10 +18,6 @@ obj-$(CONFIG_USB_LCD)		+= usblcd.o
 obj-$(CONFIG_USB_LD)            += ldusb.o
 obj-$(CONFIG_USB_LED)           += usbled.o
 obj-$(CONFIG_USB_LEGOTOWER)     += legousbtower.o
-obj-$(CONFIG_USB_PHIDGET)       += phidget.o
-obj-$(CONFIG_USB_PHIDGETKIT)    += phidgetkit.o
-obj-$(CONFIG_USB_PHIDGETMOTORCONTROL)   += phidgetmotorcontrol.o
-obj-$(CONFIG_USB_PHIDGETSERVO)  += phidgetservo.o
 obj-$(CONFIG_USB_RIO500)        += rio500.o
 obj-$(CONFIG_USB_TEST)          += usbtest.o
 obj-$(CONFIG_USB_TRANCEVIBRATOR)        += trancevibrator.o
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index 79a7668ef264..9d0675ed0d4c 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -1568,7 +1568,7 @@ static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number,
                        struct u132_target *target = &ftdi->target[ed];
                        struct u132_command *command = &ftdi->command[
                                COMMAND_MASK & ftdi->command_next];
-                        int remaining_length = urb->transfer_buffer_length -
+                        u32 remaining_length = urb->transfer_buffer_length -
                                urb->actual_length;
                        command->header = 0x82 | (ed << 5);
                        if (remaining_length == 0) {
@@ -1702,7 +1702,7 @@ static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number,
                                | (address << 0);
                        command->width = usb_maxpacket(urb->dev, urb->pipe,
                                usb_pipeout(urb->pipe));
-                        command->follows = min(1024,
+                        command->follows = min_t(u32, 1024,
                                urb->transfer_buffer_length -
                                urb->actual_length);
                        command->value = 0;
@@ -1766,7 +1766,7 @@ static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number,
                mutex_lock(&ftdi->u132_lock);
                command_size = ftdi->command_next - ftdi->command_head;
                if (command_size < COMMAND_SIZE) {
-                        int remaining_length = urb->transfer_buffer_length -
+                        u32 remaining_length = urb->transfer_buffer_length -
                                urb->actual_length;
                        struct u132_target *target = &ftdi->target[ed];
                        struct u132_command *command = &ftdi->command[
diff --git a/drivers/usb/misc/phidget.c b/drivers/usb/misc/phidget.c
deleted file mode 100644
index 735ed33f4f7f..000000000000
--- a/drivers/usb/misc/phidget.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * USB Phidgets class
- *
- * Copyright (C) 2006  Sean Young <sean@mess.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/err.h>
-#include <linux/device.h>
-struct class *phidget_class;
-static int __init init_phidget(void)
-{
-        phidget_class = class_create(THIS_MODULE, "phidget");
-        if (IS_ERR(phidget_class))
-                return PTR_ERR(phidget_class);
-        return 0;
-}
-static void __exit cleanup_phidget(void)
-{
-        class_destroy(phidget_class);
-}
-EXPORT_SYMBOL_GPL(phidget_class);
-module_init(init_phidget);
-module_exit(cleanup_phidget);
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Sean Young <sean@mess.org>");
-MODULE_DESCRIPTION("Container module for phidget class");
diff --git a/drivers/usb/misc/phidget.h b/drivers/usb/misc/phidget.h
deleted file mode 100644
index c4011907d431..000000000000
--- a/drivers/usb/misc/phidget.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * USB Phidgets class
- *
- * Copyright (C) 2006  Sean Young <sean@mess.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-extern struct class *phidget_class;
diff --git a/drivers/usb/misc/phidgetkit.c b/drivers/usb/misc/phidgetkit.c
deleted file mode 100644
index cc8e0a926f99..000000000000
--- a/drivers/usb/misc/phidgetkit.c
+++ /dev/null
@@ -1,740 +0,0 @@
-/*
- * USB PhidgetInterfaceKit driver 1.0
- *
- * Copyright (C) 2004, 2006 Sean Young <sean@mess.org>
- * Copyright (C) 2005 Daniel Saakes <daniel@saakes.net>
- * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This is a driver for the USB PhidgetInterfaceKit.
- */
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include "phidget.h"
-#define DRIVER_AUTHOR "Sean Young <sean@mess.org>"
-#define DRIVER_DESC "USB PhidgetInterfaceKit Driver"
-#define USB_VENDOR_ID_GLAB              0x06c2
-#define USB_DEVICE_ID_INTERFACEKIT004   0x0040
-#define USB_DEVICE_ID_INTERFACEKIT01616 0x0044
-#define USB_DEVICE_ID_INTERFACEKIT888   0x0045
-#define USB_DEVICE_ID_INTERFACEKIT047   0x0051
-#define USB_DEVICE_ID_INTERFACEKIT088   0x0053
-#define USB_VENDOR_ID_WISEGROUP         0x0925
-#define USB_DEVICE_ID_INTERFACEKIT884   0x8201
-#define MAX_INTERFACES                  16
-#define URB_INT_SIZE                    8
-struct driver_interfacekit {
-        int sensors;
-        int inputs;
-        int outputs;
-        int has_lcd;
-        int amnesiac;
-};
-#define ifkit(_sensors, _inputs, _outputs, _lcd, _amnesiac)             \
-{                                                                       \
-        .sensors        = _sensors,                                     \
-        .inputs         = _inputs,                                      \
-        .outputs        = _outputs,                                     \
-        .has_lcd        = _lcd,                                         \
-        .amnesiac       = _amnesiac                                     \
-};
-static const struct driver_interfacekit ph_004 = ifkit(0, 0, 4, 0, 0);
-static const struct driver_interfacekit ph_888n = ifkit(8, 8, 8, 0, 1);
-static const struct driver_interfacekit ph_888o = ifkit(8, 8, 8, 0, 0);
-static const struct driver_interfacekit ph_047 = ifkit(0, 4, 7, 1, 0);
-static const struct driver_interfacekit ph_884 = ifkit(8, 8, 4, 0, 0);
-static const struct driver_interfacekit ph_088 = ifkit(0, 8, 8, 1, 0);
-static const struct driver_interfacekit ph_01616 = ifkit(0, 16, 16, 0, 0);
-static unsigned long device_no;
-struct interfacekit {
-        struct usb_device *udev;
-        struct usb_interface *intf;
-        struct driver_interfacekit *ifkit;
-        struct device *dev;
-        unsigned long outputs;
-        int dev_no;
-        u8 inputs[MAX_INTERFACES];
-        u16 sensors[MAX_INTERFACES];
-        u8 lcd_files_on;
-        struct urb *irq;
-        unsigned char *data;
-        dma_addr_t data_dma;
-        struct delayed_work do_notify;
-        struct delayed_work do_resubmit;
-        unsigned long input_events;
-        unsigned long sensor_events;
-};
-static struct usb_device_id id_table[] = {
-        {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT004),
-                .driver_info = (kernel_ulong_t)&ph_004},
-        {USB_DEVICE_VER(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT888, 0, 0x814),
-                .driver_info = (kernel_ulong_t)&ph_888o},
-        {USB_DEVICE_VER(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT888, 0x0815, 0xffff),
-                .driver_info = (kernel_ulong_t)&ph_888n},
-        {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT047),
-                .driver_info = (kernel_ulong_t)&ph_047},
-        {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT088),
-                .driver_info = (kernel_ulong_t)&ph_088},
-        {USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_INTERFACEKIT01616),
-                .driver_info = (kernel_ulong_t)&ph_01616},
-        {USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_INTERFACEKIT884),
-                .driver_info = (kernel_ulong_t)&ph_884},
-        {}
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-static int set_outputs(struct interfacekit *kit)
-{
-        u8 *buffer;
-        int retval;
-        buffer = kzalloc(4, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
-                return -ENOMEM;
-        }
-        buffer[0] = (u8)kit->outputs;
-        buffer[1] = (u8)(kit->outputs >> 8);
-        dev_dbg(&kit->udev->dev, "sending data: 0x%04x\n", (u16)kit->outputs);
-        retval = usb_control_msg(kit->udev,
-                         usb_sndctrlpipe(kit->udev, 0),
-                         0x09, 0x21, 0x0200, 0x0000, buffer, 4, 2000);
-        if (retval != 4)
-                dev_err(&kit->udev->dev, "usb_control_msg returned %d\n", 
-                                retval);
-        kfree(buffer);
-        if (kit->ifkit->amnesiac)
-                schedule_delayed_work(&kit->do_resubmit, HZ / 2);
-        return retval < 0 ? retval : 0;
-}
-static int change_string(struct interfacekit *kit, const char *display, unsigned char row)
-{
-        unsigned char *buffer;
-        unsigned char *form_buffer;
-        int retval = -ENOMEM;
-        int i,j, len, buf_ptr;
-        
-        buffer = kmalloc(8, GFP_KERNEL);
-        form_buffer = kmalloc(30, GFP_KERNEL);
-        if ((!buffer) || (!form_buffer)) {
-                dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
-                goto exit;
-        }
-        len = strlen(display);
-        if (len > 20)
-                len = 20;
-        dev_dbg(&kit->udev->dev, "Setting LCD line %d to %s\n", row, display);
-        form_buffer[0] = row * 0x40 + 0x80;
-        form_buffer[1] = 0x02;
-        buf_ptr = 2;
-        for (i = 0; i<len; i++)
-                form_buffer[buf_ptr++] = display[i];
-        for (i = 0; i < (20 - len); i++)
-                form_buffer[buf_ptr++] = 0x20;
-        form_buffer[buf_ptr++] = 0x01;
-        form_buffer[buf_ptr++] = row * 0x40 + 0x80 + strlen(display);
-        for (i = 0; i < buf_ptr; i += 7) {
-                if ((buf_ptr - i) > 7)
-                        len = 7;
-                else
-                        len = (buf_ptr - i);
-                for (j = 0; j < len; j++)
-                        buffer[j] = form_buffer[i + j];
-                buffer[7] = len;
-                retval = usb_control_msg(kit->udev,
-                                 usb_sndctrlpipe(kit->udev, 0),
-                                 0x09, 0x21, 0x0200, 0x0000, buffer, 8, 2000);
-                if (retval < 0)
-                        goto exit;
-        }
-        retval = 0;
-exit:
-        kfree(buffer);
-        kfree(form_buffer);
-        return retval;
-}
-#define set_lcd_line(number)    \
-static ssize_t lcd_line_##number(struct device *dev,                    \
-                                        struct device_attribute *attr,  \
-                                        const char *buf, size_t count)  \
-{                                                                       \
-        struct interfacekit *kit = dev_get_drvdata(dev);                \
-        change_string(kit, buf, number - 1);                            \
-        return count;                                                   \
-}
-#define lcd_line_attr(number)                                           \
-        __ATTR(lcd_line_##number, S_IWUGO, NULL, lcd_line_##number)
-set_lcd_line(1);
-set_lcd_line(2);
-static ssize_t set_backlight(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
-{
-        struct interfacekit *kit = dev_get_drvdata(dev);
-        int enabled;
-        unsigned char *buffer;
-        int retval = -ENOMEM;
-        
-        buffer = kzalloc(8, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
-                goto exit;
-        }
-        if (sscanf(buf, "%d", &enabled) < 1) {
-                retval = -EINVAL;
-                goto exit;
-        }
-        if (enabled)
-                buffer[0] = 0x01;
-        buffer[7] = 0x11;
-        dev_dbg(&kit->udev->dev, "Setting backlight to %s\n", enabled ? "on" : "off");
-        
-        retval = usb_control_msg(kit->udev,
-                         usb_sndctrlpipe(kit->udev, 0),
-                         0x09, 0x21, 0x0200, 0x0000, buffer, 8, 2000);
-        if (retval < 0)
-                goto exit;
-        retval = count;
-exit:
-        kfree(buffer);
-        return retval;
-}
-static struct device_attribute dev_lcd_line_attrs[] = {
-        lcd_line_attr(1),
-        lcd_line_attr(2),
-        __ATTR(backlight, S_IWUGO, NULL, set_backlight)
-};
-static void remove_lcd_files(struct interfacekit *kit)
-{
-        int i;
-        if (kit->lcd_files_on) {
-                dev_dbg(&kit->udev->dev, "Removing lcd files\n");
-                for (i=0; i<ARRAY_SIZE(dev_lcd_line_attrs); i++)
-                        device_remove_file(kit->dev, &dev_lcd_line_attrs[i]);
-        }
-}
-static ssize_t enable_lcd_files(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
-{
-        struct interfacekit *kit = dev_get_drvdata(dev);
-        int enable;
-        int i, rc;
-        
-        if (kit->ifkit->has_lcd == 0)
-                return -ENODEV;
-        if (sscanf(buf, "%d", &enable) < 1)
-                return -EINVAL;
-        if (enable) {
-                if (!kit->lcd_files_on) {
-                        dev_dbg(&kit->udev->dev, "Adding lcd files\n");
-                        for (i=0; i<ARRAY_SIZE(dev_lcd_line_attrs); i++) {
-                                rc = device_create_file(kit->dev,
-                                        &dev_lcd_line_attrs[i]);
-                                if (rc)
-                                        goto out;
-                        }
-                        kit->lcd_files_on = 1;
-                }
-        } else {
-                if (kit->lcd_files_on) {
-                        remove_lcd_files(kit);
-                        kit->lcd_files_on = 0;
-                }
-        }
-        
-        return count;
-out:
-        while (i-- > 0)
-                device_remove_file(kit->dev, &dev_lcd_line_attrs[i]);
-        return rc;
-}
-static DEVICE_ATTR(lcd, S_IWUGO, NULL, enable_lcd_files);
-static void interfacekit_irq(struct urb *urb)
-{
-        struct interfacekit *kit = urb->context;
-        unsigned char *buffer = kit->data;
-        int i, level, sensor;
-        int retval;
-        int status = urb->status;
-        switch (status) {
-        case 0:                 /* success */
-                break;
-        case -ECONNRESET:       /* unlink */
-        case -ENOENT:
-        case -ESHUTDOWN:
-                return;
-        /* -EPIPE:  should clear the halt */
-        default:                /* error */
-                goto resubmit;
-        }
-        /* digital inputs */
-        if (kit->ifkit->inputs == 16) {
-                for (i=0; i < 8; i++) {
-                        level = (buffer[0] >> i) & 1;
-                        if (kit->inputs[i] != level) {
-                                kit->inputs[i] = level;
-                                set_bit(i, &kit->input_events);
-                        }
-                        level = (buffer[1] >> i) & 1;
-                        if (kit->inputs[8 + i] != level) {
-                                kit->inputs[8 + i] = level;
-                                set_bit(8 + i, &kit->input_events);
-                        }
-                }
-        }
-        else if (kit->ifkit->inputs == 8) {
-                for (i=0; i < 8; i++) {
-                        level = (buffer[1] >> i) & 1;
-                        if (kit->inputs[i] != level) {
-                                kit->inputs[i] = level;
-                                set_bit(i, &kit->input_events);
-                        }
-                }
-        }
-        /* analog inputs */
-        if (kit->ifkit->sensors) {
-                sensor = (buffer[0] & 1) ? 4 : 0;
-                level = buffer[2] + (buffer[3] & 0x0f) * 256;
-                if (level != kit->sensors[sensor]) {
-                        kit->sensors[sensor] = level;
-                        set_bit(sensor, &kit->sensor_events);
-                }
-                sensor++;
-                level = buffer[4] + (buffer[3] & 0xf0) * 16;
-                if (level != kit->sensors[sensor]) {
-                        kit->sensors[sensor] = level;
-                        set_bit(sensor, &kit->sensor_events);
-                }
-                sensor++;
-                level = buffer[5] + (buffer[6] & 0x0f) * 256;
-                if (level != kit->sensors[sensor]) {
-                        kit->sensors[sensor] = level;
-                        set_bit(sensor, &kit->sensor_events);
-                }
-                sensor++;
-                level = buffer[7] + (buffer[6] & 0xf0) * 16;
-                if (level != kit->sensors[sensor]) {
-                        kit->sensors[sensor] = level;
-                        set_bit(sensor, &kit->sensor_events);
-                }
-        }
-        if (kit->input_events || kit->sensor_events)
-                schedule_delayed_work(&kit->do_notify, 0);
-resubmit:
-        retval = usb_submit_urb(urb, GFP_ATOMIC);
-        if (retval)
-                err("can't resubmit intr, %s-%s/interfacekit0, retval %d",
-                        kit->udev->bus->bus_name,
-                        kit->udev->devpath, retval);
-}
-static void do_notify(struct work_struct *work)
-{
-        struct interfacekit *kit =
-                container_of(work, struct interfacekit, do_notify.work);
-        int i;
-        char sysfs_file[8];
-        for (i=0; i<kit->ifkit->inputs; i++) {
-                if (test_and_clear_bit(i, &kit->input_events)) {
-                        sprintf(sysfs_file, "input%d", i + 1);
-                        sysfs_notify(&kit->dev->kobj, NULL, sysfs_file);
-                }
-        }
-        for (i=0; i<kit->ifkit->sensors; i++) {
-                if (test_and_clear_bit(i, &kit->sensor_events)) {
-                        sprintf(sysfs_file, "sensor%d", i + 1);
-                        sysfs_notify(&kit->dev->kobj, NULL, sysfs_file);
-                }
-        }
-}
-static void do_resubmit(struct work_struct *work)
-{
-        struct interfacekit *kit =
-                container_of(work, struct interfacekit, do_resubmit.work);
-        set_outputs(kit);
-}
-#define show_set_output(value)          \
-static ssize_t set_output##value(struct device *dev,                    \
-                                        struct device_attribute *attr,  \
-                                        const char *buf, size_t count)  \
-{                                                                       \
-        struct interfacekit *kit = dev_get_drvdata(dev);                \
-        int enable;                                                     \
-        int retval;                                                     \
-                                                                        \
-        if (sscanf(buf, "%d", &enable) < 1)                             \
-                return -EINVAL;                                         \
-                                                                        \
-        if (enable)                                                     \
-                set_bit(value - 1, &kit->outputs);                      \
-        else                                                            \
-                clear_bit(value - 1, &kit->outputs);                    \
-                                                                        \
-        retval = set_outputs(kit);                                      \
-                                                                        \
-        return retval ? retval : count;                                 \
-}                                                                       \
-                                                                        \
-static ssize_t show_output##value(struct device *dev,                   \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct interfacekit *kit = dev_get_drvdata(dev);                \
-                                                                        \
-        return sprintf(buf, "%d\n", !!test_bit(value - 1, &kit->outputs));\
-}
-#define output_attr(value)                                              \
-        __ATTR(output##value, S_IWUGO | S_IRUGO,                        \
-                show_output##value, set_output##value)
-show_set_output(1);
-show_set_output(2);
-show_set_output(3);
-show_set_output(4);
-show_set_output(5);
-show_set_output(6);
-show_set_output(7);
-show_set_output(8);
-show_set_output(9);
-show_set_output(10);
-show_set_output(11);
-show_set_output(12);
-show_set_output(13);
-show_set_output(14);
-show_set_output(15);
-show_set_output(16);
-static struct device_attribute dev_output_attrs[] = {
-        output_attr(1), output_attr(2), output_attr(3), output_attr(4),
-        output_attr(5), output_attr(6), output_attr(7), output_attr(8),
-        output_attr(9), output_attr(10), output_attr(11), output_attr(12),
-        output_attr(13), output_attr(14), output_attr(15), output_attr(16)
-};
-#define show_input(value)       \
-static ssize_t show_input##value(struct device *dev,                    \
-                        struct device_attribute *attr, char *buf)       \
-{                                                                       \
-        struct interfacekit *kit = dev_get_drvdata(dev);                \
-                                                                        \
-        return sprintf(buf, "%d\n", (int)kit->inputs[value - 1]);       \
-}
-#define input_attr(value)                                               \
-        __ATTR(input##value, S_IRUGO, show_input##value, NULL)
-show_input(1);
-show_input(2);
-show_input(3);
-show_input(4);
-show_input(5);
-show_input(6);
-show_input(7);
-show_input(8);
-show_input(9);
-show_input(10);
-show_input(11);
-show_input(12);
-show_input(13);
-show_input(14);
-show_input(15);
-show_input(16);
-static struct device_attribute dev_input_attrs[] = {
-        input_attr(1), input_attr(2), input_attr(3), input_attr(4),
-        input_attr(5), input_attr(6), input_attr(7), input_attr(8),
-        input_attr(9), input_attr(10), input_attr(11), input_attr(12),
-        input_attr(13), input_attr(14), input_attr(15), input_attr(16)
-};
-#define show_sensor(value)      \
-static ssize_t show_sensor##value(struct device *dev,                   \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct interfacekit *kit = dev_get_drvdata(dev);                \
-                                                                        \
-        return sprintf(buf, "%d\n", (int)kit->sensors[value - 1]);      \
-}
-#define sensor_attr(value)                                              \
-        __ATTR(sensor##value, S_IRUGO, show_sensor##value, NULL)
-show_sensor(1);
-show_sensor(2);
-show_sensor(3);
-show_sensor(4);
-show_sensor(5);
-show_sensor(6);
-show_sensor(7);
-show_sensor(8);
-static struct device_attribute dev_sensor_attrs[] = {
-        sensor_attr(1), sensor_attr(2), sensor_attr(3), sensor_attr(4),
-        sensor_attr(5), sensor_attr(6), sensor_attr(7), sensor_attr(8)
-};
-static int interfacekit_probe(struct usb_interface *intf, const struct usb_device_id *id)
-{
-        struct usb_device *dev = interface_to_usbdev(intf);
-        struct usb_host_interface *interface;
-        struct usb_endpoint_descriptor *endpoint;
-        struct interfacekit *kit;
-        struct driver_interfacekit *ifkit;
-        int pipe, maxp, rc = -ENOMEM;
-        int bit, value, i;
-        ifkit = (struct driver_interfacekit *)id->driver_info;
-        if (!ifkit)
-                return -ENODEV;
-        interface = intf->cur_altsetting;
-        if (interface->desc.bNumEndpoints != 1)
-                return -ENODEV;
-        endpoint = &interface->endpoint[0].desc;
-        if (!usb_endpoint_dir_in(endpoint))
-                return -ENODEV;
-        /*
-         * bmAttributes
-         */
-        pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
-        maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
-        
-        kit = kzalloc(sizeof(*kit), GFP_KERNEL);
-        if (!kit)
-                goto out;
-        kit->dev_no = -1;
-        kit->ifkit = ifkit;
-        kit->data = usb_buffer_alloc(dev, URB_INT_SIZE, GFP_ATOMIC, &kit->data_dma);
-        if (!kit->data)
-                goto out;
-        kit->irq = usb_alloc_urb(0, GFP_KERNEL);
-        if (!kit->irq)
-                goto out;
-        kit->udev = usb_get_dev(dev);
-        kit->intf = intf;
-        INIT_DELAYED_WORK(&kit->do_notify, do_notify);
-        INIT_DELAYED_WORK(&kit->do_resubmit, do_resubmit);
-        usb_fill_int_urb(kit->irq, kit->udev, pipe, kit->data,
-                        maxp > URB_INT_SIZE ? URB_INT_SIZE : maxp,
-                        interfacekit_irq, kit, endpoint->bInterval);
-        kit->irq->transfer_dma = kit->data_dma;
-        kit->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        usb_set_intfdata(intf, kit);
-        do {
-                bit = find_first_zero_bit(&device_no, sizeof(device_no));
-                value = test_and_set_bit(bit, &device_no);
-        } while(value);
-        kit->dev_no = bit;
-        kit->dev = device_create(phidget_class, &kit->udev->dev, MKDEV(0, 0),
-                                 kit, "interfacekit%d", kit->dev_no);
-        if (IS_ERR(kit->dev)) {
-                rc = PTR_ERR(kit->dev);
-                kit->dev = NULL;
-                goto out;
-        }
-        if (usb_submit_urb(kit->irq, GFP_KERNEL)) {
-                rc = -EIO;
-                goto out;
-        }
-        for (i=0; i<ifkit->outputs; i++ ) {
-                rc = device_create_file(kit->dev, &dev_output_attrs[i]);
-                if (rc)
-                        goto out2;
-        }
-        for (i=0; i<ifkit->inputs; i++ ) {
-                rc = device_create_file(kit->dev, &dev_input_attrs[i]);
-                if (rc)
-                        goto out3;
-        }
-        for (i=0; i<ifkit->sensors; i++ ) {
-                rc = device_create_file(kit->dev, &dev_sensor_attrs[i]);
-                if (rc)
-                        goto out4;
-        }
-        if (ifkit->has_lcd) {
-                rc = device_create_file(kit->dev, &dev_attr_lcd);
-                if (rc)
-                        goto out4;
-        }
-        dev_info(&intf->dev, "USB PhidgetInterfaceKit %d/%d/%d attached\n",
-                        ifkit->sensors, ifkit->inputs, ifkit->outputs);
-        return 0;
-out4:
-        while (i-- > 0)
-                device_remove_file(kit->dev, &dev_sensor_attrs[i]);
-        i = ifkit->inputs;
-out3:
-        while (i-- > 0)
-                device_remove_file(kit->dev, &dev_input_attrs[i]);
-        i = ifkit->outputs;
-out2:
-        while (i-- > 0)
-                device_remove_file(kit->dev, &dev_output_attrs[i]);
-out:
-        if (kit) {
-                usb_free_urb(kit->irq);
-                if (kit->data)
-                        usb_buffer_free(dev, URB_INT_SIZE, kit->data, kit->data_dma);
-                if (kit->dev)
-                        device_unregister(kit->dev);
-                if (kit->dev_no >= 0)
-                        clear_bit(kit->dev_no, &device_no);
-                kfree(kit);
-        }
-        return rc;
-}
-static void interfacekit_disconnect(struct usb_interface *interface)
-{
-        struct interfacekit *kit;
-        int i;
-        kit = usb_get_intfdata(interface);
-        usb_set_intfdata(interface, NULL);
-        if (!kit)
-                return;
-        usb_kill_urb(kit->irq);
-        usb_free_urb(kit->irq);
-        usb_buffer_free(kit->udev, URB_INT_SIZE, kit->data, kit->data_dma);
-        cancel_delayed_work(&kit->do_notify);
-        cancel_delayed_work(&kit->do_resubmit);
-        for (i=0; i<kit->ifkit->outputs; i++)
-                device_remove_file(kit->dev, &dev_output_attrs[i]);
-        for (i=0; i<kit->ifkit->inputs; i++)
-                device_remove_file(kit->dev, &dev_input_attrs[i]);
-        for (i=0; i<kit->ifkit->sensors; i++)
-                device_remove_file(kit->dev, &dev_sensor_attrs[i]);
-        if (kit->ifkit->has_lcd) {
-                device_remove_file(kit->dev, &dev_attr_lcd);
-                remove_lcd_files(kit);
-        }
-        device_unregister(kit->dev);
-        dev_info(&interface->dev, "USB PhidgetInterfaceKit %d/%d/%d detached\n",
-                kit->ifkit->sensors, kit->ifkit->inputs, kit->ifkit->outputs);
-        usb_put_dev(kit->udev);
-        clear_bit(kit->dev_no, &device_no);
-        kfree(kit);
-}
-static struct usb_driver interfacekit_driver = {
-        .name = "phidgetkit",
-        .probe = interfacekit_probe,
-        .disconnect = interfacekit_disconnect,
-        .id_table = id_table
-};
-static int __init interfacekit_init(void)
-{
-        int retval = 0;
-        retval = usb_register(&interfacekit_driver);
-        if (retval)
-                err("usb_register failed. Error number %d", retval);
-        return retval;
-}
-static void __exit interfacekit_exit(void)
-{
-        usb_deregister(&interfacekit_driver);
-}
-module_init(interfacekit_init);
-module_exit(interfacekit_exit);
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
diff --git a/drivers/usb/misc/phidgetmotorcontrol.c b/drivers/usb/misc/phidgetmotorcontrol.c
deleted file mode 100644
index 38088b44349e..000000000000
--- a/drivers/usb/misc/phidgetmotorcontrol.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/*
- * USB Phidget MotorControl driver
- *
- * Copyright (C) 2006  Sean Young <sean@mess.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include "phidget.h"
-#define DRIVER_AUTHOR "Sean Young <sean@mess.org>"
-#define DRIVER_DESC "USB PhidgetMotorControl Driver"
-#define USB_VENDOR_ID_GLAB              0x06c2
-#define USB_DEVICE_ID_MOTORCONTROL      0x0058
-#define URB_INT_SIZE                    8
-static unsigned long device_no;
-struct motorcontrol {
-        struct usb_device *udev;
-        struct usb_interface *intf;
-        struct device *dev;
-        int dev_no;
-        u8 inputs[4];
-        s8 desired_speed[2];
-        s8 speed[2];
-        s16 _current[2];
-        s8 acceleration[2];
-        struct urb *irq;
-        unsigned char *data;
-        dma_addr_t data_dma;
-        struct delayed_work do_notify;
-        unsigned long input_events;
-        unsigned long speed_events;
-        unsigned long exceed_events;
-};
-static struct usb_device_id id_table[] = {
-        { USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_MOTORCONTROL) },
-        {}
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-static int set_motor(struct motorcontrol *mc, int motor)
-{
-        u8 *buffer;
-        int speed, speed2, acceleration;
-        int retval;
-        buffer = kzalloc(8, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&mc->intf->dev, "%s - out of memory\n", __func__);
-                return -ENOMEM;
-        }
-        acceleration = mc->acceleration[motor] * 10;
-        /* -127 <= speed <= 127 */
-        speed = (mc->desired_speed[motor] * 127) / 100;
-        /* -0x7300 <= speed2 <= 0x7300 */
-        speed2 = (mc->desired_speed[motor] * 230 * 128) / 100;
-        buffer[0] = motor;
-        buffer[1] = speed;
-        buffer[2] = acceleration >> 8;
-        buffer[3] = acceleration;
-        buffer[4] = speed2 >> 8;
-        buffer[5] = speed2;
-        retval = usb_control_msg(mc->udev,
-                         usb_sndctrlpipe(mc->udev, 0),
-                         0x09, 0x21, 0x0200, 0x0000, buffer, 8, 2000);
-        if (retval != 8)
-                dev_err(&mc->intf->dev, "usb_control_msg returned %d\n",
-                                retval);
-        kfree(buffer);
-        return retval < 0 ? retval : 0;
-}
-static void motorcontrol_irq(struct urb *urb)
-{
-        struct motorcontrol *mc = urb->context;
-        unsigned char *buffer = mc->data;
-        int i, level;
-        int retval;
-        int status = urb->status;;
-        switch (status) {
-        case 0:                 /* success */
-                break;
-        case -ECONNRESET:       /* unlink */
-        case -ENOENT:
-        case -ESHUTDOWN:
-                return;
-        /* -EPIPE:  should clear the halt */
-        default:                /* error */
-                goto resubmit;
-        }
-        /* digital inputs */
-        for (i=0; i<4; i++) {
-                level = (buffer[0] >> i) & 1;
-                if (mc->inputs[i] != level) {
-                        mc->inputs[i] = level;
-                        set_bit(i, &mc->input_events);
-                }
-        }
-        /* motor speed */
-        if (buffer[2] == 0) {
-                for (i=0; i<2; i++) {
-                level = ((s8)buffer[4+i]) * 100 / 127;
-                        if (mc->speed[i] != level) {
-                                mc->speed[i] = level;
-                                set_bit(i, &mc->speed_events);
-                        }
-                }
-        } else {
-                int index = buffer[3] & 1;
-                level = ((s8)buffer[4] << 8) | buffer[5];
-                level = level * 100 / 29440;
-                if (mc->speed[index] != level) {
-                        mc->speed[index] = level;
-                        set_bit(index, &mc->speed_events);
-                }
-                level = ((s8)buffer[6] << 8) | buffer[7];
-                mc->_current[index] = level * 100 / 1572;
-        }
-        if (buffer[1] & 1)
-                set_bit(0, &mc->exceed_events);
-        if (buffer[1] & 2)
-                set_bit(1, &mc->exceed_events);
-        if (mc->input_events || mc->exceed_events || mc->speed_events)
-                schedule_delayed_work(&mc->do_notify, 0);
-resubmit:
-        retval = usb_submit_urb(urb, GFP_ATOMIC);
-        if (retval)
-                dev_err(&mc->intf->dev,
-                        "can't resubmit intr, %s-%s/motorcontrol0, retval %d\n",
-                        mc->udev->bus->bus_name,
-                        mc->udev->devpath, retval);
-}
-static void do_notify(struct work_struct *work)
-{
-        struct motorcontrol *mc =
-                container_of(work, struct motorcontrol, do_notify.work);
-        int i;
-        char sysfs_file[8];
-        for (i=0; i<4; i++) {
-                if (test_and_clear_bit(i, &mc->input_events)) {
-                        sprintf(sysfs_file, "input%d", i);
-                        sysfs_notify(&mc->dev->kobj, NULL, sysfs_file);
-                }
-        }
-        for (i=0; i<2; i++) {
-                if (test_and_clear_bit(i, &mc->speed_events)) {
-                        sprintf(sysfs_file, "speed%d", i);
-                        sysfs_notify(&mc->dev->kobj, NULL, sysfs_file);
-                }
-        }
-        for (i=0; i<2; i++) {
-                if (test_and_clear_bit(i, &mc->exceed_events))
-                        dev_warn(&mc->intf->dev,
-                                "motor #%d exceeds 1.5 Amp current limit\n", i);
-        }
-}
-#define show_set_speed(value)           \
-static ssize_t set_speed##value(struct device *dev,                     \
-                                        struct device_attribute *attr,  \
-                                        const char *buf, size_t count)  \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-        int speed;                                                      \
-        int retval;                                                     \
-                                                                        \
-        if (sscanf(buf, "%d", &speed) < 1)                              \
-                return -EINVAL;                                         \
-                                                                        \
-        if (speed < -100 || speed > 100)                                \
-                return -EINVAL;                                         \
-                                                                        \
-        mc->desired_speed[value] = speed;                               \
-                                                                        \
-        retval = set_motor(mc, value);                                  \
-                                                                        \
-        return retval ? retval : count;                                 \
-}                                                                       \
-                                                                        \
-static ssize_t show_speed##value(struct device *dev,                    \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-                                                                        \
-        return sprintf(buf, "%d\n", mc->speed[value]);                  \
-}
-#define speed_attr(value)                                               \
-        __ATTR(speed##value, S_IWUGO | S_IRUGO,                         \
-                show_speed##value, set_speed##value)
-show_set_speed(0);
-show_set_speed(1);
-#define show_set_acceleration(value)            \
-static ssize_t set_acceleration##value(struct device *dev,              \
-                                        struct device_attribute *attr,  \
-                                        const char *buf, size_t count)  \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-        int acceleration;                                               \
-        int retval;                                                     \
-                                                                        \
-        if (sscanf(buf, "%d", &acceleration) < 1)                       \
-                return -EINVAL;                                         \
-                                                                        \
-        if (acceleration < 0 || acceleration > 100)                     \
-                return -EINVAL;                                         \
-                                                                        \
-        mc->acceleration[value] = acceleration;                         \
-                                                                        \
-        retval = set_motor(mc, value);                                  \
-                                                                        \
-        return retval ? retval : count;                                 \
-}                                                                       \
-                                                                        \
-static ssize_t show_acceleration##value(struct device *dev,             \
-                                        struct device_attribute *attr,  \
-                                                        char *buf)      \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-                                                                        \
-        return sprintf(buf, "%d\n", mc->acceleration[value]);           \
-}
-#define acceleration_attr(value)        \
-        __ATTR(acceleration##value, S_IWUGO | S_IRUGO,                  \
-                show_acceleration##value, set_acceleration##value)
-show_set_acceleration(0);
-show_set_acceleration(1);
-#define show_current(value)     \
-static ssize_t show_current##value(struct device *dev,                  \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-                                                                        \
-        return sprintf(buf, "%dmA\n", (int)mc->_current[value]);        \
-}
-#define current_attr(value)     \
-        __ATTR(current##value, S_IRUGO, show_current##value, NULL)
-show_current(0);
-show_current(1);
-#define show_input(value)       \
-static ssize_t show_input##value(struct device *dev,                    \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct motorcontrol *mc = dev_get_drvdata(dev);                 \
-                                                                        \
-        return sprintf(buf, "%d\n", (int)mc->inputs[value]);            \
-}
-#define input_attr(value)       \
-        __ATTR(input##value, S_IRUGO, show_input##value, NULL)
-show_input(0);
-show_input(1);
-show_input(2);
-show_input(3);
-static struct device_attribute dev_attrs[] = {
-        input_attr(0),
-        input_attr(1),
-        input_attr(2),
-        input_attr(3),
-        speed_attr(0),
-        speed_attr(1),
-        acceleration_attr(0),
-        acceleration_attr(1),
-        current_attr(0),
-        current_attr(1)
-};
-static int motorcontrol_probe(struct usb_interface *intf, const struct usb_device_id *id)
-{
-        struct usb_device *dev = interface_to_usbdev(intf);
-        struct usb_host_interface *interface;
-        struct usb_endpoint_descriptor *endpoint;
-        struct motorcontrol *mc;
-        int pipe, maxp, rc = -ENOMEM;
-        int bit, value, i;
-        interface = intf->cur_altsetting;
-        if (interface->desc.bNumEndpoints != 1)
-                return -ENODEV;
-        endpoint = &interface->endpoint[0].desc;
-        if (!usb_endpoint_dir_in(endpoint))
-                return -ENODEV;
-        /*
-         * bmAttributes
-         */
-        pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
-        maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
-        mc = kzalloc(sizeof(*mc), GFP_KERNEL);
-        if (!mc)
-                goto out;
-        mc->dev_no = -1;
-        mc->data = usb_buffer_alloc(dev, URB_INT_SIZE, GFP_ATOMIC, &mc->data_dma);
-        if (!mc->data)
-                goto out;
-        mc->irq = usb_alloc_urb(0, GFP_KERNEL);
-        if (!mc->irq)
-                goto out;
-        mc->udev = usb_get_dev(dev);
-        mc->intf = intf;
-        mc->acceleration[0] = mc->acceleration[1] = 10;
-        INIT_DELAYED_WORK(&mc->do_notify, do_notify);
-        usb_fill_int_urb(mc->irq, mc->udev, pipe, mc->data,
-                        maxp > URB_INT_SIZE ? URB_INT_SIZE : maxp,
-                        motorcontrol_irq, mc, endpoint->bInterval);
-        mc->irq->transfer_dma = mc->data_dma;
-        mc->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        usb_set_intfdata(intf, mc);
-        do {
-                bit = find_first_zero_bit(&device_no, sizeof(device_no));
-                value = test_and_set_bit(bit, &device_no);
-        } while(value);
-        mc->dev_no = bit;
-        mc->dev = device_create(phidget_class, &mc->udev->dev, MKDEV(0, 0), mc,
-                                "motorcontrol%d", mc->dev_no);
-        if (IS_ERR(mc->dev)) {
-                rc = PTR_ERR(mc->dev);
-                mc->dev = NULL;
-                goto out;
-        }
-        if (usb_submit_urb(mc->irq, GFP_KERNEL)) {
-                rc = -EIO;
-                goto out;
-        }
-        for (i=0; i<ARRAY_SIZE(dev_attrs); i++) {
-                rc = device_create_file(mc->dev, &dev_attrs[i]);
-                if (rc)
-                        goto out2;
-        }
-        dev_info(&intf->dev, "USB PhidgetMotorControl attached\n");
-        return 0;
-out2:
-        while (i-- > 0)
-                device_remove_file(mc->dev, &dev_attrs[i]);
-out:
-        if (mc) {
-                usb_free_urb(mc->irq);
-                if (mc->data)
-                        usb_buffer_free(dev, URB_INT_SIZE, mc->data, mc->data_dma);
-                if (mc->dev)
-                        device_unregister(mc->dev);
-                if (mc->dev_no >= 0)
-                        clear_bit(mc->dev_no, &device_no);
-                kfree(mc);
-        }
-        return rc;
-}
-static void motorcontrol_disconnect(struct usb_interface *interface)
-{
-        struct motorcontrol *mc;
-        int i;
-        mc = usb_get_intfdata(interface);
-        usb_set_intfdata(interface, NULL);
-        if (!mc)
-                return;
-        usb_kill_urb(mc->irq);
-        usb_free_urb(mc->irq);
-        usb_buffer_free(mc->udev, URB_INT_SIZE, mc->data, mc->data_dma);
-        cancel_delayed_work(&mc->do_notify);
-        for (i=0; i<ARRAY_SIZE(dev_attrs); i++)
-                device_remove_file(mc->dev, &dev_attrs[i]);
-        device_unregister(mc->dev);
-        usb_put_dev(mc->udev);
-        clear_bit(mc->dev_no, &device_no);
-        kfree(mc);
-        dev_info(&interface->dev, "USB PhidgetMotorControl detached\n");
-}
-static struct usb_driver motorcontrol_driver = {
-        .name = "phidgetmotorcontrol",
-        .probe = motorcontrol_probe,
-        .disconnect = motorcontrol_disconnect,
-        .id_table = id_table
-};
-static int __init motorcontrol_init(void)
-{
-        int retval = 0;
-        retval = usb_register(&motorcontrol_driver);
-        if (retval)
-                err("usb_register failed. Error number %d", retval);
-        return retval;
-}
-static void __exit motorcontrol_exit(void)
-{
-        usb_deregister(&motorcontrol_driver);
-}
-module_init(motorcontrol_init);
-module_exit(motorcontrol_exit);
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
diff --git a/drivers/usb/misc/phidgetservo.c b/drivers/usb/misc/phidgetservo.c
deleted file mode 100644
index bef6fe16364b..000000000000
--- a/drivers/usb/misc/phidgetservo.c
+++ /dev/null
@@ -1,375 +0,0 @@
-/*
- * USB PhidgetServo driver 1.0
- *
- * Copyright (C) 2004, 2006 Sean Young <sean@mess.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This is a driver for the USB PhidgetServo version 2.0 and 3.0 servo 
- * controllers available at: http://www.phidgets.com/ 
- *
- * Note that the driver takes input as: degrees.minutes
- *
- * CAUTION: Generally you should use 0 < degrees < 180 as anything else
- * is probably beyond the range of your servo and may damage it.
- */
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include "phidget.h"
-#define DRIVER_AUTHOR "Sean Young <sean@mess.org>"
-#define DRIVER_DESC "USB PhidgetServo Driver"
-#define VENDOR_ID_GLAB                          0x06c2
-#define DEVICE_ID_GLAB_PHIDGETSERVO_QUAD        0x0038
-#define DEVICE_ID_GLAB_PHIDGETSERVO_UNI         0x0039
-#define VENDOR_ID_WISEGROUP                     0x0925
-#define VENDOR_ID_WISEGROUP_PHIDGETSERVO_QUAD   0x8101
-#define VENDOR_ID_WISEGROUP_PHIDGETSERVO_UNI    0x8104
-#define SERVO_VERSION_30                        0x01
-#define SERVO_COUNT_QUAD                        0x02
-static struct usb_device_id id_table[] = {
-        {
-                USB_DEVICE(VENDOR_ID_GLAB, DEVICE_ID_GLAB_PHIDGETSERVO_QUAD), 
-                .driver_info = SERVO_VERSION_30 | SERVO_COUNT_QUAD 
-        },
-        {
-                USB_DEVICE(VENDOR_ID_GLAB, DEVICE_ID_GLAB_PHIDGETSERVO_UNI),
-                .driver_info = SERVO_VERSION_30 
-        },
-        {
-                USB_DEVICE(VENDOR_ID_WISEGROUP, 
-                                VENDOR_ID_WISEGROUP_PHIDGETSERVO_QUAD),
-                .driver_info = SERVO_COUNT_QUAD 
-        },
-        {
-                USB_DEVICE(VENDOR_ID_WISEGROUP, 
-                                VENDOR_ID_WISEGROUP_PHIDGETSERVO_UNI),
-                .driver_info = 0
-        },
-        {}
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-static int unsigned long device_no;
-struct phidget_servo {
-        struct usb_device *udev;
-        struct device *dev;
-        int dev_no;
-        ulong type;
-        int pulse[4];
-        int degrees[4];
-        int minutes[4];
-};
-static int
-change_position_v30(struct phidget_servo *servo, int servo_no, int degrees, 
-                                                                int minutes)
-{
-        int retval;
-        unsigned char *buffer;
-        if (degrees < -23 || degrees > 362)
-                return -EINVAL;
-        buffer = kmalloc(6, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&servo->udev->dev, "%s - out of memory\n",
-                        __func__);
-                return -ENOMEM;
-        }
-        /*
-         * pulse = 0 - 4095
-         * angle = 0 - 180 degrees
-         *
-         * pulse = angle * 10.6 + 243.8 
-         */
-        servo->pulse[servo_no] = ((degrees*60 + minutes)*106 + 2438*60)/600;    
-        servo->degrees[servo_no]= degrees;
-        servo->minutes[servo_no]= minutes;      
-        /* 
-         * The PhidgetServo v3.0 is controlled by sending 6 bytes,
-         * 4 * 12 bits for each servo.
-         *
-         * low = lower 8 bits pulse
-         * high = higher 4 bits pulse
-         *
-         * offset     bits
-         * +---+-----------------+
-         * | 0 |      low 0      |
-         * +---+--------+--------+
-         * | 1 | high 1 | high 0 |
-         * +---+--------+--------+
-         * | 2 |      low 1      |
-         * +---+-----------------+
-         * | 3 |      low 2      |
-         * +---+--------+--------+
-         * | 4 | high 3 | high 2 |
-         * +---+--------+--------+
-         * | 5 |      low 3      |
-         * +---+-----------------+
-         */
-        buffer[0] = servo->pulse[0] & 0xff;
-        buffer[1] = (servo->pulse[0] >> 8 & 0x0f)
-            | (servo->pulse[1] >> 4 & 0xf0);
-        buffer[2] = servo->pulse[1] & 0xff;
-        buffer[3] = servo->pulse[2] & 0xff;
-        buffer[4] = (servo->pulse[2] >> 8 & 0x0f)
-            | (servo->pulse[3] >> 4 & 0xf0);
-        buffer[5] = servo->pulse[3] & 0xff;
-        dev_dbg(&servo->udev->dev,
-                "data: %02x %02x %02x %02x %02x %02x\n",
-                buffer[0], buffer[1], buffer[2],
-                buffer[3], buffer[4], buffer[5]);
-        retval = usb_control_msg(servo->udev,
-                                 usb_sndctrlpipe(servo->udev, 0),
-                                 0x09, 0x21, 0x0200, 0x0000, buffer, 6, 2000);
-        kfree(buffer);
-        return retval;
-}
-static int
-change_position_v20(struct phidget_servo *servo, int servo_no, int degrees,
-                                                                int minutes)
-{
-        int retval;
-        unsigned char *buffer;
-        if (degrees < -23 || degrees > 278)
-                return -EINVAL;
-        buffer = kmalloc(2, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(&servo->udev->dev, "%s - out of memory\n",
-                        __func__);
-                return -ENOMEM;
-        }
-        /*
-         * angle = 0 - 180 degrees
-         * pulse = angle + 23
-         */
-        servo->pulse[servo_no]= degrees + 23;
-        servo->degrees[servo_no]= degrees;
-        servo->minutes[servo_no]= 0;
-        /*
-         * The PhidgetServo v2.0 is controlled by sending two bytes. The
-         * first byte is the servo number xor'ed with 2:
-         *
-         * servo 0 = 2
-         * servo 1 = 3
-         * servo 2 = 0
-         * servo 3 = 1
-         *
-         * The second byte is the position.
-         */
-        buffer[0] = servo_no ^ 2;
-        buffer[1] = servo->pulse[servo_no];
-        dev_dbg(&servo->udev->dev, "data: %02x %02x\n", buffer[0], buffer[1]);
-        retval = usb_control_msg(servo->udev,
-                                 usb_sndctrlpipe(servo->udev, 0),
-                                 0x09, 0x21, 0x0200, 0x0000, buffer, 2, 2000);
-        kfree(buffer);
-        return retval;
-}
-#define show_set(value) \
-static ssize_t set_servo##value (struct device *dev,                    \
-                                        struct device_attribute *attr,  \
-                                        const char *buf, size_t count)  \
-{                                                                       \
-        int degrees, minutes, retval;                                   \
-        struct phidget_servo *servo = dev_get_drvdata(dev);             \
-                                                                        \
-        minutes = 0;                                                    \
-        /* must at least convert degrees */                             \
-        if (sscanf(buf, "%d.%d", &degrees, &minutes) < 1) {             \
-                return -EINVAL;                                         \
-        }                                                               \
-                                                                        \
-        if (minutes < 0 || minutes > 59)                                \
-                return -EINVAL;                                         \
-                                                                        \
-        if (servo->type & SERVO_VERSION_30)                             \
-                retval = change_position_v30(servo, value, degrees,     \
-                                                        minutes);       \
-        else                                                            \
-                retval = change_position_v20(servo, value, degrees,     \
-                                                        minutes);       \
-                                                                        \
-        return retval < 0 ? retval : count;                             \
-}                                                                       \
-                                                                        \
-static ssize_t show_servo##value (struct device *dev,                   \
-                                        struct device_attribute *attr,  \
-                                        char *buf)                      \
-{                                                                       \
-        struct phidget_servo *servo = dev_get_drvdata(dev);             \
-                                                                        \
-        return sprintf(buf, "%d.%02d\n", servo->degrees[value],         \
-                                servo->minutes[value]);                 \
-}
-#define servo_attr(value)                                               \
-        __ATTR(servo##value, S_IWUGO | S_IRUGO,                         \
-                show_servo##value, set_servo##value)
-show_set(0);
-show_set(1);
-show_set(2);
-show_set(3);
-static struct device_attribute dev_attrs[] = {
-        servo_attr(0), servo_attr(1), servo_attr(2), servo_attr(3)
-};
-static int
-servo_probe(struct usb_interface *interface, const struct usb_device_id *id)
-{
-        struct usb_device *udev = interface_to_usbdev(interface);
-        struct phidget_servo *dev;
-        int bit, value, rc;
-        int servo_count, i;
-        dev = kzalloc(sizeof (struct phidget_servo), GFP_KERNEL);
-        if (dev == NULL) {
-                dev_err(&interface->dev, "%s - out of memory\n", __func__);
-                rc = -ENOMEM;
-                goto out;
-        }
-        dev->udev = usb_get_dev(udev);
-        dev->type = id->driver_info;
-        dev->dev_no = -1;
-        usb_set_intfdata(interface, dev);
-        do {
-                bit = find_first_zero_bit(&device_no, sizeof(device_no));
-                value = test_and_set_bit(bit, &device_no);
-        } while (value);
-        dev->dev_no = bit;
-        dev->dev = device_create(phidget_class, &dev->udev->dev, MKDEV(0, 0),
-                                 dev, "servo%d", dev->dev_no);
-        if (IS_ERR(dev->dev)) {
-                rc = PTR_ERR(dev->dev);
-                dev->dev = NULL;
-                goto out;
-        }
-        servo_count = dev->type & SERVO_COUNT_QUAD ? 4 : 1;
-        for (i=0; i<servo_count; i++) {
-                rc = device_create_file(dev->dev, &dev_attrs[i]);
-                if (rc)
-                        goto out2;
-        }
-        dev_info(&interface->dev, "USB %d-Motor PhidgetServo v%d.0 attached\n",
-                servo_count, dev->type & SERVO_VERSION_30 ? 3 : 2);
-        if (!(dev->type & SERVO_VERSION_30))
-                dev_info(&interface->dev,
-                         "WARNING: v2.0 not tested! Please report if it works.\n");
-        return 0;
-out2:
-        while (i-- > 0)
-                device_remove_file(dev->dev, &dev_attrs[i]);
-out:
-        if (dev) {
-                if (dev->dev)
-                        device_unregister(dev->dev);
-                if (dev->dev_no >= 0)
-                        clear_bit(dev->dev_no, &device_no);
-                kfree(dev);
-        }
-        return rc;
-}
-static void
-servo_disconnect(struct usb_interface *interface)
-{
-        struct phidget_servo *dev;
-        int servo_count, i;
-        dev = usb_get_intfdata(interface);
-        usb_set_intfdata(interface, NULL);
-        if (!dev)
-                return;
-        servo_count = dev->type & SERVO_COUNT_QUAD ? 4 : 1;
-        for (i=0; i<servo_count; i++)
-                device_remove_file(dev->dev, &dev_attrs[i]);
-        device_unregister(dev->dev);
-        usb_put_dev(dev->udev);
-        dev_info(&interface->dev, "USB %d-Motor PhidgetServo v%d.0 detached\n",
-                servo_count, dev->type & SERVO_VERSION_30 ? 3 : 2);
-        clear_bit(dev->dev_no, &device_no);
-        kfree(dev);
-}
-static struct usb_driver servo_driver = {
-        .name = "phidgetservo",
-        .probe = servo_probe,
-        .disconnect = servo_disconnect,
-        .id_table = id_table
-};
-static int __init
-phidget_servo_init(void)
-{
-        int retval;
-        retval = usb_register(&servo_driver);
-        if (retval)
-                err("usb_register failed. Error number %d", retval);
-        return retval;
-}
-static void __exit
-phidget_servo_exit(void)
-{
-        usb_deregister(&servo_driver);
-}
-module_init(phidget_servo_init);
-module_exit(phidget_servo_exit);
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 4cf27c72423e..f8d9045d668a 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -37,10 +37,13 @@
 #define MON_IOCX_GET   _IOW(MON_IOC_MAGIC, 6, struct mon_bin_get)
 #define MON_IOCX_MFETCH _IOWR(MON_IOC_MAGIC, 7, struct mon_bin_mfetch)
 #define MON_IOCH_MFLUSH _IO(MON_IOC_MAGIC, 8)
+/* #9 was MON_IOCT_SETAPI */
+#define MON_IOCX_GETX   _IOW(MON_IOC_MAGIC, 10, struct mon_bin_get)
 #ifdef CONFIG_COMPAT
 #define MON_IOCX_GET32 _IOW(MON_IOC_MAGIC, 6, struct mon_bin_get32)
 #define MON_IOCX_MFETCH32 _IOWR(MON_IOC_MAGIC, 7, struct mon_bin_mfetch32)
+#define MON_IOCX_GETX32   _IOW(MON_IOC_MAGIC, 10, struct mon_bin_get32)
 #endif
 /*
@@ -92,7 +95,29 @@ struct mon_bin_hdr {
        int status;
        unsigned int len_urb;   /* Length of data (submitted or actual) */
        unsigned int len_cap;   /* Delivered length */
-        unsigned char setup[SETUP_LEN]; /* Only for Control S-type */
+        union {
+                unsigned char setup[SETUP_LEN]; /* Only for Control S-type */
+                struct iso_rec {
+                        int error_count;
+                        int numdesc;
+                } iso;
+        } s;
+        int interval;
+        int start_frame;
+        unsigned int xfer_flags;
+        unsigned int ndesc;     /* Actual number of ISO descriptors */
+};
+/*
+ * ISO vector, packed into the head of data stream.
+ * This has to take 16 bytes to make sure that the end of buffer
+ * wrap is not happening in the middle of a descriptor.
+ */
+struct mon_bin_isodesc {
+        int          iso_status;
+        unsigned int iso_off;
+        unsigned int iso_len;
+        u32 _pad;
 };
 /* per file statistic */
@@ -102,7 +127,7 @@ struct mon_bin_stats {
 };
 struct mon_bin_get {
-        struct mon_bin_hdr __user *hdr; /* Only 48 bytes, not 64. */
+        struct mon_bin_hdr __user *hdr; /* Can be 48 bytes or 64. */
        void __user *data;
        size_t alloc;           /* Length of data (can be zero) */
 };
@@ -131,6 +156,11 @@ struct mon_bin_mfetch32 {
 #define PKT_ALIGN   64
 #define PKT_SIZE    64
+#define PKT_SZ_API0 48  /* API 0 (2.6.20) size */
+#define PKT_SZ_API1 64  /* API 1 size: extra fields */
+#define ISODESC_MAX   128       /* Same number as usbfs allows, 2048 bytes. */
 /* max number of USB bus supported */
 #define MON_BIN_MAX_MINOR 128
@@ -360,12 +390,8 @@ static inline char mon_bin_get_setup(unsigned char *setupb,
    const struct urb *urb, char ev_type)
 {
-        if (!usb_endpoint_xfer_control(&urb->ep->desc) || ev_type != 'S')
-                return '-';
        if (urb->setup_packet == NULL)
                return 'Z';
        memcpy(setupb, urb->setup_packet, SETUP_LEN);
        return 0;
 }
@@ -387,6 +413,26 @@ static char mon_bin_get_data(const struct mon_reader_bin *rp,
        return 0;
 }
+static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
+    unsigned int offset, struct urb *urb, char ev_type, unsigned int ndesc)
+{
+        struct mon_bin_isodesc *dp;
+        struct usb_iso_packet_descriptor *fp;
+        fp = urb->iso_frame_desc;
+        while (ndesc-- != 0) {
+                dp = (struct mon_bin_isodesc *)
+                    (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
+                dp->iso_status = fp->status;
+                dp->iso_off = fp->offset;
+                dp->iso_len = (ev_type == 'S') ? fp->length : fp->actual_length;
+                dp->_pad = 0;
+                if ((offset += sizeof(struct mon_bin_isodesc)) >= rp->b_size)
+                        offset = 0;
+                fp++;
+        }
+}
 static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
    char ev_type, int status)
 {
@@ -396,6 +442,7 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
        unsigned int urb_length;
        unsigned int offset;
        unsigned int length;
+        unsigned int ndesc, lendesc;
        unsigned char dir;
        struct mon_bin_hdr *ep;
        char data_tag = 0;
@@ -407,6 +454,19 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
        /*
         * Find the maximum allowable length, then allocate space.
         */
+        if (usb_endpoint_xfer_isoc(epd)) {
+                if (urb->number_of_packets < 0) {
+                        ndesc = 0;
+                } else if (urb->number_of_packets >= ISODESC_MAX) {
+                        ndesc = ISODESC_MAX;
+                } else {
+                        ndesc = urb->number_of_packets;
+                }
+        } else {
+                ndesc = 0;
+        }
+        lendesc = ndesc*sizeof(struct mon_bin_isodesc);
        urb_length = (ev_type == 'S') ?
            urb->transfer_buffer_length : urb->actual_length;
        length = urb_length;
@@ -429,10 +489,12 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
                dir = 0;
        }
-        if (rp->mmap_active)
+        if (rp->mmap_active) {
-                offset = mon_buff_area_alloc_contiguous(rp, length + PKT_SIZE);
+                offset = mon_buff_area_alloc_contiguous(rp,
-        else
+                                                 length + PKT_SIZE + lendesc);
-                offset = mon_buff_area_alloc(rp, length + PKT_SIZE);
+        } else {
+                offset = mon_buff_area_alloc(rp, length + PKT_SIZE + lendesc);
+        }
        if (offset == ~0) {
                rp->cnt_lost++;
                spin_unlock_irqrestore(&rp->b_lock, flags);
@@ -456,9 +518,31 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
        ep->ts_usec = ts.tv_usec;
        ep->status = status;
        ep->len_urb = urb_length;
-        ep->len_cap = length;
+        ep->len_cap = length + lendesc;
+        ep->xfer_flags = urb->transfer_flags;
+        if (usb_endpoint_xfer_int(epd)) {
+                ep->interval = urb->interval;
+        } else if (usb_endpoint_xfer_isoc(epd)) {
+                ep->interval = urb->interval;
+                ep->start_frame = urb->start_frame;
+                ep->s.iso.error_count = urb->error_count;
+                ep->s.iso.numdesc = urb->number_of_packets;
+        }
+        if (usb_endpoint_xfer_control(epd) && ev_type == 'S') {
+                ep->flag_setup = mon_bin_get_setup(ep->s.setup, urb, ev_type);
+        } else {
+                ep->flag_setup = '-';
+        }
+        if (ndesc != 0) {
+                ep->ndesc = ndesc;
+                mon_bin_get_isodesc(rp, offset, urb, ev_type, ndesc);
+                if ((offset += lendesc) >= rp->b_size)
+                        offset -= rp->b_size;
+        }
-        ep->flag_setup = mon_bin_get_setup(ep->setup, urb, ev_type);
        if (length != 0) {
                ep->flag_data = mon_bin_get_data(rp, offset, urb, length);
                if (ep->flag_data != 0) {       /* Yes, it's 0x00, not '0' */
@@ -592,7 +676,8 @@ err_alloc:
 * Returns zero or error.
 */
 static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
-    struct mon_bin_hdr __user *hdr, void __user *data, unsigned int nbytes)
+    struct mon_bin_hdr __user *hdr, unsigned int hdrbytes,
+    void __user *data, unsigned int nbytes)
 {
        unsigned long flags;
        struct mon_bin_hdr *ep;
@@ -609,7 +694,7 @@ static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
        ep = MON_OFF2HDR(rp, rp->b_out);
-        if (copy_to_user(hdr, ep, sizeof(struct mon_bin_hdr))) {
+        if (copy_to_user(hdr, ep, hdrbytes)) {
                mutex_unlock(&rp->fetch_lock);
                return -EFAULT;
        }
@@ -657,6 +742,7 @@ static ssize_t mon_bin_read(struct file *file, char __user *buf,
    size_t nbytes, loff_t *ppos)
 {
        struct mon_reader_bin *rp = file->private_data;
+        unsigned int hdrbytes = PKT_SZ_API0;
        unsigned long flags;
        struct mon_bin_hdr *ep;
        unsigned int offset;
@@ -674,8 +760,8 @@ static ssize_t mon_bin_read(struct file *file, char __user *buf,
        ep = MON_OFF2HDR(rp, rp->b_out);
-        if (rp->b_read < sizeof(struct mon_bin_hdr)) {
+        if (rp->b_read < hdrbytes) {
-                step_len = min(nbytes, sizeof(struct mon_bin_hdr) - rp->b_read);
+                step_len = min(nbytes, (size_t)(hdrbytes - rp->b_read));
                ptr = ((char *)ep) + rp->b_read;
                if (step_len && copy_to_user(buf, ptr, step_len)) {
                        mutex_unlock(&rp->fetch_lock);
@@ -687,13 +773,13 @@ static ssize_t mon_bin_read(struct file *file, char __user *buf,
                done += step_len;
        }
-        if (rp->b_read >= sizeof(struct mon_bin_hdr)) {
+        if (rp->b_read >= hdrbytes) {
                step_len = ep->len_cap;
-                step_len -= rp->b_read - sizeof(struct mon_bin_hdr);
+                step_len -= rp->b_read - hdrbytes;
                if (step_len > nbytes)
                        step_len = nbytes;
                offset = rp->b_out + PKT_SIZE;
-                offset += rp->b_read - sizeof(struct mon_bin_hdr);
+                offset += rp->b_read - hdrbytes;
                if (offset >= rp->b_size)
                        offset -= rp->b_size;
                if (copy_from_buf(rp, offset, buf, step_len)) {
@@ -709,7 +795,7 @@ static ssize_t mon_bin_read(struct file *file, char __user *buf,
        /*
         * Check if whole packet was read, and if so, jump to the next one.
         */
-        if (rp->b_read >= sizeof(struct mon_bin_hdr) + ep->len_cap) {
+        if (rp->b_read >= hdrbytes + ep->len_cap) {
                spin_lock_irqsave(&rp->b_lock, flags);
                mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
                spin_unlock_irqrestore(&rp->b_lock, flags);
@@ -908,6 +994,7 @@ static int mon_bin_ioctl(struct inode *inode, struct file *file,
                break;
        case MON_IOCX_GET:
+        case MON_IOCX_GETX:
                {
                struct mon_bin_get getb;
@@ -917,8 +1004,9 @@ static int mon_bin_ioctl(struct inode *inode, struct file *file,
                if (getb.alloc > 0x10000000)    /* Want to cast to u32 */
                        return -EINVAL;
-                ret = mon_bin_get_event(file, rp,
+                ret = mon_bin_get_event(file, rp, getb.hdr,
-                          getb.hdr, getb.data, (unsigned int)getb.alloc);
+                    (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1,
+                    getb.data, (unsigned int)getb.alloc);
                }
                break;
@@ -984,16 +1072,18 @@ static long mon_bin_compat_ioctl(struct file *file,
        switch (cmd) {
-        case MON_IOCX_GET32: {
+        case MON_IOCX_GET32:
+        case MON_IOCX_GETX32:
+                {
                struct mon_bin_get32 getb;
                if (copy_from_user(&getb, (void __user *)arg,
                                            sizeof(struct mon_bin_get32)))
                        return -EFAULT;
-                ret = mon_bin_get_event(file, rp,
+                ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32),
-                    compat_ptr(getb.hdr32), compat_ptr(getb.data32),
+                    (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1,
-                    getb.alloc32);
+                    compat_ptr(getb.data32), getb.alloc32);
                if (ret < 0)
                        return ret;
                }
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 9985db08e7db..b66e8544d8b9 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -20,8 +20,8 @@ config USB_MUSB_HDRC
          it's being used with, including the USB peripheral role,
          or the USB host role, or both.
-          Texas Instruments parts using this IP include DaVinci 644x,
+          Texas Instruments familiies using this IP include DaVinci
-          OMAP 243x, OMAP 343x, and TUSB 6010.
+          (35x, 644x ...), OMAP 243x, OMAP 3, and TUSB 6010.
          Analog Devices parts using this IP include Blackfin BF54x,
          BF525 and BF527.
@@ -40,7 +40,7 @@ config USB_MUSB_SOC
        default y if (BF54x && !BF544)
        default y if (BF52x && !BF522 && !BF523)
-comment "DaVinci 644x USB support"
+comment "DaVinci 35x and 644x USB support"
        depends on USB_MUSB_HDRC && ARCH_DAVINCI
 comment "OMAP 243x high speed USB support"
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 2dc7606f319c..10d11ab113ab 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -48,6 +48,9 @@
 #include "cppi_dma.h"
+#define USB_PHY_CTRL    IO_ADDRESS(USBPHY_CTL_PADDR)
+#define DM355_DEEPSLEEP IO_ADDRESS(DM355_DEEPSLEEP_PADDR)
 /* REVISIT (PM) we should be able to keep the PHY in low power mode most
 * of the time (24 MHZ oscillator and PLL off, etc) by setting POWER.D0
 * and, when in host mode, autosuspending idle root ports... PHYPLLON
@@ -56,20 +59,26 @@
 static inline void phy_on(void)
 {
-        /* start the on-chip PHY and its PLL */
+        u32     phy_ctrl = __raw_readl(USB_PHY_CTRL);
-        __raw_writel(USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON,
-                        (void __force __iomem *) IO_ADDRESS(USBPHY_CTL_PADDR));
+        /* power everything up; start the on-chip PHY and its PLL */
-        while ((__raw_readl((void __force __iomem *)
+        phy_ctrl &= ~(USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN);
-                                IO_ADDRESS(USBPHY_CTL_PADDR))
+        phy_ctrl |= USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON;
-                        & USBPHY_PHYCLKGD) == 0)
+        __raw_writel(phy_ctrl, USB_PHY_CTRL);
+        /* wait for PLL to lock before proceeding */
+        while ((__raw_readl(USB_PHY_CTRL) & USBPHY_PHYCLKGD) == 0)
                cpu_relax();
 }
 static inline void phy_off(void)
 {
-        /* powerdown the on-chip PHY and its oscillator */
+        u32     phy_ctrl = __raw_readl(USB_PHY_CTRL);
-        __raw_writel(USBPHY_OSCPDWN | USBPHY_PHYPDWN, (void __force __iomem *)
-                        IO_ADDRESS(USBPHY_CTL_PADDR));
+        /* powerdown the on-chip PHY, its PLL, and the OTG block */
+        phy_ctrl &= ~(USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON);
+        phy_ctrl |= USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN;
+        __raw_writel(phy_ctrl, USB_PHY_CTRL);
 }
 static int dma_off = 1;
@@ -126,10 +135,6 @@ void musb_platform_disable(struct musb *musb)
 }
-/* REVISIT it's not clear whether DaVinci can support full OTG.  */
-static int vbus_state = -1;
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
 #define portstate(stmt)         stmt
 #else
@@ -137,10 +142,19 @@ static int vbus_state = -1;
 #endif
-/* VBUS SWITCHING IS BOARD-SPECIFIC */
+/*
+ * VBUS SWITCHING IS BOARD-SPECIFIC ... at least for the DM6446 EVM,
+ * which doesn't wire DRVVBUS to the FET that switches it.  Unclear
+ * if that's a problem with the DM6446 chip or just with that board.
+ *
+ * In either case, the DM355 EVM automates DRVVBUS the normal way,
+ * when J10 is out, and TI documents it as handling OTG.
+ */
 #ifdef CONFIG_MACH_DAVINCI_EVM
+static int vbus_state = -1;
 /* I2C operations are always synchronous, and require a task context.
 * With unloaded systems, using the shared workqueue seems to suffice
 * to satisfy the 100msec A_WAIT_VRISE timeout...
@@ -150,12 +164,12 @@ static void evm_deferred_drvvbus(struct work_struct *ignored)
        gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
        vbus_state = !vbus_state;
 }
-static DECLARE_WORK(evm_vbus_work, evm_deferred_drvvbus);
 #endif  /* EVM */
 static void davinci_source_power(struct musb *musb, int is_on, int immediate)
 {
+#ifdef CONFIG_MACH_DAVINCI_EVM
        if (is_on)
                is_on = 1;
@@ -163,16 +177,17 @@ static void davinci_source_power(struct musb *musb, int is_on, int immediate)
                return;
        vbus_state = !is_on;            /* 0/1 vs "-1 == unknown/init" */
-#ifdef CONFIG_MACH_DAVINCI_EVM
        if (machine_is_davinci_evm()) {
+                static DECLARE_WORK(evm_vbus_work, evm_deferred_drvvbus);
                if (immediate)
                        gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
                else
                        schedule_work(&evm_vbus_work);
        }
-#endif
        if (immediate)
                vbus_state = is_on;
+#endif
 }
 static void davinci_set_vbus(struct musb *musb, int is_on)
@@ -391,6 +406,17 @@ int __init musb_platform_init(struct musb *musb)
        musb->board_set_vbus = davinci_set_vbus;
        davinci_source_power(musb, 0, 1);
+        /* dm355 EVM swaps D+/D- for signal integrity, and
+         * is clocked from the main 24 MHz crystal.
+         */
+        if (machine_is_davinci_dm355_evm()) {
+                u32     phy_ctrl = __raw_readl(USB_PHY_CTRL);
+                phy_ctrl &= ~(3 << 9);
+                phy_ctrl |= USBPHY_DATAPOL;
+                __raw_writel(phy_ctrl, USB_PHY_CTRL);
+        }
        /* reset the controller */
        musb_writel(tibase, DAVINCI_USB_CTRL_REG, 0x1);
@@ -401,8 +427,7 @@ int __init musb_platform_init(struct musb *musb)
        /* NOTE:  irqs are in mixed mode, not bypass to pure-musb */
        pr_debug("DaVinci OTG revision %08x phy %03x control %02x\n",
-                revision, __raw_readl((void __force __iomem *)
+                revision, __raw_readl(USB_PHY_CTRL),
-                                IO_ADDRESS(USBPHY_CTL_PADDR)),
                musb_readb(tibase, DAVINCI_USB_CTRL_REG));
        musb->isr = davinci_interrupt;
diff --git a/drivers/usb/musb/davinci.h b/drivers/usb/musb/davinci.h
index 7fb6238e270f..046c84433cad 100644
--- a/drivers/usb/musb/davinci.h
+++ b/drivers/usb/musb/davinci.h
@@ -15,14 +15,21 @@
 */
 /* Integrated highspeed/otg PHY */
-#define USBPHY_CTL_PADDR        (DAVINCI_SYSTEM_MODULE_BASE + 0x34)
+#define USBPHY_CTL_PADDR        (DAVINCI_SYSTEM_MODULE_BASE + 0x34)
-#define USBPHY_PHYCLKGD         (1 << 8)
+#define USBPHY_DATAPOL          BIT(11) /* (dm355) switch D+/D- */
-#define USBPHY_SESNDEN          (1 << 7)        /* v(sess_end) comparator */
+#define USBPHY_PHYCLKGD         BIT(8)
-#define USBPHY_VBDTCTEN         (1 << 6)        /* v(bus) comparator */
+#define USBPHY_SESNDEN          BIT(7)  /* v(sess_end) comparator */
-#define USBPHY_PHYPLLON         (1 << 4)        /* override pll suspend */
+#define USBPHY_VBDTCTEN         BIT(6)  /* v(bus) comparator */
-#define USBPHY_CLKO1SEL         (1 << 3)
+#define USBPHY_VBUSSENS         BIT(5)  /* (dm355,ro) is vbus > 0.5V */
-#define USBPHY_OSCPDWN          (1 << 2)
+#define USBPHY_PHYPLLON         BIT(4)  /* override pll suspend */
-#define USBPHY_PHYPDWN          (1 << 0)
+#define USBPHY_CLKO1SEL         BIT(3)
+#define USBPHY_OSCPDWN          BIT(2)
+#define USBPHY_OTGPDWN          BIT(1)
+#define USBPHY_PHYPDWN          BIT(0)
+#define DM355_DEEPSLEEP_PADDR   (DAVINCI_SYSTEM_MODULE_BASE + 0x48)
+#define DRVVBUS_FORCE           BIT(2)
+#define DRVVBUS_OVERRIDE        BIT(1)
 /* For now include usb OTG module registers here */
 #define DAVINCI_USB_VERSION_REG         0x00
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index af77e4659006..338cd1611ab3 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -769,7 +769,7 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb,
                case OTG_STATE_A_SUSPEND:
                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
                        musb_root_disconnect(musb);
-                        if (musb->a_wait_bcon != 0)
+                        if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
                                musb_platform_try_idle(musb, jiffies
                                        + msecs_to_jiffies(musb->a_wait_bcon));
                        break;
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 630946a2d9fc..efb39b5e55b5 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -331,7 +331,6 @@ struct musb {
        struct list_head        control;        /* of musb_qh */
        struct list_head        in_bulk;        /* of musb_qh */
        struct list_head        out_bulk;       /* of musb_qh */
-        struct musb_qh          *periodic[32];  /* tree of interrupt+iso */
 #endif
        /* called with IRQs blocked; ON/nonzero implies starting a session,
@@ -479,10 +478,11 @@ static inline void musb_configure_ep0(struct musb *musb)
 static inline int musb_read_fifosize(struct musb *musb,
                struct musb_hw_ep *hw_ep, u8 epnum)
 {
+        void *mbase = musb->mregs;
        u8 reg = 0;
        /* read from core using indexed model */
-        reg = musb_readb(hw_ep->regs, 0x10 + MUSB_FIFOSIZE);
+        reg = musb_readb(mbase, MUSB_EP_OFFSET(epnum, MUSB_FIFOSIZE));
        /* 0's returned when no more endpoints */
        if (!reg)
                return -ENODEV;
@@ -509,6 +509,7 @@ static inline void musb_configure_ep0(struct musb *musb)
 {
        musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
        musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
+        musb->endpoints[0].is_shared_fifo = true;
 }
 #endif /* CONFIG_BLACKFIN */
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 6dbbd0786a6a..499c431a6d62 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -64,11 +64,8 @@
 *
 * - DMA (Mentor/OMAP) ...has at least toggle update problems
 *
- * - Still no traffic scheduling code to make NAKing for bulk or control
+ * - [23-feb-2009] minimal traffic scheduling to avoid bulk RX packet
- *   transfers unable to starve other requests; or to make efficient use
+ *   starvation ... nothing yet for TX, interrupt, or bulk.
- *   of hardware with periodic transfers.  (Note that network drivers
- *   commonly post bulk reads that stay pending for a long time; these
- *   would make very visible trouble.)
 *
 * - Not tested with HNP, but some SRP paths seem to behave.
 *
@@ -88,11 +85,8 @@
 *
 * CONTROL transfers all go through ep0.  BULK ones go through dedicated IN
 * and OUT endpoints ... hardware is dedicated for those "async" queue(s).
- *
 * (Yes, bulk _could_ use more of the endpoints than that, and would even
- * benefit from it ... one remote device may easily be NAKing while others
+ * benefit from it.)
- * need to perform transfers in that same direction.  The same thing could
- * be done in software though, assuming dma cooperates.)
 *
 * INTERUPPT and ISOCHRONOUS transfers are scheduled to the other endpoints.
 * So far that scheduling is both dumb and optimistic:  the endpoint will be
@@ -201,8 +195,9 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
                len = urb->iso_frame_desc[0].length;
                break;
        default:                /* bulk, interrupt */
-                buf = urb->transfer_buffer;
+                /* actual_length may be nonzero on retry paths */
-                len = urb->transfer_buffer_length;
+                buf = urb->transfer_buffer + urb->actual_length;
+                len = urb->transfer_buffer_length - urb->actual_length;
        }
        DBG(4, "qh %p urb %p dev%d ep%d%s%s, hw_ep %d, %p/%d\n",
@@ -395,7 +390,6 @@ musb_giveback(struct musb_qh *qh, struct urb *urb, int status)
                         * de-allocated if it's tracked and allocated;
                         * and where we'd update the schedule tree...
                         */
-                        musb->periodic[ep->epnum] = NULL;
                        kfree(qh);
                        qh = NULL;
                        break;
@@ -1045,7 +1039,8 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
                /* NOTE:  this code path would be a good place to PAUSE a
                 * control transfer, if another one is queued, so that
-                 * ep0 is more likely to stay busy.
+                 * ep0 is more likely to stay busy.  That's already done
+                 * for bulk RX transfers.
                 *
                 * if (qh->ring.next != &musb->control), then
                 * we have a candidate... NAKing is *NOT* an error
@@ -1197,6 +1192,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                /* NOTE:  this code path would be a good place to PAUSE a
                 * transfer, if there's some other (nonperiodic) tx urb
                 * that could use this fifo.  (dma complicates it...)
+                 * That's already done for bulk RX transfers.
                 *
                 * if (bulk && qh->ring.next != &musb->out_bulk), then
                 * we have a candidate... NAKing is *NOT* an error
@@ -1358,6 +1354,50 @@ finish:
 #endif
+/* Schedule next QH from musb->in_bulk and move the current qh to
+ * the end; avoids starvation for other endpoints.
+ */
+static void musb_bulk_rx_nak_timeout(struct musb *musb, struct musb_hw_ep *ep)
+{
+        struct dma_channel      *dma;
+        struct urb              *urb;
+        void __iomem            *mbase = musb->mregs;
+        void __iomem            *epio = ep->regs;
+        struct musb_qh          *cur_qh, *next_qh;
+        u16                     rx_csr;
+        musb_ep_select(mbase, ep->epnum);
+        dma = is_dma_capable() ? ep->rx_channel : NULL;
+        /* clear nak timeout bit */
+        rx_csr = musb_readw(epio, MUSB_RXCSR);
+        rx_csr |= MUSB_RXCSR_H_WZC_BITS;
+        rx_csr &= ~MUSB_RXCSR_DATAERROR;
+        musb_writew(epio, MUSB_RXCSR, rx_csr);
+        cur_qh = first_qh(&musb->in_bulk);
+        if (cur_qh) {
+                urb = next_urb(cur_qh);
+                if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
+                        dma->status = MUSB_DMA_STATUS_CORE_ABORT;
+                        musb->dma_controller->channel_abort(dma);
+                        urb->actual_length += dma->actual_len;
+                        dma->actual_len = 0L;
+                }
+                musb_save_toggle(ep, 1, urb);
+                /* move cur_qh to end of queue */
+                list_move_tail(&cur_qh->ring, &musb->in_bulk);
+                /* get the next qh from musb->in_bulk */
+                next_qh = first_qh(&musb->in_bulk);
+                /* set rx_reinit and schedule the next qh */
+                ep->rx_reinit = 1;
+                musb_start_urb(musb, 1, next_qh);
+        }
+}
 /*
 * Service an RX interrupt for the given IN endpoint; docs cover bulk, iso,
 * and high-bandwidth IN transfer cases.
@@ -1421,18 +1461,26 @@ void musb_host_rx(struct musb *musb, u8 epnum)
        } else if (rx_csr & MUSB_RXCSR_DATAERROR) {
                if (USB_ENDPOINT_XFER_ISOC != qh->type) {
-                        /* NOTE this code path would be a good place to PAUSE a
+                        DBG(6, "RX end %d NAK timeout\n", epnum);
-                         * transfer, if there's some other (nonperiodic) rx urb
-                         * that could use this fifo.  (dma complicates it...)
+                        /* NOTE: NAKing is *NOT* an error, so we want to
+                         * continue.  Except ... if there's a request for
+                         * another QH, use that instead of starving it.
                         *
-                         * if (bulk && qh->ring.next != &musb->in_bulk), then
+                         * Devices like Ethernet and serial adapters keep
-                         * we have a candidate... NAKing is *NOT* an error
+                         * reads posted at all times, which will starve
+                         * other devices without this logic.
                         */
-                        DBG(6, "RX end %d NAK timeout\n", epnum);
+                        if (usb_pipebulk(urb->pipe)
+                                        && qh->mux == 1
+                                        && !list_is_singular(&musb->in_bulk)) {
+                                musb_bulk_rx_nak_timeout(musb, hw_ep);
+                                return;
+                        }
                        musb_ep_select(mbase, epnum);
-                        musb_writew(epio, MUSB_RXCSR,
+                        rx_csr |= MUSB_RXCSR_H_WZC_BITS;
-                                        MUSB_RXCSR_H_WZC_BITS
+                        rx_csr &= ~MUSB_RXCSR_DATAERROR;
-                                        | MUSB_RXCSR_H_REQPKT);
+                        musb_writew(epio, MUSB_RXCSR, rx_csr);
                        goto finish;
                } else {
@@ -1711,31 +1759,27 @@ static int musb_schedule(
        /* else, periodic transfers get muxed to other endpoints */
-        /* FIXME this doesn't consider direction, so it can only
+        /*
-         * work for one half of the endpoint hardware, and assumes
+         * We know this qh hasn't been scheduled, so all we need to do
-         * the previous cases handled all non-shared endpoints...
-         */
-        /* we know this qh hasn't been scheduled, so all we need to do
         * is choose which hardware endpoint to put it on ...
         *
         * REVISIT what we really want here is a regular schedule tree
-         * like e.g. OHCI uses, but for now musb->periodic is just an
+         * like e.g. OHCI uses.
-         * array of the _single_ logical endpoint associated with a
-         * given physical one (identity mapping logical->physical).
-         *
-         * that simplistic approach makes TT scheduling a lot simpler;
-         * there is none, and thus none of its complexity...
         */
        best_diff = 4096;
        best_end = -1;
-        for (epnum = 1; epnum < musb->nr_endpoints; epnum++) {
+        for (epnum = 1, hw_ep = musb->endpoints + 1;
+                        epnum < musb->nr_endpoints;
+                        epnum++, hw_ep++) {
                int     diff;
-                if (musb->periodic[epnum])
+                if (is_in || hw_ep->is_shared_fifo) {
+                        if (hw_ep->in_qh  != NULL)
+                                continue;
+                } else  if (hw_ep->out_qh != NULL)
                        continue;
-                hw_ep = &musb->endpoints[epnum];
                if (hw_ep == musb->bulk_ep)
                        continue;
@@ -1756,6 +1800,17 @@ static int musb_schedule(
                        head = &musb->in_bulk;
                else
                        head = &musb->out_bulk;
+                /* Enable bulk RX NAK timeout scheme when bulk requests are
+                 * multiplexed.  This scheme doen't work in high speed to full
+                 * speed scenario as NAK interrupts are not coming from a
+                 * full speed device connected to a high speed device.
+                 * NAK timeout interval is 8 (128 uframe or 16ms) for HS and
+                 * 4 (8 frame or 8ms) for FS device.
+                 */
+                if (is_in && qh->dev)
+                        qh->intv_reg =
+                                (USB_SPEED_HIGH == qh->dev->speed) ? 8 : 4;
                goto success;
        } else if (best_end < 0) {
                return -ENOSPC;
@@ -1764,7 +1819,6 @@ static int musb_schedule(
        idle = 1;
        qh->mux = 0;
        hw_ep = musb->endpoints + best_end;
-        musb->periodic[best_end] = qh;
        DBG(4, "qh %p periodic slot %d\n", qh, best_end);
 success:
        if (head) {
@@ -1888,13 +1942,11 @@ static int musb_urb_enqueue(
                 *
                 * The downside of disabling this is that transfer scheduling
                 * gets VERY unfair for nonperiodic transfers; a misbehaving
-                 * peripheral could make that hurt.  Or for reads, one that's
+                 * peripheral could make that hurt.  That's perfectly normal
-                 * perfectly normal:  network and other drivers keep reads
+                 * for reads from network or serial adapters ... so we have
-                 * posted at all times, having one pending for a week should
+                 * partial NAKlimit support for bulk RX.
-                 * be perfectly safe.
                 *
-                 * The upside of disabling it is avoidng transfer scheduling
+                 * The upside of disabling it is simpler transfer scheduling.
-                 * code to put this aside for while.
                 */
                interval = 0;
        }
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index e0e9ce584175..bf677acc83db 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -285,7 +285,7 @@ int musb_hub_control(
                desc->bDescLength = 9;
                desc->bDescriptorType = 0x29;
                desc->bNbrPorts = 1;
-                desc->wHubCharacteristics = __constant_cpu_to_le16(
+                desc->wHubCharacteristics = cpu_to_le16(
                                  0x0001        /* per-port power switching */
                                | 0x0010        /* no overcurrent reporting */
                                );
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index ee55b449ffde..aa884d072f0b 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -43,7 +43,7 @@ config ISP1301_OMAP
 config TWL4030_USB
        tristate "TWL4030 USB Transceiver Driver"
-        depends on TWL4030_CORE
+        depends on TWL4030_CORE && REGULATOR_TWL4030
        select USB_OTG_UTILS
        help
          Enable this to support the USB OTG transceiver on TWL4030
@@ -51,4 +51,12 @@ config TWL4030_USB
          This transceiver supports high and full speed devices plus,
          in host mode, low speed.
+config NOP_USB_XCEIV
+        tristate "NOP USB Transceiver Driver"
+        select USB_OTG_UTILS
+        help
+         this driver is to be used by all the usb transceiver which are either
+         built-in with usb ip or which are autonomous and doesn't require any
+         phy programming such as ISP1x04 etc.
 endif # USB || OTG
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
index d73c7cf5e2f7..208167856529 100644
--- a/drivers/usb/otg/Makefile
+++ b/drivers/usb/otg/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_USB_OTG_UTILS)	+= otg.o
 obj-$(CONFIG_USB_GPIO_VBUS)     += gpio_vbus.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TWL4030_USB)       += twl4030-usb.o
+obj-$(CONFIG_NOP_USB_XCEIV)     += nop-usb-xceiv.o
 ccflags-$(CONFIG_USB_DEBUG)     += -DDEBUG
 ccflags-$(CONFIG_USB_GADGET_DEBUG) += -DDEBUG
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
index 63a6036f04be..1c26c94513e9 100644
--- a/drivers/usb/otg/gpio_vbus.c
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -13,6 +13,7 @@
 #include <linux/gpio.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <linux/workqueue.h>
 #include <linux/regulator/consumer.h>
@@ -34,6 +35,7 @@ struct gpio_vbus_data {
        struct regulator       *vbus_draw;
        int                     vbus_draw_enabled;
        unsigned                mA;
+        struct work_struct      work;
 };
@@ -76,24 +78,26 @@ static void set_vbus_draw(struct gpio_vbus_data *gpio_vbus, unsigned mA)
        gpio_vbus->mA = mA;
 }
-/* VBUS change IRQ handler */
+static int is_vbus_powered(struct gpio_vbus_mach_info *pdata)
-static irqreturn_t gpio_vbus_irq(int irq, void *data)
 {
-        struct platform_device *pdev = data;
+        int vbus;
-        struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
-        struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
-        int gpio, vbus;
        vbus = gpio_get_value(pdata->gpio_vbus);
        if (pdata->gpio_vbus_inverted)
                vbus = !vbus;
-        dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n",
+        return vbus;
-                vbus ? "supplied" : "inactive",
+}
-                gpio_vbus->otg.gadget ? gpio_vbus->otg.gadget->name : "none");
+static void gpio_vbus_work(struct work_struct *work)
+{
+        struct gpio_vbus_data *gpio_vbus =
+                container_of(work, struct gpio_vbus_data, work);
+        struct gpio_vbus_mach_info *pdata = gpio_vbus->dev->platform_data;
+        int gpio;
        if (!gpio_vbus->otg.gadget)
-                return IRQ_HANDLED;
+                return;
        /* Peripheral controllers which manage the pullup themselves won't have
         * gpio_pullup configured here.  If it's configured here, we'll do what
@@ -101,7 +105,7 @@ static irqreturn_t gpio_vbus_irq(int irq, void *data)
         * that may complicate usb_gadget_{,dis}connect() support.
         */
        gpio = pdata->gpio_pullup;
-        if (vbus) {
+        if (is_vbus_powered(pdata)) {
                gpio_vbus->otg.state = OTG_STATE_B_PERIPHERAL;
                usb_gadget_vbus_connect(gpio_vbus->otg.gadget);
@@ -121,6 +125,21 @@ static irqreturn_t gpio_vbus_irq(int irq, void *data)
                usb_gadget_vbus_disconnect(gpio_vbus->otg.gadget);
                gpio_vbus->otg.state = OTG_STATE_B_IDLE;
        }
+}
+/* VBUS change IRQ handler */
+static irqreturn_t gpio_vbus_irq(int irq, void *data)
+{
+        struct platform_device *pdev = data;
+        struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
+        struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
+        dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n",
+                is_vbus_powered(pdata) ? "supplied" : "inactive",
+                gpio_vbus->otg.gadget ? gpio_vbus->otg.gadget->name : "none");
+        if (gpio_vbus->otg.gadget)
+                schedule_work(&gpio_vbus->work);
        return IRQ_HANDLED;
 }
@@ -257,6 +276,7 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
                        irq, err);
                goto err_irq;
        }
+        INIT_WORK(&gpio_vbus->work, gpio_vbus_work);
        /* only active when a gadget is registered */
        err = otg_set_transceiver(&gpio_vbus->otg);
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
new file mode 100644
index 000000000000..4b933f646f2e
--- /dev/null
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -0,0 +1,180 @@
+/*
+ * drivers/usb/otg/nop-usb-xceiv.c
+ *
+ * NOP USB transceiver for all USB transceiver which are either built-in
+ * into USB IP or which are mostly autonomous.
+ *
+ * Copyright (C) 2009 Texas Instruments Inc
+ * Author: Ajay Kumar Gupta <ajay.gupta@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Current status:
+ *      this is to add "nop" transceiver for all those phy which is
+ *      autonomous such as isp1504 etc.
+ */
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/usb/otg.h>
+struct nop_usb_xceiv {
+        struct otg_transceiver  otg;
+        struct device           *dev;
+};
+static u64 nop_xceiv_dmamask = DMA_32BIT_MASK;
+static struct platform_device nop_xceiv_device = {
+        .name           = "nop_usb_xceiv",
+        .id             = -1,
+        .dev = {
+                .dma_mask               = &nop_xceiv_dmamask,
+                .coherent_dma_mask      = DMA_32BIT_MASK,
+                .platform_data          = NULL,
+        },
+};
+void usb_nop_xceiv_register(void)
+{
+        if (platform_device_register(&nop_xceiv_device) < 0) {
+                printk(KERN_ERR "Unable to register usb nop transceiver\n");
+                return;
+        }
+}
+void usb_nop_xceiv_unregister(void)
+{
+        platform_device_unregister(&nop_xceiv_device);
+}
+static inline struct nop_usb_xceiv *xceiv_to_nop(struct otg_transceiver *x)
+{
+        return container_of(x, struct nop_usb_xceiv, otg);
+}
+static int nop_set_suspend(struct otg_transceiver *x, int suspend)
+{
+        return 0;
+}
+static int nop_set_peripheral(struct otg_transceiver *x,
+                struct usb_gadget *gadget)
+{
+        struct nop_usb_xceiv *nop;
+        if (!x)
+                return -ENODEV;
+        nop = xceiv_to_nop(x);
+        if (!gadget) {
+                nop->otg.gadget = NULL;
+                return -ENODEV;
+        }
+        nop->otg.gadget = gadget;
+        nop->otg.state = OTG_STATE_B_IDLE;
+        return 0;
+}
+static int nop_set_host(struct otg_transceiver *x, struct usb_bus *host)
+{
+        struct nop_usb_xceiv *nop;
+        if (!x)
+                return -ENODEV;
+        nop = xceiv_to_nop(x);
+        if (!host) {
+                nop->otg.host = NULL;
+                return -ENODEV;
+        }
+        nop->otg.host = host;
+        return 0;
+}
+static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
+{
+        struct nop_usb_xceiv    *nop;
+        int err;
+        nop = kzalloc(sizeof *nop, GFP_KERNEL);
+        if (!nop)
+                return -ENOMEM;
+        nop->dev                = &pdev->dev;
+        nop->otg.dev            = nop->dev;
+        nop->otg.label          = "nop-xceiv";
+        nop->otg.state          = OTG_STATE_UNDEFINED;
+        nop->otg.set_host       = nop_set_host;
+        nop->otg.set_peripheral = nop_set_peripheral;
+        nop->otg.set_suspend    = nop_set_suspend;
+        err = otg_set_transceiver(&nop->otg);
+        if (err) {
+                dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
+                        err);
+                goto exit;
+        }
+        platform_set_drvdata(pdev, nop);
+        return 0;
+exit:
+        kfree(nop);
+        return err;
+}
+static int __devexit nop_usb_xceiv_remove(struct platform_device *pdev)
+{
+        struct nop_usb_xceiv *nop = platform_get_drvdata(pdev);
+        otg_set_transceiver(NULL);
+        platform_set_drvdata(pdev, NULL);
+        kfree(nop);
+        return 0;
+}
+static struct platform_driver nop_usb_xceiv_driver = {
+        .probe          = nop_usb_xceiv_probe,
+        .remove         = __devexit_p(nop_usb_xceiv_remove),
+        .driver         = {
+                .name   = "nop_usb_xceiv",
+                .owner  = THIS_MODULE,
+        },
+};
+static int __init nop_usb_xceiv_init(void)
+{
+        return platform_driver_register(&nop_usb_xceiv_driver);
+}
+subsys_initcall(nop_usb_xceiv_init);
+static void __exit nop_usb_xceiv_exit(void)
+{
+        platform_driver_unregister(&nop_usb_xceiv_driver);
+}
+module_exit(nop_usb_xceiv_exit);
+MODULE_ALIAS("platform:nop_usb_xceiv");
+MODULE_AUTHOR("Texas Instruments Inc");
+MODULE_DESCRIPTION("NOP USB Transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index 416e4410be02..d9478d0e1c8b 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -34,6 +34,8 @@
 #include <linux/delay.h>
 #include <linux/usb/otg.h>
 #include <linux/i2c/twl4030.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
 /* Register defines */
@@ -246,6 +248,11 @@ struct twl4030_usb {
        struct otg_transceiver  otg;
        struct device           *dev;
+        /* TWL4030 internal USB regulator supplies */
+        struct regulator        *usb1v5;
+        struct regulator        *usb1v8;
+        struct regulator        *usb3v1;
        /* for vbus reporting with irqs disabled */
        spinlock_t              lock;
@@ -434,6 +441,18 @@ static void twl4030_phy_power(struct twl4030_usb *twl, int on)
        pwr = twl4030_usb_read(twl, PHY_PWR_CTRL);
        if (on) {
+                regulator_enable(twl->usb3v1);
+                regulator_enable(twl->usb1v8);
+                /*
+                 * Disabling usb3v1 regulator (= writing 0 to VUSB3V1_DEV_GRP
+                 * in twl4030) resets the VUSB_DEDICATED2 register. This reset
+                 * enables VUSB3V1_SLEEP bit that remaps usb3v1 ACTIVE state to
+                 * SLEEP. We work around this by clearing the bit after usv3v1
+                 * is re-activated. This ensures that VUSB3V1 is really active.
+                 */
+                twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,
+                                                        VUSB_DEDICATED2);
+                regulator_enable(twl->usb1v5);
                pwr &= ~PHY_PWR_PHYPWD;
                WARN_ON(twl4030_usb_write_verify(twl, PHY_PWR_CTRL, pwr) < 0);
                twl4030_usb_write(twl, PHY_CLK_CTRL,
@@ -443,6 +462,9 @@ static void twl4030_phy_power(struct twl4030_usb *twl, int on)
        } else  {
                pwr |= PHY_PWR_PHYPWD;
                WARN_ON(twl4030_usb_write_verify(twl, PHY_PWR_CTRL, pwr) < 0);
+                regulator_disable(twl->usb1v5);
+                regulator_disable(twl->usb1v8);
+                regulator_disable(twl->usb3v1);
        }
 }
@@ -468,7 +490,7 @@ static void twl4030_phy_resume(struct twl4030_usb *twl)
        twl->asleep = 0;
 }
-static void twl4030_usb_ldo_init(struct twl4030_usb *twl)
+static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
 {
        /* Enable writing to power configuration registers */
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
@@ -480,20 +502,45 @@ static void twl4030_usb_ldo_init(struct twl4030_usb *twl)
        /* input to VUSB3V1 LDO is from VBAT, not VBUS */
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
-        /* turn on 3.1V regulator */
+        /* Initialize 3.1V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB3V1_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP);
+        twl->usb3v1 = regulator_get(twl->dev, "usb3v1");
+        if (IS_ERR(twl->usb3v1))
+                return -ENODEV;
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
-        /* turn on 1.5V regulator */
+        /* Initialize 1.5V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB1V5_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP);
+        twl->usb1v5 = regulator_get(twl->dev, "usb1v5");
+        if (IS_ERR(twl->usb1v5))
+                goto fail1;
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
-        /* turn on 1.8V regulator */
+        /* Initialize 1.8V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB1V8_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP);
+        twl->usb1v8 = regulator_get(twl->dev, "usb1v8");
+        if (IS_ERR(twl->usb1v8))
+                goto fail2;
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
        /* disable access to power configuration registers */
        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
+        return 0;
+fail2:
+        regulator_put(twl->usb1v5);
+        twl->usb1v5 = NULL;
+fail1:
+        regulator_put(twl->usb3v1);
+        twl->usb3v1 = NULL;
+        return -ENODEV;
 }
 static ssize_t twl4030_usb_vbus_show(struct device *dev,
@@ -598,7 +645,7 @@ static int __init twl4030_usb_probe(struct platform_device *pdev)
 {
        struct twl4030_usb_data *pdata = pdev->dev.platform_data;
        struct twl4030_usb      *twl;
-        int                     status;
+        int                     status, err;
        if (!pdata) {
                dev_dbg(&pdev->dev, "platform_data not available\n");
@@ -622,7 +669,12 @@ static int __init twl4030_usb_probe(struct platform_device *pdev)
        /* init spinlock for workqueue */
        spin_lock_init(&twl->lock);
-        twl4030_usb_ldo_init(twl);
+        err = twl4030_usb_ldo_init(twl);
+        if (err) {
+                dev_err(&pdev->dev, "ldo init failed\n");
+                kfree(twl);
+                return err;
+        }
        otg_set_transceiver(&twl->otg);
        platform_set_drvdata(pdev, twl);
@@ -688,6 +740,9 @@ static int __exit twl4030_usb_remove(struct platform_device *pdev)
        twl4030_usb_clear_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
        twl4030_phy_power(twl, 0);
+        regulator_put(twl->usb1v5);
+        regulator_put(twl->usb1v8);
+        regulator_put(twl->usb3v1);
        kfree(twl);
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index b361f05cafac..a65f9196b0a0 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -116,14 +116,14 @@ config USB_SERIAL_DIGI_ACCELEPORT
          To compile this driver as a module, choose M here: the
          module will be called digi_acceleport.
-config USB_SERIAL_CP2101
+config USB_SERIAL_CP210X
-        tristate "USB CP2101 UART Bridge Controller"
+        tristate "USB CP210x family of UART Bridge Controllers"
        help
-          Say Y here if you want to use a CP2101/CP2102 based USB to RS232
+          Say Y here if you want to use a CP2101/CP2102/CP2103 based USB
-          converter.
+          to RS232 converters.
          To compile this driver as a module, choose M here: the
-          module will be called cp2101.
+          module will be called cp210x.
 config USB_SERIAL_CYPRESS_M8
        tristate "USB Cypress M8 USB Serial Driver"
@@ -472,6 +472,15 @@ config USB_SERIAL_OTI6858
          To compile this driver as a module, choose M here: the
          module will be called oti6858.
+config USB_SERIAL_QUALCOMM
+        tristate "USB Qualcomm Serial modem"
+        help
+          Say Y here if you have a Qualcomm USB modem device.  These are
+          usually wireless cellular modems.
+          To compile this driver as a module, choose M here: the
+          module will be called qcserial.
 config USB_SERIAL_SPCP8X5
        tristate "USB SPCP8x5 USB To Serial Driver"
        help
@@ -515,6 +524,15 @@ config USB_SERIAL_SIERRAWIRELESS
          To compile this driver as a module, choose M here: the
          module will be called sierra.
+config USB_SERIAL_SYMBOL
+        tristate "USB Symbol Barcode driver (serial mode)"
+        help
+          Say Y here if you want to use a Symbol USB Barcode device
+          in serial emulation mode.
+          To compile this driver as a module, choose M here: the
+          module will be called symbolserial.
 config USB_SERIAL_TI
        tristate "USB TI 3410/5052 Serial Driver"
        help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index b75be91eb8f1..66619beb6cc0 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -15,7 +15,7 @@ obj-$(CONFIG_USB_SERIAL_AIRCABLE)		+= aircable.o
 obj-$(CONFIG_USB_SERIAL_ARK3116)                += ark3116.o
 obj-$(CONFIG_USB_SERIAL_BELKIN)                 += belkin_sa.o
 obj-$(CONFIG_USB_SERIAL_CH341)                  += ch341.o
-obj-$(CONFIG_USB_SERIAL_CP2101)                 += cp2101.o
+obj-$(CONFIG_USB_SERIAL_CP210X)                 += cp210x.o
 obj-$(CONFIG_USB_SERIAL_CYBERJACK)              += cyberjack.o
 obj-$(CONFIG_USB_SERIAL_CYPRESS_M8)             += cypress_m8.o
 obj-$(CONFIG_USB_SERIAL_DEBUG)                  += usb_debug.o
@@ -45,10 +45,12 @@ obj-$(CONFIG_USB_SERIAL_OPTICON)		+= opticon.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_OTI6858)                += oti6858.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
+obj-$(CONFIG_USB_SERIAL_QUALCOMM)               += qcserial.o
 obj-$(CONFIG_USB_SERIAL_SAFE)                   += safe_serial.o
 obj-$(CONFIG_USB_SERIAL_SIEMENS_MPI)            += siemens_mpi.o
 obj-$(CONFIG_USB_SERIAL_SIERRAWIRELESS)         += sierra.o
 obj-$(CONFIG_USB_SERIAL_SPCP8X5)                += spcp8x5.o
+obj-$(CONFIG_USB_SERIAL_SYMBOL)                 += symbolserial.o
 obj-$(CONFIG_USB_SERIAL_TI)                     += ti_usb_3410_5052.o
 obj-$(CONFIG_USB_SERIAL_VISOR)                  += visor.o
 obj-$(CONFIG_USB_SERIAL_WHITEHEAT)              += whiteheat.o
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index f61e3ca64305..ab4cc277aa65 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -1,5 +1,7 @@
 /*
 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
+ * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
+ * Copyright 2009, Boris Hajduk <boris@hajduk.org>
 *
 * ch341.c implements a serial port driver for the Winchiphead CH341.
 *
@@ -21,9 +23,39 @@
 #include <linux/usb/serial.h>
 #include <linux/serial.h>
-#define DEFAULT_BAUD_RATE 2400
+#define DEFAULT_BAUD_RATE 9600
 #define DEFAULT_TIMEOUT   1000
+/* flags for IO-Bits */
+#define CH341_BIT_RTS (1 << 6)
+#define CH341_BIT_DTR (1 << 5)
+/******************************/
+/* interrupt pipe definitions */
+/******************************/
+/* always 4 interrupt bytes */
+/* first irq byte normally 0x08 */
+/* second irq byte base 0x7d + below */
+/* third irq byte base 0x94 + below */
+/* fourth irq byte normally 0xee */
+/* second interrupt byte */
+#define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */
+/* status returned in third interrupt answer byte, inverted in data
+   from irq */
+#define CH341_BIT_CTS 0x01
+#define CH341_BIT_DSR 0x02
+#define CH341_BIT_RI  0x04
+#define CH341_BIT_DCD 0x08
+#define CH341_BITS_MODEM_STAT 0x0f /* all bits */
+/*******************************/
+/* baudrate calculation factor */
+/*******************************/
+#define CH341_BAUDBASE_FACTOR 1532620800
+#define CH341_BAUDBASE_DIVMAX 3
 static int debug;
 static struct usb_device_id id_table [] = {
@@ -34,9 +66,12 @@ static struct usb_device_id id_table [] = {
 MODULE_DEVICE_TABLE(usb, id_table);
 struct ch341_private {
-        unsigned baud_rate;
+        spinlock_t lock; /* access lock */
-        u8 dtr;
+        wait_queue_head_t delta_msr_wait; /* wait queue for modem status */
-        u8 rts;
+        unsigned baud_rate; /* set baud rate */
+        u8 line_control; /* set line control value RTS/DTR */
+        u8 line_status; /* active status of modem control inputs */
+        u8 multi_status_change; /* status changed multiple since last call */
 };
 static int ch341_control_out(struct usb_device *dev, u8 request,
@@ -72,37 +107,28 @@ static int ch341_set_baudrate(struct usb_device *dev,
 {
        short a, b;
        int r;
+        unsigned long factor;
+        short divisor;
        dbg("ch341_set_baudrate(%d)", priv->baud_rate);
-        switch (priv->baud_rate) {
-        case 2400:
+        if (!priv->baud_rate)
-                a = 0xd901;
-                b = 0x0038;
-                break;
-        case 4800:
-                a = 0x6402;
-                b = 0x001f;
-                break;
-        case 9600:
-                a = 0xb202;
-                b = 0x0013;
-                break;
-        case 19200:
-                a = 0xd902;
-                b = 0x000d;
-                break;
-        case 38400:
-                a = 0x6403;
-                b = 0x000a;
-                break;
-        case 115200:
-                a = 0xcc03;
-                b = 0x0008;
-                break;
-        default:
                return -EINVAL;
+        factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
+        divisor = CH341_BAUDBASE_DIVMAX;
+        while ((factor > 0xfff0) && divisor) {
+                factor >>= 3;
+                divisor--;
        }
+        if (factor > 0xfff0)
+                return -EINVAL;
+        factor = 0x10000 - factor;
+        a = (factor & 0xff00) | divisor;
+        b = factor & 0xff;
        r = ch341_control_out(dev, 0x9a, 0x1312, a);
        if (!r)
                r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
@@ -110,19 +136,18 @@ static int ch341_set_baudrate(struct usb_device *dev,
        return r;
 }
-static int ch341_set_handshake(struct usb_device *dev,
+static int ch341_set_handshake(struct usb_device *dev, u8 control)
-                               struct ch341_private *priv)
 {
-        dbg("ch341_set_handshake(%d,%d)", priv->dtr, priv->rts);
+        dbg("ch341_set_handshake(0x%02x)", control);
-        return ch341_control_out(dev, 0xa4,
+        return ch341_control_out(dev, 0xa4, ~control, 0);
-                ~((priv->dtr?1<<5:0)|(priv->rts?1<<6:0)), 0);
 }
-static int ch341_get_status(struct usb_device *dev)
+static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
 {
        char *buffer;
        int r;
        const unsigned size = 8;
+        unsigned long flags;
        dbg("ch341_get_status()");
@@ -134,10 +159,15 @@ static int ch341_get_status(struct usb_device *dev)
        if (r < 0)
                goto out;
-        /* Not having the datasheet for the CH341, we ignore the bytes returned
+        /* setup the private status if available */
-         * from the device. Return error if the device did not respond in time.
+        if (r == 2) {
-         */
+                r = 0;
-        r = 0;
+                spin_lock_irqsave(&priv->lock, flags);
+                priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
+                priv->multi_status_change = 0;
+                spin_unlock_irqrestore(&priv->lock, flags);
+        } else
+                r = -EPROTO;
 out:    kfree(buffer);
        return r;
@@ -180,7 +210,7 @@ static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
                goto out;
        /* expect 0xff 0xee */
-        r = ch341_get_status(dev);
+        r = ch341_get_status(dev, priv);
        if (r < 0)
                goto out;
@@ -192,12 +222,12 @@ static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
        if (r < 0)
                goto out;
-        r = ch341_set_handshake(dev, priv);
+        r = ch341_set_handshake(dev, priv->line_control);
        if (r < 0)
                goto out;
        /* expect 0x9f 0xee */
-        r = ch341_get_status(dev);
+        r = ch341_get_status(dev, priv);
 out:    kfree(buffer);
        return r;
@@ -216,9 +246,10 @@ static int ch341_attach(struct usb_serial *serial)
        if (!priv)
                return -ENOMEM;
+        spin_lock_init(&priv->lock);
+        init_waitqueue_head(&priv->delta_msr_wait);
        priv->baud_rate = DEFAULT_BAUD_RATE;
-        priv->dtr = 1;
+        priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
-        priv->rts = 1;
        r = ch341_configure(serial->dev, priv);
        if (r < 0)
@@ -231,6 +262,35 @@ error:	kfree(priv);
        return r;
 }
+static void ch341_close(struct tty_struct *tty, struct usb_serial_port *port,
+                                struct file *filp)
+{
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        unsigned int c_cflag;
+        dbg("%s - port %d", __func__, port->number);
+        /* shutdown our urbs */
+        dbg("%s - shutting down urbs", __func__);
+        usb_kill_urb(port->write_urb);
+        usb_kill_urb(port->read_urb);
+        usb_kill_urb(port->interrupt_in_urb);
+        if (tty) {
+                c_cflag = tty->termios->c_cflag;
+                if (c_cflag & HUPCL) {
+                        /* drop DTR and RTS */
+                        spin_lock_irqsave(&priv->lock, flags);
+                        priv->line_control = 0;
+                        spin_unlock_irqrestore(&priv->lock, flags);
+                        ch341_set_handshake(port->serial->dev, 0);
+                }
+        }
+        wake_up_interruptible(&priv->delta_msr_wait);
+}
 /* open this device, set default parameters */
 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
                                struct file *filp)
@@ -242,14 +302,13 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
        dbg("ch341_open()");
        priv->baud_rate = DEFAULT_BAUD_RATE;
-        priv->dtr = 1;
+        priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
-        priv->rts = 1;
        r = ch341_configure(serial->dev, priv);
        if (r)
                goto out;
-        r = ch341_set_handshake(serial->dev, priv);
+        r = ch341_set_handshake(serial->dev, priv->line_control);
        if (r)
                goto out;
@@ -257,6 +316,16 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
        if (r)
                goto out;
+        dbg("%s - submitting interrupt urb", __func__);
+        port->interrupt_in_urb->dev = serial->dev;
+        r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+        if (r) {
+                dev_err(&port->dev, "%s - failed submitting interrupt urb,"
+                        " error %d\n", __func__, r);
+                ch341_close(tty, port, NULL);
+                return -EPROTO;
+        }
        r = usb_serial_generic_open(tty, port, filp);
 out:    return r;
@@ -270,46 +339,224 @@ static void ch341_set_termios(struct tty_struct *tty,
 {
        struct ch341_private *priv = usb_get_serial_port_data(port);
        unsigned baud_rate;
+        unsigned long flags;
        dbg("ch341_set_termios()");
+        if (!tty || !tty->termios)
+                return;
        baud_rate = tty_get_baud_rate(tty);
-        switch (baud_rate) {
+        priv->baud_rate = baud_rate;
-        case 2400:
-        case 4800:
+        if (baud_rate) {
-        case 9600:
+                spin_lock_irqsave(&priv->lock, flags);
-        case 19200:
+                priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
-        case 38400:
+                spin_unlock_irqrestore(&priv->lock, flags);
-        case 115200:
+                ch341_set_baudrate(port->serial->dev, priv);
-                priv->baud_rate = baud_rate;
+        } else {
-                break;
+                spin_lock_irqsave(&priv->lock, flags);
-        default:
+                priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
-                dbg("Rate %d not supported, using %d",
+                spin_unlock_irqrestore(&priv->lock, flags);
-                        baud_rate, DEFAULT_BAUD_RATE);
-                priv->baud_rate = DEFAULT_BAUD_RATE;
        }
-        ch341_set_baudrate(port->serial->dev, priv);
+        ch341_set_handshake(port->serial->dev, priv->line_control);
        /* Unimplemented:
         * (cflag & CSIZE) : data bits [5, 8]
         * (cflag & PARENB) : parity {NONE, EVEN, ODD}
         * (cflag & CSTOPB) : stop bits [1, 2]
         */
+}
+static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
+                          unsigned int set, unsigned int clear)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        u8 control;
+        spin_lock_irqsave(&priv->lock, flags);
+        if (set & TIOCM_RTS)
+                priv->line_control |= CH341_BIT_RTS;
+        if (set & TIOCM_DTR)
+                priv->line_control |= CH341_BIT_DTR;
+        if (clear & TIOCM_RTS)
+                priv->line_control &= ~CH341_BIT_RTS;
+        if (clear & TIOCM_DTR)
+                priv->line_control &= ~CH341_BIT_DTR;
+        control = priv->line_control;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return ch341_set_handshake(port->serial->dev, control);
+}
+static void ch341_read_int_callback(struct urb *urb)
+{
+        struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+        unsigned char *data = urb->transfer_buffer;
+        unsigned int actual_length = urb->actual_length;
+        int status;
+        dbg("%s (%d)", __func__, port->number);
+        switch (urb->status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d", __func__,
+                    urb->status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d", __func__,
+                    urb->status);
+                goto exit;
+        }
-         /* Copy back the old hardware settings */
+        usb_serial_debug_data(debug, &port->dev, __func__,
-         tty_termios_copy_hw(tty->termios, old_termios);
+                              urb->actual_length, urb->transfer_buffer);
-         /* And re-encode with the new baud */
-         tty_encode_baud_rate(tty, baud_rate, baud_rate);
+        if (actual_length >= 4) {
+                struct ch341_private *priv = usb_get_serial_port_data(port);
+                unsigned long flags;
+                spin_lock_irqsave(&priv->lock, flags);
+                priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
+                if ((data[1] & CH341_MULT_STAT))
+                        priv->multi_status_change = 1;
+                spin_unlock_irqrestore(&priv->lock, flags);
+                wake_up_interruptible(&priv->delta_msr_wait);
+        }
+exit:
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status)
+                dev_err(&urb->dev->dev,
+                        "%s - usb_submit_urb failed with result %d\n",
+                        __func__, status);
+}
+static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
+{
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        u8 prevstatus;
+        u8 status;
+        u8 changed;
+        u8 multi_change = 0;
+        spin_lock_irqsave(&priv->lock, flags);
+        prevstatus = priv->line_status;
+        priv->multi_status_change = 0;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        while (!multi_change) {
+                interruptible_sleep_on(&priv->delta_msr_wait);
+                /* see if a signal did it */
+                if (signal_pending(current))
+                        return -ERESTARTSYS;
+                spin_lock_irqsave(&priv->lock, flags);
+                status = priv->line_status;
+                multi_change = priv->multi_status_change;
+                spin_unlock_irqrestore(&priv->lock, flags);
+                changed = prevstatus ^ status;
+                if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) ||
+                    ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) ||
+                    ((arg & TIOCM_CD)  && (changed & CH341_BIT_DCD)) ||
+                    ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
+                        return 0;
+                }
+                prevstatus = status;
+        }
+        return 0;
+}
+/*static int ch341_ioctl(struct usb_serial_port *port, struct file *file,*/
+static int ch341_ioctl(struct tty_struct *tty, struct file *file,
+                        unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
+        switch (cmd) {
+        case TIOCMIWAIT:
+                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+                return wait_modem_info(port, arg);
+        default:
+                dbg("%s not supported = 0x%04x", __func__, cmd);
+                break;
+        }
+        return -ENOIOCTLCMD;
+}
+static int ch341_tiocmget(struct tty_struct *tty, struct file *file)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        u8 mcr;
+        u8 status;
+        unsigned int result;
+        dbg("%s (%d)", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        mcr = priv->line_control;
+        status = priv->line_status;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        result = ((mcr & CH341_BIT_DTR)         ? TIOCM_DTR : 0)
+                  | ((mcr & CH341_BIT_RTS)      ? TIOCM_RTS : 0)
+                  | ((status & CH341_BIT_CTS)   ? TIOCM_CTS : 0)
+                  | ((status & CH341_BIT_DSR)   ? TIOCM_DSR : 0)
+                  | ((status & CH341_BIT_RI)    ? TIOCM_RI  : 0)
+                  | ((status & CH341_BIT_DCD)   ? TIOCM_CD  : 0);
+        dbg("%s - result = %x", __func__, result);
+        return result;
+}
+static int ch341_reset_resume(struct usb_interface *intf)
+{
+        struct usb_device *dev = interface_to_usbdev(intf);
+        struct usb_serial *serial = NULL;
+        struct ch341_private *priv;
+        serial = usb_get_intfdata(intf);
+        priv = usb_get_serial_port_data(serial->port[0]);
+        /*reconfigure ch341 serial port after bus-reset*/
+        ch341_configure(dev, priv);
+        usb_serial_resume(intf);
+        return 0;
 }
 static struct usb_driver ch341_driver = {
        .name           = "ch341",
        .probe          = usb_serial_probe,
        .disconnect     = usb_serial_disconnect,
+        .suspend        = usb_serial_suspend,
+        .resume         = usb_serial_resume,
+        .reset_resume   = ch341_reset_resume,
        .id_table       = id_table,
        .no_dynamic_id  = 1,
+        .supports_autosuspend = 1,
 };
 static struct usb_serial_driver ch341_device = {
@@ -317,12 +564,17 @@ static struct usb_serial_driver ch341_device = {
                .owner  = THIS_MODULE,
                .name   = "ch341-uart",
        },
-        .id_table         = id_table,
+        .id_table          = id_table,
-        .usb_driver       = &ch341_driver,
+        .usb_driver        = &ch341_driver,
-        .num_ports        = 1,
+        .num_ports         = 1,
-        .open             = ch341_open,
+        .open              = ch341_open,
-        .set_termios      = ch341_set_termios,
+        .close             = ch341_close,
-        .attach           = ch341_attach,
+        .ioctl             = ch341_ioctl,
+        .set_termios       = ch341_set_termios,
+        .tiocmget          = ch341_tiocmget,
+        .tiocmset          = ch341_tiocmset,
+        .read_int_callback = ch341_read_int_callback,
+        .attach            = ch341_attach,
 };
 static int __init ch341_init(void)
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp210x.c
index 9b4082b58c5b..e8d5133ce9c8 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp210x.c
@@ -11,10 +11,6 @@
 * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
 * control thanks to Munir Nassar nassarmu@real-time.com
 *
- * Outstanding Issues:
- *  Buffers are not flushed when the port is opened.
- *  Multiple calls to write() may fail with "Resource temporarily unavailable"
- *
 */
 #include <linux/kernel.h>
@@ -31,7 +27,7 @@
 /*
 * Version Information
 */
-#define DRIVER_VERSION "v0.07"
+#define DRIVER_VERSION "v0.08"
 #define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
 /*
@@ -42,17 +38,21 @@ static int cp2101_open(struct tty_struct *, struct usb_serial_port *,
 static void cp2101_cleanup(struct usb_serial_port *);
 static void cp2101_close(struct tty_struct *, struct usb_serial_port *,
                                                        struct file*);
-static void cp2101_get_termios(struct tty_struct *);
+static void cp2101_get_termios(struct tty_struct *,
+        struct usb_serial_port *port);
+static void cp2101_get_termios_port(struct usb_serial_port *port,
+        unsigned int *cflagp, unsigned int *baudp);
 static void cp2101_set_termios(struct tty_struct *, struct usb_serial_port *,
                                                        struct ktermios*);
 static int cp2101_tiocmget(struct tty_struct *, struct file *);
 static int cp2101_tiocmset(struct tty_struct *, struct file *,
                unsigned int, unsigned int);
+static int cp2101_tiocmset_port(struct usb_serial_port *port, struct file *,
+                unsigned int, unsigned int);
 static void cp2101_break_ctl(struct tty_struct *, int);
 static int cp2101_startup(struct usb_serial *);
 static void cp2101_shutdown(struct usb_serial *);
 static int debug;
 static struct usb_device_id id_table [] = {
@@ -91,6 +91,7 @@ static struct usb_device_id id_table [] = {
        { USB_DEVICE(0x10c4, 0x8293) }, /* Telegesys ETRX2USB */
        { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
        { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
+        { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
        { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
        { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
        { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
@@ -225,7 +226,7 @@ static int cp2101_get_config(struct usb_serial_port *port, u8 request,
        kfree(buf);
        if (result != size) {
-                dev_err(&port->dev, "%s - Unable to send config request, "
+                dbg("%s - Unable to send config request, "
                                "request=0x%x size=%d result=%d\n",
                                __func__, request, size, result);
                return -EPROTO;
@@ -276,7 +277,7 @@ static int cp2101_set_config(struct usb_serial_port *port, u8 request,
        kfree(buf);
        if ((size > 2 && result != size) || result < 0) {
-                dev_err(&port->dev, "%s - Unable to send request, "
+                dbg("%s - Unable to send request, "
                                "request=0x%x size=%d result=%d\n",
                                __func__, request, size, result);
                return -EPROTO;
@@ -301,6 +302,47 @@ static inline int cp2101_set_config_single(struct usb_serial_port *port,
        return cp2101_set_config(port, request, &data, 2);
 }
+/*
+ * cp2101_quantise_baudrate
+ * Quantises the baud rate as per AN205 Table 1
+ */
+static unsigned int cp2101_quantise_baudrate(unsigned int baud) {
+        if      (baud <= 56)       baud = 0;
+        else if (baud <= 300)      baud = 300;
+        else if (baud <= 600)      baud = 600;
+        else if (baud <= 1200)     baud = 1200;
+        else if (baud <= 1800)     baud = 1800;
+        else if (baud <= 2400)     baud = 2400;
+        else if (baud <= 4000)     baud = 4000;
+        else if (baud <= 4803)     baud = 4800;
+        else if (baud <= 7207)     baud = 7200;
+        else if (baud <= 9612)     baud = 9600;
+        else if (baud <= 14428)    baud = 14400;
+        else if (baud <= 16062)    baud = 16000;
+        else if (baud <= 19250)    baud = 19200;
+        else if (baud <= 28912)    baud = 28800;
+        else if (baud <= 38601)    baud = 38400;
+        else if (baud <= 51558)    baud = 51200;
+        else if (baud <= 56280)    baud = 56000;
+        else if (baud <= 58053)    baud = 57600;
+        else if (baud <= 64111)    baud = 64000;
+        else if (baud <= 77608)    baud = 76800;
+        else if (baud <= 117028)   baud = 115200;
+        else if (baud <= 129347)   baud = 128000;
+        else if (baud <= 156868)   baud = 153600;
+        else if (baud <= 237832)   baud = 230400;
+        else if (baud <= 254234)   baud = 250000;
+        else if (baud <= 273066)   baud = 256000;
+        else if (baud <= 491520)   baud = 460800;
+        else if (baud <= 567138)   baud = 500000;
+        else if (baud <= 670254)   baud = 576000;
+        else if (baud <= 1053257)  baud = 921600;
+        else if (baud <= 1474560)  baud = 1228800;
+        else if (baud <= 2457600)  baud = 1843200;
+        else                       baud = 3686400;
+        return baud;
+}
 static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
                                struct file *filp)
 {
@@ -331,10 +373,12 @@ static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
        }
        /* Configure the termios structure */
-        cp2101_get_termios(tty);
+        cp2101_get_termios(tty, port);
        /* Set the DTR and RTS pins low */
-        cp2101_tiocmset(tty, NULL, TIOCM_DTR | TIOCM_RTS, 0);
+        cp2101_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
+                        : port,
+                NULL, TIOCM_DTR | TIOCM_RTS, 0);
        return 0;
 }
@@ -376,9 +420,31 @@ static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
 * from the device, corrects any unsupported values, and configures the
 * termios structure to reflect the state of the device
 */
-static void cp2101_get_termios (struct tty_struct *tty)
+static void cp2101_get_termios(struct tty_struct *tty,
+        struct usb_serial_port *port)
+{
+        unsigned int baud;
+        if (tty) {
+                cp2101_get_termios_port(tty->driver_data,
+                        &tty->termios->c_cflag, &baud);
+                tty_encode_baud_rate(tty, baud, baud);
+        }
+        else {
+                unsigned int cflag;
+                cflag = 0;
+                cp2101_get_termios_port(port, &cflag, &baud);
+        }
+}
+/*
+ * cp2101_get_termios_port
+ * This is the heart of cp2101_get_termios which always uses a &usb_serial_port.
+ */
+static void cp2101_get_termios_port(struct usb_serial_port *port,
+        unsigned int *cflagp, unsigned int *baudp)
 {
-        struct usb_serial_port *port = tty->driver_data;
        unsigned int cflag, modem_ctl[4];
        unsigned int baud;
        unsigned int bits;
@@ -388,12 +454,12 @@ static void cp2101_get_termios (struct tty_struct *tty)
        cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
        /* Convert to baudrate */
        if (baud)
-                baud = BAUD_RATE_GEN_FREQ / baud;
+                baud = cp2101_quantise_baudrate((BAUD_RATE_GEN_FREQ + baud/2)/ baud);
        dbg("%s - baud rate = %d", __func__, baud);
+        *baudp = baud;
-        tty_encode_baud_rate(tty, baud, baud);
+        cflag = *cflagp;
-        cflag = tty->termios->c_cflag;
        cp2101_get_config(port, CP2101_BITS, &bits, 2);
        cflag &= ~CSIZE;
@@ -499,7 +565,7 @@ static void cp2101_get_termios (struct tty_struct *tty)
                cflag &= ~CRTSCTS;
        }
-        tty->termios->c_cflag = cflag;
+        *cflagp = cflag;
 }
 static void cp2101_set_termios(struct tty_struct *tty,
@@ -517,46 +583,16 @@ static void cp2101_set_termios(struct tty_struct *tty,
        tty->termios->c_cflag &= ~CMSPAR;
        cflag = tty->termios->c_cflag;
        old_cflag = old_termios->c_cflag;
-        baud = tty_get_baud_rate(tty);
+        baud = cp2101_quantise_baudrate(tty_get_baud_rate(tty));
        /* If the baud rate is to be updated*/
-        if (baud != tty_termios_baud_rate(old_termios)) {
+        if (baud != tty_termios_baud_rate(old_termios) && baud != 0) {
-                switch (baud) {
+                dbg("%s - Setting baud rate to %d baud", __func__,
-                case 0:
+                                baud);
-                case 600:
+                if (cp2101_set_config_single(port, CP2101_BAUDRATE,
-                case 1200:
+                                        ((BAUD_RATE_GEN_FREQ + baud/2) / baud))) {
-                case 1800:
+                        dbg("Baud rate requested not supported by device\n");
-                case 2400:
+                        baud = tty_termios_baud_rate(old_termios);
-                case 4800:
-                case 7200:
-                case 9600:
-                case 14400:
-                case 19200:
-                case 28800:
-                case 38400:
-                case 55854:
-                case 57600:
-                case 115200:
-                case 127117:
-                case 230400:
-                case 460800:
-                case 921600:
-                case 3686400:
-                        break;
-                default:
-                        baud = 9600;
-                        break;
-                }
-                if (baud) {
-                        dbg("%s - Setting baud rate to %d baud", __func__,
-                                        baud);
-                        if (cp2101_set_config_single(port, CP2101_BAUDRATE,
-                                                (BAUD_RATE_GEN_FREQ / baud))) {
-                                dev_err(&port->dev, "Baud rate requested not "
-                                                "supported by device\n");
-                                baud = tty_termios_baud_rate(old_termios);
-                        }
                }
        }
        /* Report back the resulting baud rate */
@@ -588,14 +624,14 @@ static void cp2101_set_termios(struct tty_struct *tty,
                        dbg("%s - data bits = 9", __func__);
                        break;*/
                default:
-                        dev_err(&port->dev, "cp2101 driver does not "
+                        dbg("cp2101 driver does not "
                                        "support the number of bits requested,"
                                        " using 8 bit mode\n");
                                bits |= BITS_DATA_8;
                                break;
                }
                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
-                        dev_err(&port->dev, "Number of data bits requested "
+                        dbg("Number of data bits requested "
                                        "not supported by device\n");
        }
@@ -612,7 +648,7 @@ static void cp2101_set_termios(struct tty_struct *tty,
                        }
                }
                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
-                        dev_err(&port->dev, "Parity mode not supported "
+                        dbg("Parity mode not supported "
                                        "by device\n");
        }
@@ -627,7 +663,7 @@ static void cp2101_set_termios(struct tty_struct *tty,
                        dbg("%s - stop bits = 1", __func__);
                }
                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
-                        dev_err(&port->dev, "Number of stop bits requested "
+                        dbg("Number of stop bits requested "
                                        "not supported by device\n");
        }
@@ -661,6 +697,12 @@ static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
                unsigned int set, unsigned int clear)
 {
        struct usb_serial_port *port = tty->driver_data;
+        return cp2101_tiocmset_port(port, file, set, clear);
+}
+static int cp2101_tiocmset_port(struct usb_serial_port *port, struct file *file,
+                unsigned int set, unsigned int clear)
+{
        unsigned int control = 0;
        dbg("%s - port %d", __func__, port->number);
@@ -685,7 +727,6 @@ static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
        dbg("%s - control = 0x%.4x", __func__, control);
        return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
 }
 static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index ae84c326a540..dcc87aaa8628 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1938,18 +1938,16 @@ static void ftdi_process_read(struct work_struct *work)
                /* Compare new line status to the old one, signal if different/
                   N.B. packet may be processed more than once, but differences
                   are only processed once.  */
-                if (priv != NULL) {
+                char new_status = data[packet_offset + 0] &
-                        char new_status = data[packet_offset + 0] &
+                                                FTDI_STATUS_B0_MASK;
-                                                        FTDI_STATUS_B0_MASK;
+                if (new_status != priv->prev_status) {
-                        if (new_status != priv->prev_status) {
+                        priv->diff_status |=
-                                priv->diff_status |=
+                                new_status ^ priv->prev_status;
-                                        new_status ^ priv->prev_status;
+                        wake_up_interruptible(&priv->delta_msr_wait);
-                                wake_up_interruptible(&priv->delta_msr_wait);
+                        priv->prev_status = new_status;
-                                priv->prev_status = new_status;
-                        }
                }
-                length = min(PKTSZ, urb->actual_length-packet_offset)-2;
+                length = min_t(u32, PKTSZ, urb->actual_length-packet_offset)-2;
                if (length < 0) {
                        dev_err(&port->dev, "%s - bad packet length: %d\n",
                                __func__, length+2);
@@ -2294,11 +2292,8 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
                           FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
                           0, 0,
                           buf, 1, WDR_TIMEOUT);
-                if (ret < 0) {
+                if (ret < 0)
-                        dbg("%s Could not get modem status of device - err: %d", __func__,
-                            ret);
                        return ret;
-                }
                break;
        case FT8U232AM:
        case FT232BM:
@@ -2313,15 +2308,11 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
                                   FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
                                   0, priv->interface,
                                   buf, 2, WDR_TIMEOUT);
-                if (ret < 0) {
+                if (ret < 0)
-                        dbg("%s Could not get modem status of device - err: %d", __func__,
-                            ret);
                        return ret;
-                }
                break;
        default:
                return -EFAULT;
-                break;
        }
        return  (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 814909f1ee63..9d57cace3731 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -177,14 +177,6 @@ int usb_serial_generic_resume(struct usb_serial *serial)
        struct usb_serial_port *port;
        int i, c = 0, r;
-#ifdef CONFIG_PM
-        /*
-         * If this is an autoresume, don't submit URBs.
-         * They will be submitted in the open function instead.
-         */
-        if (serial->dev->auto_pm)
-                return 0;
-#endif
        for (i = 0; i < serial->num_ports; i++) {
                port = serial->port[i];
                if (port->port.count && port->read_urb) {
@@ -196,6 +188,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
        return c ? -EIO : 0;
 }
+EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
 void usb_serial_generic_close(struct tty_struct *tty,
                        struct usb_serial_port *port, struct file *filp)
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 132be74d2b89..ef92095b0732 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -78,6 +78,7 @@ static int  ipaq_open(struct tty_struct *tty,
                        struct usb_serial_port *port, struct file *filp);
 static void ipaq_close(struct tty_struct *tty,
                        struct usb_serial_port *port, struct file *filp);
+static int  ipaq_calc_num_ports(struct usb_serial *serial);
 static int  ipaq_startup(struct usb_serial *serial);
 static void ipaq_shutdown(struct usb_serial *serial);
 static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port,
@@ -572,15 +573,10 @@ static struct usb_serial_driver ipaq_device = {
        .description =          "PocketPC PDA",
        .usb_driver =           &ipaq_driver,
        .id_table =             ipaq_id_table,
-        /*
-         * some devices have an extra endpoint, which
-         * must be ignored as it would make the core
-         * create a second port which oopses when used
-         */
-        .num_ports =            1,
        .open =                 ipaq_open,
        .close =                ipaq_close,
        .attach =               ipaq_startup,
+        .calc_num_ports =       ipaq_calc_num_ports,
        .shutdown =             ipaq_shutdown,
        .write =                ipaq_write,
        .write_room =           ipaq_write_room,
@@ -956,14 +952,49 @@ static void ipaq_destroy_lists(struct usb_serial_port *port)
 }
+static int ipaq_calc_num_ports(struct usb_serial *serial)
+{
+        /*
+         * some devices have 3 endpoints, the 3rd of which
+         * must be ignored as it would make the core
+         * create a second port which oopses when used
+         */
+        int ipaq_num_ports = 1;
+        dbg("%s - numberofendpoints: %d", __FUNCTION__,
+                (int)serial->interface->cur_altsetting->desc.bNumEndpoints);
+        /*
+         * a few devices have 4 endpoints, seemingly Yakuma devices,
+         * and we need the second pair, so let them have 2 ports
+         *
+         * TODO: can we drop port 1 ?
+         */
+        if (serial->interface->cur_altsetting->desc.bNumEndpoints > 3) {
+                ipaq_num_ports = 2;
+        }
+        return ipaq_num_ports;
+}
 static int ipaq_startup(struct usb_serial *serial)
 {
        dbg("%s", __func__);
        if (serial->dev->actconfig->desc.bConfigurationValue != 1) {
+                /*
+                 * FIXME: HP iPaq rx3715, possibly others, have 1 config that
+                 * is labeled as 2
+                 */
                dev_err(&serial->dev->dev, "active config #%d != 1 ??\n",
                        serial->dev->actconfig->desc.bConfigurationValue);
                return -ENODEV;
        }
+        dbg("%s - iPAQ module configured for %d ports",
+                __FUNCTION__, serial->num_ports);
        return usb_reset_configuration(serial->dev);
 }
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 9878c0fb3859..00daa8f7759a 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1507,7 +1507,7 @@ static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
        } else {
                dev_warn(&serial->interface->dev,
                         "unsupported endpoint type %x\n",
-                         ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
+                         usb_endpoint_type(ep_desc));
                usb_free_urb(urb);
                return NULL;
        }
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index cea326f1f105..839583dc8b6a 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -1,8 +1,8 @@
 /*
 * Opticon USB barcode to serial driver
 *
- * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
+ * Copyright (C) 2008 - 2009 Greg Kroah-Hartman <gregkh@suse.de>
- * Copyright (C) 2008 Novell Inc.
+ * Copyright (C) 2008 - 2009 Novell Inc.
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License version
@@ -14,6 +14,7 @@
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
+#include <linux/serial.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
@@ -40,8 +41,12 @@ struct opticon_private {
        bool throttled;
        bool actually_throttled;
        bool rts;
+        int outstanding_urbs;
 };
+/* max number of write urbs in flight */
+#define URB_UPPER_LIMIT 4
 static void opticon_bulk_callback(struct urb *urb)
 {
        struct opticon_private *priv = urb->context;
@@ -106,7 +111,6 @@ static void opticon_bulk_callback(struct urb *urb)
                                        priv->rts = false;
                                else
                                        priv->rts = true;
-                                /* FIXME change the RTS level */
                        } else {
                        dev_dbg(&priv->udev->dev,
                                "Unknown data packet received from the device:"
@@ -188,6 +192,120 @@ static void opticon_close(struct tty_struct *tty, struct usb_serial_port *port,
        usb_kill_urb(priv->bulk_read_urb);
 }
+static void opticon_write_bulk_callback(struct urb *urb)
+{
+        struct opticon_private *priv = urb->context;
+        int status = urb->status;
+        unsigned long flags;
+        /* free up the transfer buffer, as usb_free_urb() does not do this */
+        kfree(urb->transfer_buffer);
+        if (status)
+                dbg("%s - nonzero write bulk status received: %d",
+                    __func__, status);
+        spin_lock_irqsave(&priv->lock, flags);
+        --priv->outstanding_urbs;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        usb_serial_port_softint(priv->port);
+}
+static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
+                         const unsigned char *buf, int count)
+{
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        struct usb_serial *serial = port->serial;
+        struct urb *urb;
+        unsigned char *buffer;
+        unsigned long flags;
+        int status;
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
+                spin_unlock_irqrestore(&priv->lock, flags);
+                dbg("%s - write limit hit\n", __func__);
+                return 0;
+        }
+        priv->outstanding_urbs++;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        buffer = kmalloc(count, GFP_ATOMIC);
+        if (!buffer) {
+                dev_err(&port->dev, "out of memory\n");
+                count = -ENOMEM;
+                goto error_no_buffer;
+        }
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+        if (!urb) {
+                dev_err(&port->dev, "no more free urbs\n");
+                count = -ENOMEM;
+                goto error_no_urb;
+        }
+        memcpy(buffer, buf, count);
+        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
+        usb_fill_bulk_urb(urb, serial->dev,
+                          usb_sndbulkpipe(serial->dev,
+                                          port->bulk_out_endpointAddress),
+                          buffer, count, opticon_write_bulk_callback, priv);
+        /* send it down the pipe */
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status) {
+                dev_err(&port->dev,
+                   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
+                                                        __func__, status);
+                count = status;
+                goto error;
+        }
+        /* we are done with this urb, so let the host driver
+         * really free it when it is finished with it */
+        usb_free_urb(urb);
+        return count;
+error:
+        usb_free_urb(urb);
+error_no_urb:
+        kfree(buffer);
+error_no_buffer:
+        spin_lock_irqsave(&priv->lock, flags);
+        --priv->outstanding_urbs;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return count;
+}
+static int opticon_write_room(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        dbg("%s - port %d", __func__, port->number);
+        /*
+         * We really can take almost anything the user throws at us
+         * but let's pick a nice big number to tell the tty
+         * layer that we have lots of free space, unless we don't.
+         */
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
+                spin_unlock_irqrestore(&priv->lock, flags);
+                dbg("%s - write limit hit\n", __func__);
+                return 0;
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 2048;
+}
 static void opticon_throttle(struct tty_struct *tty)
 {
        struct usb_serial_port *port = tty->driver_data;
@@ -223,6 +341,67 @@ static void opticon_unthrottle(struct tty_struct *tty)
                                                        __func__, result);
 }
+static int opticon_tiocmget(struct tty_struct *tty, struct file *file)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        int result = 0;
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->rts)
+                result = TIOCM_RTS;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        dbg("%s - %x", __func__, result);
+        return result;
+}
+static int get_serial_info(struct opticon_private *priv,
+                           struct serial_struct __user *serial)
+{
+        struct serial_struct tmp;
+        if (!serial)
+                return -EFAULT;
+        memset(&tmp, 0x00, sizeof(tmp));
+        /* fake emulate a 16550 uart to make userspace code happy */
+        tmp.type                = PORT_16550A;
+        tmp.line                = priv->serial->minor;
+        tmp.port                = 0;
+        tmp.irq                 = 0;
+        tmp.flags               = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
+        tmp.xmit_fifo_size      = 1024;
+        tmp.baud_base           = 9600;
+        tmp.close_delay         = 5*HZ;
+        tmp.closing_wait        = 30*HZ;
+        if (copy_to_user(serial, &tmp, sizeof(*serial)))
+                return -EFAULT;
+        return 0;
+}
+static int opticon_ioctl(struct tty_struct *tty, struct file *file,
+                         unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        switch (cmd) {
+        case TIOCGSERIAL:
+                return get_serial_info(priv,
+                                       (struct serial_struct __user *)arg);
+        }
+        return -ENOIOCTLCMD;
+}
 static int opticon_startup(struct usb_serial *serial)
 {
        struct opticon_private *priv;
@@ -306,11 +485,37 @@ static void opticon_shutdown(struct usb_serial *serial)
        usb_set_serial_data(serial, NULL);
 }
+static int opticon_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        struct usb_serial *serial = usb_get_intfdata(intf);
+        struct opticon_private *priv = usb_get_serial_data(serial);
+        usb_kill_urb(priv->bulk_read_urb);
+        return 0;
+}
+static int opticon_resume(struct usb_interface *intf)
+{
+        struct usb_serial *serial = usb_get_intfdata(intf);
+        struct opticon_private *priv = usb_get_serial_data(serial);
+        struct usb_serial_port *port = serial->port[0];
+        int result;
+        mutex_lock(&port->mutex);
+        if (port->port.count)
+                result = usb_submit_urb(priv->bulk_read_urb, GFP_NOIO);
+        else
+                result = 0;
+        mutex_unlock(&port->mutex);
+        return result;
+}
 static struct usb_driver opticon_driver = {
        .name =         "opticon",
        .probe =        usb_serial_probe,
        .disconnect =   usb_serial_disconnect,
+        .suspend =      opticon_suspend,
+        .resume =       opticon_resume,
        .id_table =     id_table,
        .no_dynamic_id =        1,
 };
@@ -326,9 +531,13 @@ static struct usb_serial_driver opticon_device = {
        .attach =               opticon_startup,
        .open =                 opticon_open,
        .close =                opticon_close,
+        .write =                opticon_write,
+        .write_room =           opticon_write_room,
        .shutdown =             opticon_shutdown,
        .throttle =             opticon_throttle,
        .unthrottle =           opticon_unthrottle,
+        .ioctl =                opticon_ioctl,
+        .tiocmget =             opticon_tiocmget,
 };
 static int __init opticon_init(void)
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 61ebddc48497..d560c0b54e6e 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -62,6 +62,8 @@ static int  option_tiocmget(struct tty_struct *tty, struct file *file);
 static int  option_tiocmset(struct tty_struct *tty, struct file *file,
                                unsigned int set, unsigned int clear);
 static int  option_send_setup(struct tty_struct *tty, struct usb_serial_port *port);
+static int  option_suspend(struct usb_serial *serial, pm_message_t message);
+static int  option_resume(struct usb_serial *serial);
 /* Vendor and product IDs */
 #define OPTION_VENDOR_ID                        0x0AF0
@@ -523,6 +525,8 @@ static struct usb_driver option_driver = {
        .name       = "option",
        .probe      = usb_serial_probe,
        .disconnect = usb_serial_disconnect,
+        .suspend    = usb_serial_suspend,
+        .resume     = usb_serial_resume,
        .id_table   = option_ids,
        .no_dynamic_id =        1,
 };
@@ -551,6 +555,8 @@ static struct usb_serial_driver option_1port_device = {
        .attach            = option_startup,
        .shutdown          = option_shutdown,
        .read_int_callback = option_instat_callback,
+        .suspend           = option_suspend,
+        .resume            = option_resume,
 };
 static int debug;
@@ -821,10 +827,10 @@ static void option_instat_callback(struct urb *urb)
                                req_pkt->bRequestType, req_pkt->bRequest);
                }
        } else
-                dbg("%s: error %d", __func__, status);
+                err("%s: error %d", __func__, status);
        /* Resubmit urb so we continue receiving IRQ data */
-        if (status != -ESHUTDOWN) {
+        if (status != -ESHUTDOWN && status != -ENOENT) {
                urb->dev = serial->dev;
                err = usb_submit_urb(urb, GFP_ATOMIC);
                if (err)
@@ -843,7 +849,6 @@ static int option_write_room(struct tty_struct *tty)
        portdata = usb_get_serial_port_data(port);
        for (i = 0; i < N_OUT_URB; i++) {
                this_urb = portdata->out_urbs[i];
                if (this_urb && !test_bit(i, &portdata->out_busy))
@@ -1105,14 +1110,12 @@ bail_out_error:
        return 1;
 }
-static void option_shutdown(struct usb_serial *serial)
+static void stop_read_write_urbs(struct usb_serial *serial)
 {
        int i, j;
        struct usb_serial_port *port;
        struct option_port_private *portdata;
-        dbg("%s", __func__);
        /* Stop reading/writing urbs */
        for (i = 0; i < serial->num_ports; ++i) {
                port = serial->port[i];
@@ -1122,6 +1125,17 @@ static void option_shutdown(struct usb_serial *serial)
                for (j = 0; j < N_OUT_URB; j++)
                        usb_kill_urb(portdata->out_urbs[j]);
        }
+}
+static void option_shutdown(struct usb_serial *serial)
+{
+        int i, j;
+        struct usb_serial_port *port;
+        struct option_port_private *portdata;
+        dbg("%s", __func__);
+        stop_read_write_urbs(serial);
        /* Now free them */
        for (i = 0; i < serial->num_ports; ++i) {
@@ -1152,6 +1166,66 @@ static void option_shutdown(struct usb_serial *serial)
        }
 }
+static int option_suspend(struct usb_serial *serial, pm_message_t message)
+{
+        dbg("%s entered", __func__);
+        stop_read_write_urbs(serial);
+        return 0;
+}
+static int option_resume(struct usb_serial *serial)
+{
+        int err, i, j;
+        struct usb_serial_port *port;
+        struct urb *urb;
+        struct option_port_private *portdata;
+        dbg("%s entered", __func__);
+        /* get the interrupt URBs resubmitted unconditionally */
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                if (!port->interrupt_in_urb) {
+                        dbg("%s: No interrupt URB for port %d\n", __func__, i);
+                        continue;
+                }
+                port->interrupt_in_urb->dev = serial->dev;
+                err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
+                dbg("Submitted interrupt URB for port %d (result %d)", i, err);
+                if (err < 0) {
+                        err("%s: Error %d for interrupt URB of port%d",
+                                 __func__, err, i);
+                        return err;
+                }
+        }
+        for (i = 0; i < serial->num_ports; i++) {
+                /* walk all ports */
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+                mutex_lock(&port->mutex);
+                /* skip closed ports */
+                if (!port->port.count) {
+                        mutex_unlock(&port->mutex);
+                        continue;
+                }
+                for (j = 0; j < N_IN_URB; j++) {
+                        urb = portdata->in_urbs[j];
+                        err = usb_submit_urb(urb, GFP_NOIO);
+                        if (err < 0) {
+                                mutex_unlock(&port->mutex);
+                                err("%s: Error %d for bulk URB %d",
+                                         __func__, err, i);
+                                return err;
+                        }
+                }
+                mutex_unlock(&port->mutex);
+        }
+        return 0;
+}
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
new file mode 100644
index 000000000000..e6d6b0c17fd9
--- /dev/null
+++ b/drivers/usb/serial/qcserial.c
@@ -0,0 +1,147 @@
+/*
+ * Qualcomm Serial USB driver
+ *
+ *      Copyright (c) 2008 QUALCOMM Incorporated.
+ *      Copyright (c) 2009 Greg Kroah-Hartman <gregkh@suse.de>
+ *      Copyright (c) 2009 Novell Inc.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License version
+ *      2 as published by the Free Software Foundation.
+ *
+ */
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+#define DRIVER_AUTHOR "Qualcomm Inc"
+#define DRIVER_DESC "Qualcomm USB Serial driver"
+static int debug;
+static struct usb_device_id id_table[] = {
+        {USB_DEVICE(0x05c6, 0x9211)},   /* Acer Gobi QDL device */
+        {USB_DEVICE(0x05c6, 0x9212)},   /* Acer Gobi Modem Device */
+        {USB_DEVICE(0x03f0, 0x1f1d)},   /* HP un2400 Gobi Modem Device */
+        {USB_DEVICE(0x03f0, 0x201d)},   /* HP un2400 Gobi QDL Device */
+        { }                             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+static struct usb_driver qcdriver = {
+        .name                   = "qcserial",
+        .probe                  = usb_serial_probe,
+        .disconnect             = usb_serial_disconnect,
+        .id_table               = id_table,
+        .suspend                = usb_serial_suspend,
+        .resume                 = usb_serial_resume,
+        .supports_autosuspend   = true,
+};
+static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
+{
+        int retval = -ENODEV;
+        __u8 nintf;
+        __u8 ifnum;
+        dbg("%s", __func__);
+        nintf = serial->dev->actconfig->desc.bNumInterfaces;
+        dbg("Num Interfaces = %d", nintf);
+        ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
+        dbg("This Interface = %d", ifnum);
+        switch (nintf) {
+        case 1:
+                /* QDL mode */
+                if (serial->interface->num_altsetting == 2) {
+                        struct usb_host_interface *intf;
+                        intf = &serial->interface->altsetting[1];
+                        if (intf->desc.bNumEndpoints == 2) {
+                                if (usb_endpoint_is_bulk_in(&intf->endpoint[0].desc) &&
+                                    usb_endpoint_is_bulk_out(&intf->endpoint[1].desc)) {
+                                        dbg("QDL port found");
+                                        retval = usb_set_interface(serial->dev, ifnum, 1);
+                                        if (retval < 0) {
+                                                dev_err(&serial->dev->dev,
+                                                        "Could not set interface, error %d\n",
+                                                        retval);
+                                                retval = -ENODEV;
+                                        }
+                                        return retval;
+                                }
+                        }
+                }
+                break;
+        case 4:
+                /* Composite mode */
+                if (ifnum == 2) {
+                        dbg("Modem port found");
+                        retval = usb_set_interface(serial->dev, ifnum, 0);
+                        if (retval < 0) {
+                                dev_err(&serial->dev->dev,
+                                        "Could not set interface, error %d\n",
+                                        retval);
+                                retval = -ENODEV;
+                        }
+                        return retval;
+                }
+                break;
+        default:
+                dev_err(&serial->dev->dev,
+                        "unknown number of interfaces: %d\n", nintf);
+                return -ENODEV;
+        }
+        return retval;
+}
+static struct usb_serial_driver qcdevice = {
+        .driver = {
+                .owner     = THIS_MODULE,
+                .name      = "qcserial",
+        },
+        .description         = "Qualcomm USB modem",
+        .id_table            = id_table,
+        .usb_driver          = &qcdriver,
+        .num_ports           = 1,
+        .probe               = qcprobe,
+};
+static int __init qcinit(void)
+{
+        int retval;
+        retval = usb_serial_register(&qcdevice);
+        if (retval)
+                return retval;
+        retval = usb_register(&qcdriver);
+        if (retval) {
+                usb_serial_deregister(&qcdevice);
+                return retval;
+        }
+        return 0;
+}
+static void __exit qcexit(void)
+{
+        usb_deregister(&qcdriver);
+        usb_serial_deregister(&qcdevice);
+}
+module_init(qcinit);
+module_exit(qcexit);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL v2");
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
new file mode 100644
index 000000000000..8b3cbc87adc7
--- /dev/null
+++ b/drivers/usb/serial/symbolserial.c
@@ -0,0 +1,399 @@
+/*
+ * Symbol USB barcode to serial driver
+ *
+ * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de>
+ * Copyright (C) 2009 Novell Inc.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License version
+ *      2 as published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+#include <linux/uaccess.h>
+static int debug;
+static struct usb_device_id id_table[] = {
+        { USB_DEVICE(0x05e0, 0x0600) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+/* This structure holds all of the individual device information */
+struct symbol_private {
+        struct usb_device *udev;
+        struct usb_serial *serial;
+        struct usb_serial_port *port;
+        unsigned char *int_buffer;
+        struct urb *int_urb;
+        int buffer_size;
+        u8 bInterval;
+        u8 int_address;
+        spinlock_t lock;        /* protects the following flags */
+        bool throttled;
+        bool actually_throttled;
+        bool rts;
+};
+static void symbol_int_callback(struct urb *urb)
+{
+        struct symbol_private *priv = urb->context;
+        unsigned char *data = urb->transfer_buffer;
+        struct usb_serial_port *port = priv->port;
+        int status = urb->status;
+        struct tty_struct *tty;
+        int result;
+        int available_room = 0;
+        int data_length;
+        dbg("%s - port %d", __func__, port->number);
+        switch (status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __func__, status);
+                goto exit;
+        }
+        usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
+                              data);
+        if (urb->actual_length > 1) {
+                data_length = urb->actual_length - 1;
+                /*
+                 * Data from the device comes with a 1 byte header:
+                 *
+                 * <size of data>data...
+                 *      This is real data to be sent to the tty layer
+                 * we pretty much just ignore the size and send everything
+                 * else to the tty layer.
+                 */
+                tty = tty_port_tty_get(&port->port);
+                if (tty) {
+                        available_room = tty_buffer_request_room(tty,
+                                                        data_length);
+                        if (available_room) {
+                                tty_insert_flip_string(tty, &data[1],
+                                                       available_room);
+                                tty_flip_buffer_push(tty);
+                        }
+                        tty_kref_put(tty);
+                }
+        } else {
+                dev_dbg(&priv->udev->dev,
+                        "Improper ammount of data received from the device, "
+                        "%d bytes", urb->actual_length);
+        }
+exit:
+        spin_lock(&priv->lock);
+        /* Continue trying to always read if we should */
+        if (!priv->throttled) {
+                usb_fill_int_urb(priv->int_urb, priv->udev,
+                                 usb_rcvintpipe(priv->udev,
+                                                priv->int_address),
+                                 priv->int_buffer, priv->buffer_size,
+                                 symbol_int_callback, priv, priv->bInterval);
+                result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
+                if (result)
+                        dev_err(&port->dev,
+                            "%s - failed resubmitting read urb, error %d\n",
+                                                        __func__, result);
+        } else
+                priv->actually_throttled = true;
+        spin_unlock(&priv->lock);
+}
+static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port,
+                        struct file *filp)
+{
+        struct symbol_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        int result = 0;
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = false;
+        priv->actually_throttled = false;
+        priv->port = port;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        /*
+         * Force low_latency on so that our tty_push actually forces the data
+         * through, otherwise it is scheduled, and with high data rates (like
+         * with OHCI) data can get lost.
+         */
+        if (tty)
+                tty->low_latency = 1;
+        /* Start reading from the device */
+        usb_fill_int_urb(priv->int_urb, priv->udev,
+                         usb_rcvintpipe(priv->udev, priv->int_address),
+                         priv->int_buffer, priv->buffer_size,
+                         symbol_int_callback, priv, priv->bInterval);
+        result = usb_submit_urb(priv->int_urb, GFP_KERNEL);
+        if (result)
+                dev_err(&port->dev,
+                        "%s - failed resubmitting read urb, error %d\n",
+                        __func__, result);
+        return result;
+}
+static void symbol_close(struct tty_struct *tty, struct usb_serial_port *port,
+                          struct file *filp)
+{
+        struct symbol_private *priv = usb_get_serial_data(port->serial);
+        dbg("%s - port %d", __func__, port->number);
+        /* shutdown our urbs */
+        usb_kill_urb(priv->int_urb);
+}
+static void symbol_throttle(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct symbol_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = true;
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+static void symbol_unthrottle(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct symbol_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        int result;
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = false;
+        priv->actually_throttled = false;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        priv->int_urb->dev = port->serial->dev;
+        result = usb_submit_urb(priv->int_urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&port->dev,
+                        "%s - failed submitting read urb, error %d\n",
+                                                        __func__, result);
+}
+static int symbol_ioctl(struct tty_struct *tty, struct file *file,
+                        unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct device *dev = &port->dev;
+        /*
+         * Right now we need to figure out what commands
+         * most userspace tools want to see for this driver,
+         * so just log the things.
+         */
+        switch (cmd) {
+        case TIOCSERGETLSR:
+                dev_info(dev, "%s: TIOCSERGETLSR\n", __func__);
+                break;
+        case TIOCGSERIAL:
+                dev_info(dev, "%s: TIOCGSERIAL\n", __func__);
+                break;
+        case TIOCMIWAIT:
+                dev_info(dev, "%s: TIOCMIWAIT\n", __func__);
+                break;
+        case TIOCGICOUNT:
+                dev_info(dev, "%s: TIOCGICOUNT\n", __func__);
+                break;
+        default:
+                dev_info(dev, "%s: unknown (%d)\n", __func__, cmd);
+        }
+        return -ENOIOCTLCMD;
+}
+static int symbol_tiocmget(struct tty_struct *tty, struct file *file)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct device *dev = &port->dev;
+        /* TODO */
+        /* probably just need to shadow whatever was sent to us here */
+        dev_info(dev, "%s\n", __func__);
+        return 0;
+}
+static int symbol_tiocmset(struct tty_struct *tty, struct file *file,
+                           unsigned int set, unsigned int clear)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct device *dev = &port->dev;
+        /* TODO */
+        /* probably just need to shadow whatever was sent to us here */
+        dev_info(dev, "%s\n", __func__);
+        return 0;
+}
+static int symbol_startup(struct usb_serial *serial)
+{
+        struct symbol_private *priv;
+        struct usb_host_interface *intf;
+        int i;
+        int retval = -ENOMEM;
+        bool int_in_found = false;
+        /* create our private serial structure */
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (priv == NULL) {
+                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+                return -ENOMEM;
+        }
+        spin_lock_init(&priv->lock);
+        priv->serial = serial;
+        priv->port = serial->port[0];
+        priv->udev = serial->dev;
+        /* find our interrupt endpoint */
+        intf = serial->interface->altsetting;
+        for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
+                struct usb_endpoint_descriptor *endpoint;
+                endpoint = &intf->endpoint[i].desc;
+                if (!usb_endpoint_is_int_in(endpoint))
+                        continue;
+                priv->int_urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!priv->int_urb) {
+                        dev_err(&priv->udev->dev, "out of memory\n");
+                        goto error;
+                }
+                priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
+                priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
+                if (!priv->int_buffer) {
+                        dev_err(&priv->udev->dev, "out of memory\n");
+                        goto error;
+                }
+                priv->int_address = endpoint->bEndpointAddress;
+                priv->bInterval = endpoint->bInterval;
+                /* set up our int urb */
+                usb_fill_int_urb(priv->int_urb, priv->udev,
+                                 usb_rcvintpipe(priv->udev,
+                                                endpoint->bEndpointAddress),
+                                 priv->int_buffer, priv->buffer_size,
+                                 symbol_int_callback, priv, priv->bInterval);
+                int_in_found = true;
+                break;
+                }
+        if (!int_in_found) {
+                dev_err(&priv->udev->dev,
+                        "Error - the proper endpoints were not found!\n");
+                goto error;
+        }
+        usb_set_serial_data(serial, priv);
+        return 0;
+error:
+        usb_free_urb(priv->int_urb);
+        kfree(priv->int_buffer);
+        kfree(priv);
+        return retval;
+}
+static void symbol_shutdown(struct usb_serial *serial)
+{
+        struct symbol_private *priv = usb_get_serial_data(serial);
+        dbg("%s", __func__);
+        usb_kill_urb(priv->int_urb);
+        usb_free_urb(priv->int_urb);
+        kfree(priv->int_buffer);
+        kfree(priv);
+        usb_set_serial_data(serial, NULL);
+}
+static struct usb_driver symbol_driver = {
+        .name =                 "symbol",
+        .probe =                usb_serial_probe,
+        .disconnect =           usb_serial_disconnect,
+        .id_table =             id_table,
+        .no_dynamic_id =        1,
+};
+static struct usb_serial_driver symbol_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "symbol",
+        },
+        .id_table =             id_table,
+        .usb_driver =           &symbol_driver,
+        .num_ports =            1,
+        .attach =               symbol_startup,
+        .open =                 symbol_open,
+        .close =                symbol_close,
+        .shutdown =             symbol_shutdown,
+        .throttle =             symbol_throttle,
+        .unthrottle =           symbol_unthrottle,
+        .ioctl =                symbol_ioctl,
+        .tiocmget =             symbol_tiocmget,
+        .tiocmset =             symbol_tiocmset,
+};
+static int __init symbol_init(void)
+{
+        int retval;
+        retval = usb_serial_register(&symbol_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&symbol_driver);
+        if (retval)
+                usb_serial_deregister(&symbol_device);
+        return retval;
+}
+static void __exit symbol_exit(void)
+{
+        usb_deregister(&symbol_driver);
+        usb_serial_deregister(&symbol_device);
+}
+module_init(symbol_init);
+module_exit(symbol_exit);
+MODULE_LICENSE("GPL");
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index cfcfd5ab06ce..742a5bc44be8 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -204,6 +204,11 @@ static int serial_open (struct tty_struct *tty, struct file *filp)
                goto bailout_kref_put;
        }
+        if (port->serial->disconnected) {
+                retval = -ENODEV;
+                goto bailout_kref_put;
+        }
        if (mutex_lock_interruptible(&port->mutex)) {
                retval = -ERESTARTSYS;
                goto bailout_kref_put;
@@ -1067,6 +1072,8 @@ int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
        struct usb_serial_port *port;
        int i, r = 0;
+        serial->suspending = 1;
        for (i = 0; i < serial->num_ports; ++i) {
                port = serial->port[i];
                if (port)
@@ -1083,10 +1090,15 @@ EXPORT_SYMBOL(usb_serial_suspend);
 int usb_serial_resume(struct usb_interface *intf)
 {
        struct usb_serial *serial = usb_get_intfdata(intf);
+        int rv;
+        serial->suspending = 0;
        if (serial->type->resume)
-                return serial->type->resume(serial);
+                rv = serial->type->resume(serial);
-        return 0;
+        else
+                rv = usb_serial_generic_resume(serial);
+        return rv;
 }
 EXPORT_SYMBOL(usb_serial_resume);
@@ -1222,7 +1234,6 @@ static void fixup_generic(struct usb_serial_driver *device)
        set_to_generic_if_null(device, read_bulk_callback);
        set_to_generic_if_null(device, write_bulk_callback);
        set_to_generic_if_null(device, shutdown);
-        set_to_generic_if_null(device, resume);
 }
 int usb_serial_register(struct usb_serial_driver *driver)
@@ -1230,6 +1241,9 @@ int usb_serial_register(struct usb_serial_driver *driver)
        /* must be called with BKL held */
        int retval;
+        if (usb_disabled())
+                return -ENODEV;
        fixup_generic(driver);
        if (!driver->description)
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 9df6887b91f6..8a372bac0e43 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -2,8 +2,8 @@
 # USB Storage driver configuration
 #
-comment "NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed;"
+comment "NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may"
-comment "see USB_STORAGE Help for more information"
+comment "also be needed; see USB_STORAGE Help for more info"
        depends on USB
 config USB_STORAGE
@@ -32,21 +32,25 @@ config USB_STORAGE_DEBUG
          verbose debugging messages.
 config USB_STORAGE_DATAFAB
-        bool "Datafab Compact Flash Reader support"
+        tristate "Datafab Compact Flash Reader support"
        depends on USB_STORAGE
        help
          Support for certain Datafab CompactFlash readers.
          Datafab has a web page at <http://www.datafabusa.com/>.
+          If this driver is compiled as a module, it will be named ums-datafab.
 config USB_STORAGE_FREECOM
-        bool "Freecom USB/ATAPI Bridge support"
+        tristate "Freecom USB/ATAPI Bridge support"
        depends on USB_STORAGE
        help
          Support for the Freecom USB to IDE/ATAPI adaptor.
          Freecom has a web page at <http://www.freecom.de/>.
+          If this driver is compiled as a module, it will be named ums-freecom.
 config USB_STORAGE_ISD200
-        bool "ISD-200 USB/ATA Bridge support"
+        tristate "ISD-200 USB/ATA Bridge support"
        depends on USB_STORAGE
        ---help---
          Say Y here if you want to use USB Mass Store devices based
@@ -61,8 +65,10 @@ config USB_STORAGE_ISD200
          - CyQ've CQ8060A CDRW drive
          - Planex eXtreme Drive RX-25HU USB-IDE cable (not model RX-25U)
+          If this driver is compiled as a module, it will be named ums-isd200.
 config USB_STORAGE_USBAT
-        bool "USBAT/USBAT02-based storage support"
+        tristate "USBAT/USBAT02-based storage support"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support storage devices
@@ -82,30 +88,38 @@ config USB_STORAGE_USBAT
          - RCA LYRA MP3 portable
          - Sandisk ImageMate SDDR-05b
+          If this driver is compiled as a module, it will be named ums-usbat.
 config USB_STORAGE_SDDR09
-        bool "SanDisk SDDR-09 (and other SmartMedia, including DPCM) support"
+        tristate "SanDisk SDDR-09 (and other SmartMedia, including DPCM) support"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support the Sandisk SDDR-09
          SmartMedia reader in the USB Mass Storage driver.
          Also works for the Microtech Zio! CompactFlash/SmartMedia reader.
+          If this driver is compiled as a module, it will be named ums-sddr09.
 config USB_STORAGE_SDDR55
-        bool "SanDisk SDDR-55 SmartMedia support"
+        tristate "SanDisk SDDR-55 SmartMedia support"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support the Sandisk SDDR-55
          SmartMedia reader in the USB Mass Storage driver.
+          If this driver is compiled as a module, it will be named ums-sddr55.
 config USB_STORAGE_JUMPSHOT
-        bool "Lexar Jumpshot Compact Flash Reader"
+        tristate "Lexar Jumpshot Compact Flash Reader"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support the Lexar Jumpshot
          USB CompactFlash reader.
+          If this driver is compiled as a module, it will be named ums-jumpshot.
 config USB_STORAGE_ALAUDA
-        bool "Olympus MAUSB-10/Fuji DPC-R1 support"
+        tristate "Olympus MAUSB-10/Fuji DPC-R1 support"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support the Olympus MAUSB-10
@@ -114,8 +128,10 @@ config USB_STORAGE_ALAUDA
          These devices are based on the Alauda chip and support both
          XD and SmartMedia cards.
+          If this driver is compiled as a module, it will be named ums-alauda.
 config USB_STORAGE_ONETOUCH
-        bool "Support OneTouch Button on Maxtor Hard Drives"
+        tristate "Support OneTouch Button on Maxtor Hard Drives"
        depends on USB_STORAGE
        depends on INPUT=y || INPUT=USB_STORAGE
        help
@@ -127,8 +143,10 @@ config USB_STORAGE_ONETOUCH
          this input in any keybinding software. (e.g. gnome's keyboard short-
          cuts)
+          If this driver is compiled as a module, it will be named ums-onetouch.
 config USB_STORAGE_KARMA
-        bool "Support for Rio Karma music player"
+        tristate "Support for Rio Karma music player"
        depends on USB_STORAGE
        help
          Say Y here to include additional code to support the Rio Karma
@@ -139,8 +157,10 @@ config USB_STORAGE_KARMA
          on the resulting scsi device node returns the Karma to normal
          operation.
+          If this driver is compiled as a module, it will be named ums-karma.
 config USB_STORAGE_CYPRESS_ATACB
-        bool "SAT emulation on Cypress USB/ATA Bridge with ATACB"
+        tristate "SAT emulation on Cypress USB/ATA Bridge with ATACB"
        depends on USB_STORAGE
        ---help---
          Say Y here if you want to use SAT (ata pass through) on devices based
@@ -150,6 +170,8 @@ config USB_STORAGE_CYPRESS_ATACB
          If you say no here your device will still work with the standard usb
          mass storage class.
+          If this driver is compiled as a module, it will be named ums-cypress.
 config USB_LIBUSUAL
        bool "The shared table of common (or usual) storage devices"
        depends on USB
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index b32069313390..5be54c019662 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -10,21 +10,36 @@ EXTRA_CFLAGS	:= -Idrivers/scsi
 obj-$(CONFIG_USB_STORAGE)       += usb-storage.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_DEBUG)     += debug.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_USBAT)     += shuttle_usbat.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR09)    += sddr09.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR55)    += sddr55.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_FREECOM)   += freecom.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)    += isd200.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)   += datafab.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)  += jumpshot.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_ALAUDA)    += alauda.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_ONETOUCH)  += onetouch.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_KARMA)     += karma.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += cypress_atacb.o
 usb-storage-objs :=     scsiglue.o protocol.o transport.o usb.o \
                        initializers.o sierra_ms.o option_ms.o $(usb-storage-obj-y)
-ifneq ($(CONFIG_USB_LIBUSUAL),)
+ifeq ($(CONFIG_USB_LIBUSUAL),)
-        obj-$(CONFIG_USB)       += libusual.o
+        usb-storage-objs        += usual-tables.o
+else
+        obj-$(CONFIG_USB)       += libusual.o usual-tables.o
 endif
+obj-$(CONFIG_USB_STORAGE_ALAUDA)        += ums-alauda.o
+obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += ums-cypress.o
+obj-$(CONFIG_USB_STORAGE_DATAFAB)       += ums-datafab.o
+obj-$(CONFIG_USB_STORAGE_FREECOM)       += ums-freecom.o
+obj-$(CONFIG_USB_STORAGE_ISD200)        += ums-isd200.o
+obj-$(CONFIG_USB_STORAGE_JUMPSHOT)      += ums-jumpshot.o
+obj-$(CONFIG_USB_STORAGE_KARMA)         += ums-karma.o
+obj-$(CONFIG_USB_STORAGE_ONETOUCH)      += ums-onetouch.o
+obj-$(CONFIG_USB_STORAGE_SDDR09)        += ums-sddr09.o
+obj-$(CONFIG_USB_STORAGE_SDDR55)        += ums-sddr55.o
+obj-$(CONFIG_USB_STORAGE_USBAT)         += ums-usbat.o
+ums-alauda-objs         := alauda.o
+ums-cypress-objs        := cypress_atacb.o
+ums-datafab-objs        := datafab.o
+ums-freecom-objs        := freecom.o
+ums-isd200-objs         := isd200.o
+ums-jumpshot-objs       := jumpshot.o
+ums-karma-objs          := karma.o
+ums-onetouch-objs       := onetouch.o
+ums-sddr09-objs         := sddr09.o
+ums-sddr55-objs         := sddr55.o
+ums-usbat-objs          := shuttle_usbat.o
diff --git a/drivers/usb/storage/alauda.c b/drivers/usb/storage/alauda.c
index 8d3711a7ff06..67edc65acb8e 100644
--- a/drivers/usb/storage/alauda.c
+++ b/drivers/usb/storage/alauda.c
@@ -31,6 +31,8 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
+#include <linux/module.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -39,7 +41,79 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "alauda.h"
+MODULE_DESCRIPTION("Driver for Alauda-based card readers");
+MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>");
+MODULE_LICENSE("GPL");
+/*
+ * Status bytes
+ */
+#define ALAUDA_STATUS_ERROR             0x01
+#define ALAUDA_STATUS_READY             0x40
+/*
+ * Control opcodes (for request field)
+ */
+#define ALAUDA_GET_XD_MEDIA_STATUS      0x08
+#define ALAUDA_GET_SM_MEDIA_STATUS      0x98
+#define ALAUDA_ACK_XD_MEDIA_CHANGE      0x0a
+#define ALAUDA_ACK_SM_MEDIA_CHANGE      0x9a
+#define ALAUDA_GET_XD_MEDIA_SIG         0x86
+#define ALAUDA_GET_SM_MEDIA_SIG         0x96
+/*
+ * Bulk command identity (byte 0)
+ */
+#define ALAUDA_BULK_CMD                 0x40
+/*
+ * Bulk opcodes (byte 1)
+ */
+#define ALAUDA_BULK_GET_REDU_DATA       0x85
+#define ALAUDA_BULK_READ_BLOCK          0x94
+#define ALAUDA_BULK_ERASE_BLOCK         0xa3
+#define ALAUDA_BULK_WRITE_BLOCK         0xb4
+#define ALAUDA_BULK_GET_STATUS2         0xb7
+#define ALAUDA_BULK_RESET_MEDIA         0xe0
+/*
+ * Port to operate on (byte 8)
+ */
+#define ALAUDA_PORT_XD                  0x00
+#define ALAUDA_PORT_SM                  0x01
+/*
+ * LBA and PBA are unsigned ints. Special values.
+ */
+#define UNDEF    0xffff
+#define SPARE    0xfffe
+#define UNUSABLE 0xfffd
+struct alauda_media_info {
+        unsigned long capacity;         /* total media size in bytes */
+        unsigned int pagesize;          /* page size in bytes */
+        unsigned int blocksize;         /* number of pages per block */
+        unsigned int uzonesize;         /* number of usable blocks per zone */
+        unsigned int zonesize;          /* number of blocks per zone */
+        unsigned int blockmask;         /* mask to get page from address */
+        unsigned char pageshift;
+        unsigned char blockshift;
+        unsigned char zoneshift;
+        u16 **lba_to_pba;               /* logical to physical block map */
+        u16 **pba_to_lba;               /* physical to logical block map */
+};
+struct alauda_info {
+        struct alauda_media_info port[2];
+        int wr_ep;                      /* endpoint to write data out of */
+        unsigned char sense_key;
+        unsigned long sense_asc;        /* additional sense code */
+        unsigned long sense_ascq;       /* additional sense code qualifier */
+};
 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
 #define LSB_of(s) ((s)&0xFF)
@@ -52,6 +126,48 @@
 #define PBA_HI(pba) (pba >> 3)
 #define PBA_ZONE(pba) (pba >> 11)
+static int init_alauda(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id alauda_usb_ids[] = {
+#       include "unusual_alauda.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, alauda_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev alauda_unusual_dev_list[] = {
+#       include "unusual_alauda.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 /*
 * Media handling
 */
@@ -307,7 +423,8 @@ static int alauda_init_media(struct us_data *us)
                data[0], data[1], data[2], data[3]);
        media_info = alauda_card_find_id(data[1]);
        if (media_info == NULL) {
-                printk("alauda_init_media: Unrecognised media signature: "
+                printk(KERN_WARNING
+                        "alauda_init_media: Unrecognised media signature: "
                        "%02X %02X %02X %02X\n",
                        data[0], data[1], data[2], data[3]);
                return USB_STOR_TRANSPORT_ERROR;
@@ -518,7 +635,8 @@ static int alauda_read_map(struct us_data *us, unsigned int zone)
                /* check even parity */
                if (parity[data[6] ^ data[7]]) {
-                        printk("alauda_read_map: Bad parity in LBA for block %d"
+                        printk(KERN_WARNING
+                               "alauda_read_map: Bad parity in LBA for block %d"
                               " (%02X %02X)\n", i, data[6], data[7]);
                        pba_to_lba[i] = UNUSABLE;
                        continue;
@@ -538,13 +656,16 @@ static int alauda_read_map(struct us_data *us, unsigned int zone)
                 */
                if (lba_offset >= uzonesize) {
-                        printk("alauda_read_map: Bad low LBA %d for block %d\n",
+                        printk(KERN_WARNING
+                               "alauda_read_map: Bad low LBA %d for block %d\n",
                               lba_real, blocknum);
                        continue;
                }
                if (lba_to_pba[lba_offset] != UNDEF) {
-                        printk("alauda_read_map: LBA %d seen for PBA %d and %d\n",
+                        printk(KERN_WARNING
+                               "alauda_read_map: "
+                               "LBA %d seen for PBA %d and %d\n",
                               lba_real, lba_to_pba[lba_offset], blocknum);
                        continue;
                }
@@ -712,13 +833,15 @@ static int alauda_write_lba(struct us_data *us, u16 lba,
        if (pba == 1) {
                /* Maybe it is impossible to write to PBA 1.
                   Fake success, but don't do anything. */
-                printk("alauda_write_lba: avoid writing to pba 1\n");
+                printk(KERN_WARNING
+                       "alauda_write_lba: avoid writing to pba 1\n");
                return USB_STOR_TRANSPORT_GOOD;
        }
        new_pba = alauda_find_unused_pba(&MEDIA_INFO(us), zone);
        if (!new_pba) {
-                printk("alauda_write_lba: Out of unused blocks\n");
+                printk(KERN_WARNING
+                       "alauda_write_lba: Out of unused blocks\n");
                return USB_STOR_TRANSPORT_ERROR;
        }
@@ -818,7 +941,7 @@ static int alauda_read_data(struct us_data *us, unsigned long address,
        len = min(sectors, blocksize) * (pagesize + 64);
        buffer = kmalloc(len, GFP_NOIO);
        if (buffer == NULL) {
-                printk("alauda_read_data: Out of memory\n");
+                printk(KERN_WARNING "alauda_read_data: Out of memory\n");
                return USB_STOR_TRANSPORT_ERROR;
        }
@@ -911,7 +1034,7 @@ static int alauda_write_data(struct us_data *us, unsigned long address,
        len = min(sectors, blocksize) * pagesize;
        buffer = kmalloc(len, GFP_NOIO);
        if (buffer == NULL) {
-                printk("alauda_write_data: Out of memory\n");
+                printk(KERN_WARNING "alauda_write_data: Out of memory\n");
                return USB_STOR_TRANSPORT_ERROR;
        }
@@ -921,7 +1044,7 @@ static int alauda_write_data(struct us_data *us, unsigned long address,
         */
        blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO);
        if (blockbuffer == NULL) {
-                printk("alauda_write_data: Out of memory\n");
+                printk(KERN_WARNING "alauda_write_data: Out of memory\n");
                kfree(buffer);
                return USB_STOR_TRANSPORT_ERROR;
        }
@@ -991,7 +1114,7 @@ static void alauda_info_destructor(void *extra)
 /*
 * Initialize alauda_info struct and find the data-write endpoint
 */
-int init_alauda(struct us_data *us)
+static int init_alauda(struct us_data *us)
 {
        struct alauda_info *info;
        struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting;
@@ -1013,7 +1136,7 @@ int init_alauda(struct us_data *us)
        return USB_STOR_TRANSPORT_GOOD;
 }
-int alauda_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int alauda_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        int rc;
        struct alauda_info *info = (struct alauda_info *) us->extra;
@@ -1121,3 +1244,48 @@ int alauda_transport(struct scsi_cmnd *srb, struct us_data *us)
        return USB_STOR_TRANSPORT_FAILED;
 }
+static int alauda_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - alauda_usb_ids) + alauda_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name  = "Alauda Control/Bulk";
+        us->transport = alauda_transport;
+        us->transport_reset = usb_stor_Bulk_reset;
+        us->max_lun = 1;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver alauda_driver = {
+        .name =         "ums-alauda",
+        .probe =        alauda_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     alauda_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init alauda_init(void)
+{
+        return usb_register(&alauda_driver);
+}
+static void __exit alauda_exit(void)
+{
+        usb_deregister(&alauda_driver);
+}
+module_init(alauda_init);
+module_exit(alauda_exit);
diff --git a/drivers/usb/storage/alauda.h b/drivers/usb/storage/alauda.h
deleted file mode 100644
index a700f87d0803..000000000000
--- a/drivers/usb/storage/alauda.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Driver for Alauda-based card readers
- *
- * Current development and maintenance by:
- *    (c) 2005 Daniel Drake <dsd@gentoo.org>
- *
- * See alauda.c for more explanation.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef _USB_ALAUDA_H
-#define _USB_ALAUDA_H
-/*
- * Status bytes
- */
-#define ALAUDA_STATUS_ERROR             0x01
-#define ALAUDA_STATUS_READY             0x40
-/*
- * Control opcodes (for request field)
- */
-#define ALAUDA_GET_XD_MEDIA_STATUS      0x08
-#define ALAUDA_GET_SM_MEDIA_STATUS      0x98
-#define ALAUDA_ACK_XD_MEDIA_CHANGE      0x0a
-#define ALAUDA_ACK_SM_MEDIA_CHANGE      0x9a
-#define ALAUDA_GET_XD_MEDIA_SIG         0x86
-#define ALAUDA_GET_SM_MEDIA_SIG         0x96
-/*
- * Bulk command identity (byte 0)
- */
-#define ALAUDA_BULK_CMD                 0x40
-/*
- * Bulk opcodes (byte 1)
- */
-#define ALAUDA_BULK_GET_REDU_DATA       0x85
-#define ALAUDA_BULK_READ_BLOCK          0x94
-#define ALAUDA_BULK_ERASE_BLOCK         0xa3
-#define ALAUDA_BULK_WRITE_BLOCK         0xb4
-#define ALAUDA_BULK_GET_STATUS2         0xb7
-#define ALAUDA_BULK_RESET_MEDIA         0xe0
-/*
- * Port to operate on (byte 8)
- */
-#define ALAUDA_PORT_XD                  0x00
-#define ALAUDA_PORT_SM                  0x01
-/*
- * LBA and PBA are unsigned ints. Special values.
- */
-#define UNDEF    0xffff
-#define SPARE    0xfffe
-#define UNUSABLE 0xfffd
-int init_alauda(struct us_data *us);
-int alauda_transport(struct scsi_cmnd *srb, struct us_data *us);
-struct alauda_media_info {
-        unsigned long capacity;         /* total media size in bytes */
-        unsigned int pagesize;          /* page size in bytes */
-        unsigned int blocksize;         /* number of pages per block */
-        unsigned int uzonesize;         /* number of usable blocks per zone */
-        unsigned int zonesize;          /* number of blocks per zone */
-        unsigned int blockmask;         /* mask to get page from address */
-        unsigned char pageshift;
-        unsigned char blockshift;
-        unsigned char zoneshift;
-        u16 **lba_to_pba;               /* logical to physical block map */
-        u16 **pba_to_lba;               /* physical to logical block map */
-};
-struct alauda_info {
-        struct alauda_media_info port[2];
-        int wr_ep;                      /* endpoint to write data out of */
-        unsigned char sense_key;
-        unsigned long sense_asc;        /* additional sense code */
-        unsigned long sense_ascq;       /* additional sense code qualifier */
-};
-#endif
diff --git a/drivers/usb/storage/cypress_atacb.c b/drivers/usb/storage/cypress_atacb.c
index 898e67d30e56..c84471821183 100644
--- a/drivers/usb/storage/cypress_atacb.c
+++ b/drivers/usb/storage/cypress_atacb.c
@@ -19,6 +19,7 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
+#include <linux/module.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_eh.h>
@@ -29,6 +30,49 @@
 #include "scsiglue.h"
 #include "debug.h"
+MODULE_DESCRIPTION("SAT support for Cypress USB/ATA bridges with ATACB");
+MODULE_AUTHOR("Matthieu Castet <castet.matthieu@free.fr>");
+MODULE_LICENSE("GPL");
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id cypress_usb_ids[] = {
+#       include "unusual_cypress.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, cypress_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev cypress_unusual_dev_list[] = {
+#       include "unusual_cypress.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 /*
 * ATACB is a protocol used on cypress usb<->ata bridge to
 * send raw ATA command over mass storage
@@ -36,7 +80,7 @@
 * More info that be found on cy7c68310_8.pdf and cy7c68300c_8.pdf
 * datasheet from cypress.com.
 */
-void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
+static void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
 {
        unsigned char save_cmnd[MAX_COMMAND_SIZE];
@@ -133,19 +177,18 @@ void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
                /* build the command for
                 * reading the ATA registers */
-                scsi_eh_prep_cmnd(srb, &ses, NULL, 0, 0);
+                scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sizeof(regs));
-                srb->sdb.length = sizeof(regs);
-                sg_init_one(&ses.sense_sgl, regs, srb->sdb.length);
-                srb->sdb.table.sgl = &ses.sense_sgl;
-                srb->sc_data_direction = DMA_FROM_DEVICE;
-                srb->sdb.table.nents = 1;
                /* we use the same command as before, but we set
                 * the read taskfile bit, for not executing atacb command,
                 * but reading register selected in srb->cmnd[4]
                 */
+                srb->cmd_len = 16;
+                srb->cmnd = ses.cmnd;
                srb->cmnd[2] = 1;
                usb_stor_transparent_scsi_command(srb, us);
+                memcpy(regs, srb->sense_buffer, sizeof(regs));
                tmp_result = srb->result;
                scsi_eh_restore_cmnd(srb, &ses);
                /* we fail to get registers, report invalid command */
@@ -162,8 +205,8 @@ void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
                /* XXX we should generate sk, asc, ascq from status and error
                 * regs
-                 * (see 11.1 Error translation � ATA device error to SCSI error map)
+                 * (see 11.1 Error translation ATA device error to SCSI error
-                 * and ata_to_sense_error from libata.
+                 *  map, and ata_to_sense_error from libata.)
                 */
                /* Sense data is current and format is descriptor. */
@@ -198,3 +241,48 @@ end:
        if (srb->cmnd[0] == ATA_12)
                srb->cmd_len = 12;
 }
+static int cypress_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - cypress_usb_ids) + cypress_unusual_dev_list);
+        if (result)
+                return result;
+        us->protocol_name = "Transparent SCSI with Cypress ATACB";
+        us->proto_handler = cypress_atacb_passthrough;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver cypress_driver = {
+        .name =         "ums-cypress",
+        .probe =        cypress_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     cypress_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init cypress_init(void)
+{
+        return usb_register(&cypress_driver);
+}
+static void __exit cypress_exit(void)
+{
+        usb_deregister(&cypress_driver);
+}
+module_init(cypress_init);
+module_exit(cypress_exit);
diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c
index 17f1ae232919..2b6e565262c2 100644
--- a/drivers/usb/storage/datafab.c
+++ b/drivers/usb/storage/datafab.c
@@ -49,6 +49,7 @@
 */
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <scsi/scsi.h>
@@ -58,12 +59,65 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "datafab.h"
+MODULE_DESCRIPTION("Driver for Datafab USB Compact Flash reader");
+MODULE_AUTHOR("Jimmie Mayfield <mayfield+datafab@sackheads.org>");
+MODULE_LICENSE("GPL");
+struct datafab_info {
+        unsigned long   sectors;        /* total sector count */
+        unsigned long   ssize;          /* sector size in bytes */
+        signed char     lun;            /* used for dual-slot readers */
+        /* the following aren't used yet */
+        unsigned char   sense_key;
+        unsigned long   sense_asc;      /* additional sense code */
+        unsigned long   sense_ascq;     /* additional sense code qualifier */
+};
 static int datafab_determine_lun(struct us_data *us,
                                 struct datafab_info *info);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id datafab_usb_ids[] = {
+#       include "unusual_datafab.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, datafab_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev datafab_unusual_dev_list[] = {
+#       include "unusual_datafab.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 static inline int
 datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) {
        if (len == 0)
@@ -500,7 +554,7 @@ static void datafab_info_destructor(void *extra)
 // Transport for the Datafab MDCFE-B
 //
-int datafab_transport(struct scsi_cmnd * srb, struct us_data *us)
+static int datafab_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        struct datafab_info *info;
        int rc;
@@ -665,3 +719,49 @@ int datafab_transport(struct scsi_cmnd * srb, struct us_data *us)
        info->sense_ascq = 0x00;
        return USB_STOR_TRANSPORT_FAILED;
 }
+static int datafab_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - datafab_usb_ids) + datafab_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name  = "Datafab Bulk-Only";
+        us->transport = datafab_transport;
+        us->transport_reset = usb_stor_Bulk_reset;
+        us->max_lun = 1;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver datafab_driver = {
+        .name =         "ums-datafab",
+        .probe =        datafab_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     datafab_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init datafab_init(void)
+{
+        return usb_register(&datafab_driver);
+}
+static void __exit datafab_exit(void)
+{
+        usb_deregister(&datafab_driver);
+}
+module_init(datafab_init);
+module_exit(datafab_exit);
diff --git a/drivers/usb/storage/datafab.h b/drivers/usb/storage/datafab.h
deleted file mode 100644
index 32e3f271e582..000000000000
--- a/drivers/usb/storage/datafab.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Driver for Datafab MDCFE-B USB Compact Flash reader
- * Header File
- *
- * Current development and maintenance by:
- *   (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org)
- *
- * See datafab.c for more explanation
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef _USB_DATAFAB_MDCFE_B_H
-#define _USB_DATAFAB_MDCFE_B_H
-extern int datafab_transport(struct scsi_cmnd *srb, struct us_data *us);
-struct datafab_info {
-        unsigned long   sectors;        // total sector count
-        unsigned long   ssize;          // sector size in bytes
-        signed char     lun;            // used for dual-slot readers
-        
-        // the following aren't used yet
-        unsigned char   sense_key;
-        unsigned long   sense_asc;      // additional sense code
-        unsigned long   sense_ascq;     // additional sense code qualifier
-};
-#endif
diff --git a/drivers/usb/storage/freecom.c b/drivers/usb/storage/freecom.c
index 73ac7262239e..54cc94277acb 100644
--- a/drivers/usb/storage/freecom.c
+++ b/drivers/usb/storage/freecom.c
@@ -26,6 +26,7 @@
 * (http://www.freecom.de/)
 */
+#include <linux/module.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -33,7 +34,10 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "freecom.h"
+MODULE_DESCRIPTION("Driver for Freecom USB/IDE adaptor");
+MODULE_AUTHOR("David Brown <usb-storage@davidb.org>");
+MODULE_LICENSE("GPL");
 #ifdef CONFIG_USB_STORAGE_DEBUG
 static void pdump (void *, int);
@@ -103,6 +107,47 @@ struct freecom_status {
 #define FCM_PACKET_LENGTH               64
 #define FCM_STATUS_PACKET_LENGTH        4
+static int init_freecom(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id freecom_usb_ids[] = {
+#       include "unusual_freecom.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, freecom_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev freecom_unusual_dev_list[] = {
+#       include "unusual_freecom.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 static int
 freecom_readdata (struct scsi_cmnd *srb, struct us_data *us,
                unsigned int ipipe, unsigned int opipe, int count)
@@ -173,7 +218,7 @@ freecom_writedata (struct scsi_cmnd *srb, struct us_data *us,
 * Transport for the Freecom USB/IDE adaptor.
 *
 */
-int freecom_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int freecom_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        struct freecom_cb_wrap *fcb;
        struct freecom_status  *fst;
@@ -377,8 +422,7 @@ int freecom_transport(struct scsi_cmnd *srb, struct us_data *us)
        return USB_STOR_TRANSPORT_GOOD;
 }
-int
+static int init_freecom(struct us_data *us)
-freecom_init (struct us_data *us)
 {
        int result;
        char *buffer = us->iobuf;
@@ -417,7 +461,7 @@ freecom_init (struct us_data *us)
        return USB_STOR_TRANSPORT_GOOD;
 }
-int usb_stor_freecom_reset(struct us_data *us)
+static int usb_stor_freecom_reset(struct us_data *us)
 {
        printk (KERN_CRIT "freecom reset called\n");
@@ -479,3 +523,48 @@ static void pdump (void *ibuffer, int length)
 }
 #endif
+static int freecom_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - freecom_usb_ids) + freecom_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name = "Freecom";
+        us->transport = freecom_transport;
+        us->transport_reset = usb_stor_freecom_reset;
+        us->max_lun = 0;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver freecom_driver = {
+        .name =         "ums-freecom",
+        .probe =        freecom_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     freecom_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init freecom_init(void)
+{
+        return usb_register(&freecom_driver);
+}
+static void __exit freecom_exit(void)
+{
+        usb_deregister(&freecom_driver);
+}
+module_init(freecom_init);
+module_exit(freecom_exit);
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 383abf2516a5..882c57b399f7 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -44,6 +44,7 @@
 #include <linux/jiffies.h>
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/hdreg.h>
 #include <linux/scatterlist.h>
@@ -57,7 +58,53 @@
 #include "protocol.h"
 #include "debug.h"
 #include "scsiglue.h"
-#include "isd200.h"
+MODULE_DESCRIPTION("Driver for In-System Design, Inc. ISD200 ASIC");
+MODULE_AUTHOR("Bj�rn Stenberg <bjorn@haxx.se>");
+MODULE_LICENSE("GPL");
+static int isd200_Initialization(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id isd200_usb_ids[] = {
+#       include "unusual_isd200.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, isd200_usb_ids);
+#undef UNUSUAL_DEV
+#undef USUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev isd200_unusual_dev_list[] = {
+#       include "unusual_isd200.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
+#undef USUAL_DEV
 /* Timeout defines (in Seconds) */
@@ -1518,7 +1565,7 @@ static int isd200_init_info(struct us_data *us)
 * Initialization for the ISD200 
 */
-int isd200_Initialization(struct us_data *us)
+static int isd200_Initialization(struct us_data *us)
 {
        US_DEBUGP("ISD200 Initialization...\n");
@@ -1549,7 +1596,7 @@ int isd200_Initialization(struct us_data *us)
 *
 */
-void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us)
+static void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us)
 {
        int sendToTransport = 1, orig_bufflen;
        union ata_cdb ataCdb;
@@ -1570,3 +1617,47 @@ void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us)
        isd200_srb_set_bufflen(srb, orig_bufflen);
 }
+static int isd200_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - isd200_usb_ids) + isd200_unusual_dev_list);
+        if (result)
+                return result;
+        us->protocol_name = "ISD200 ATA/ATAPI";
+        us->proto_handler = isd200_ata_command;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver isd200_driver = {
+        .name =         "ums-isd200",
+        .probe =        isd200_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     isd200_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init isd200_init(void)
+{
+        return usb_register(&isd200_driver);
+}
+static void __exit isd200_exit(void)
+{
+        usb_deregister(&isd200_driver);
+}
+module_init(isd200_init);
+module_exit(isd200_exit);
diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c
index df67f13c9e73..1c69420e3acf 100644
--- a/drivers/usb/storage/jumpshot.c
+++ b/drivers/usb/storage/jumpshot.c
@@ -46,6 +46,7 @@
  */
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <scsi/scsi.h>
@@ -55,9 +56,61 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "jumpshot.h"
+MODULE_DESCRIPTION("Driver for Lexar \"Jumpshot\" Compact Flash reader");
+MODULE_AUTHOR("Jimmie Mayfield <mayfield+usb@sackheads.org>");
+MODULE_LICENSE("GPL");
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id jumpshot_usb_ids[] = {
+#       include "unusual_jumpshot.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, jumpshot_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev jumpshot_unusual_dev_list[] = {
+#       include "unusual_jumpshot.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
+struct jumpshot_info {
+   unsigned long   sectors;     /* total sector count */
+   unsigned long   ssize;       /* sector size in bytes */
+   /* the following aren't used yet */
+   unsigned char   sense_key;
+   unsigned long   sense_asc;   /* additional sense code */
+   unsigned long   sense_ascq;  /* additional sense code qualifier */
+};
 static inline int jumpshot_bulk_read(struct us_data *us,
                                     unsigned char *data, 
                                     unsigned int len)
@@ -429,7 +482,7 @@ static void jumpshot_info_destructor(void *extra)
 // Transport for the Lexar 'Jumpshot'
 //
-int jumpshot_transport(struct scsi_cmnd * srb, struct us_data *us)
+static int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        struct jumpshot_info *info;
        int rc;
@@ -592,3 +645,49 @@ int jumpshot_transport(struct scsi_cmnd * srb, struct us_data *us)
        info->sense_ascq = 0x00;
        return USB_STOR_TRANSPORT_FAILED;
 }
+static int jumpshot_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - jumpshot_usb_ids) + jumpshot_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name  = "Lexar Jumpshot Control/Bulk";
+        us->transport = jumpshot_transport;
+        us->transport_reset = usb_stor_Bulk_reset;
+        us->max_lun = 1;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver jumpshot_driver = {
+        .name =         "ums-jumpshot",
+        .probe =        jumpshot_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     jumpshot_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init jumpshot_init(void)
+{
+        return usb_register(&jumpshot_driver);
+}
+static void __exit jumpshot_exit(void)
+{
+        usb_deregister(&jumpshot_driver);
+}
+module_init(jumpshot_init);
+module_exit(jumpshot_exit);
diff --git a/drivers/usb/storage/jumpshot.h b/drivers/usb/storage/jumpshot.h
deleted file mode 100644
index 19bac9d1558f..000000000000
--- a/drivers/usb/storage/jumpshot.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* Driver for Lexar "Jumpshot" USB Compact Flash reader
- * Header File
- *
- * Current development and maintenance by:
- *   (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org)
- *
- * See jumpshot.c for more explanation
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef _USB_JUMPSHOT_H
-#define _USB_JUMPSHOT_H
-extern int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us);
-struct jumpshot_info {
-   unsigned long   sectors;     // total sector count
-   unsigned long   ssize;       // sector size in bytes
- 
-   // the following aren't used yet
-   unsigned char   sense_key;
-   unsigned long   sense_asc;   // additional sense code
-   unsigned long   sense_ascq;  // additional sense code qualifier
-};
-#endif
diff --git a/drivers/usb/storage/karma.c b/drivers/usb/storage/karma.c
index 0d79ae5683f7..7953d93a7739 100644
--- a/drivers/usb/storage/karma.c
+++ b/drivers/usb/storage/karma.c
@@ -18,6 +18,8 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
+#include <linux/module.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -25,7 +27,10 @@
 #include "usb.h"
 #include "transport.h"
 #include "debug.h"
-#include "karma.h"
+MODULE_DESCRIPTION("Driver for Rio Karma");
+MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>, Keith Bennett <keith@mcs.st-and.ac.uk>");
+MODULE_LICENSE("GPL");
 #define RIO_PREFIX "RIOP\x00"
 #define RIO_PREFIX_LEN 5
@@ -36,13 +41,53 @@
 #define RIO_LEAVE_STORAGE 0x2
 #define RIO_RESET 0xC
-extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data *);
 struct karma_data {
        int in_storage;
        char *recv;
 };
+static int rio_karma_init(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id karma_usb_ids[] = {
+#       include "unusual_karma.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, karma_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev karma_unusual_dev_list[] = {
+#       include "unusual_karma.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 /*
 * Send commands to Rio Karma.
 *
@@ -104,7 +149,7 @@ err:
 * Trap START_STOP and READ_10 to leave/re-enter storage mode.
 * Everything else is propagated to the normal bulk layer.
 */
-int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        int ret;
        struct karma_data *data = (struct karma_data *) us->extra;
@@ -133,7 +178,7 @@ static void rio_karma_destructor(void *extra)
        kfree(data->recv);
 }
-int rio_karma_init(struct us_data *us)
+static int rio_karma_init(struct us_data *us)
 {
        int ret = 0;
        struct karma_data *data = kzalloc(sizeof(struct karma_data), GFP_NOIO);
@@ -153,3 +198,48 @@ int rio_karma_init(struct us_data *us)
 out:
        return ret;
 }
+static int karma_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - karma_usb_ids) + karma_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name = "Rio Karma/Bulk";
+        us->transport = rio_karma_transport;
+        us->transport_reset = usb_stor_Bulk_reset;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver karma_driver = {
+        .name =         "ums-karma",
+        .probe =        karma_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     karma_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init karma_init(void)
+{
+        return usb_register(&karma_driver);
+}
+static void __exit karma_exit(void)
+{
+        usb_deregister(&karma_driver);
+}
+module_init(karma_init);
+module_exit(karma_exit);
diff --git a/drivers/usb/storage/karma.h b/drivers/usb/storage/karma.h
deleted file mode 100644
index 8a60972af8c5..000000000000
--- a/drivers/usb/storage/karma.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef _KARMA_USB_H
-#define _KARMA_USB_H
-extern int rio_karma_init(struct us_data *us);
-extern int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us);
-#endif
diff --git a/drivers/usb/storage/libusual.c b/drivers/usb/storage/libusual.c
index f970b27ba308..fe3ffe1459b2 100644
--- a/drivers/usb/storage/libusual.c
+++ b/drivers/usb/storage/libusual.c
@@ -38,37 +38,6 @@ static atomic_t total_threads = ATOMIC_INIT(0);
 static int usu_probe_thread(void *arg);
 /*
- * The table.
- */
-#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
-                    vendorName, productName,useProtocol, useTransport, \
-                    initFunction, flags) \
-{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
-#define COMPLIANT_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
-                    vendorName, productName, useProtocol, useTransport, \
-                    initFunction, flags) \
-{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags) }
-#define USUAL_DEV(useProto, useTrans, useType) \
-{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
-  .driver_info = ((useType)<<24) }
-struct usb_device_id storage_usb_ids [] = {
-#       include "unusual_devs.h"
-        { } /* Terminating entry */
-};
-#undef USUAL_DEV
-#undef UNUSUAL_DEV
-#undef COMPLIANT_DEV
-MODULE_DEVICE_TABLE(usb, storage_usb_ids);
-EXPORT_SYMBOL_GPL(storage_usb_ids);
-/*
 * @type: the module type as an integer
 */
 void usb_usual_set_present(int type)
@@ -167,7 +136,7 @@ static struct usb_driver usu_driver = {
        .name =         "libusual",
        .probe =        usu_probe,
        .disconnect =   usu_disconnect,
-        .id_table =     storage_usb_ids,
+        .id_table =     usb_storage_usb_ids,
 };
 /*
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index c7bf8954b4e4..380233bd6a39 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -35,9 +35,16 @@
 #include <linux/module.h>
 #include <linux/usb/input.h>
 #include "usb.h"
-#include "onetouch.h"
 #include "debug.h"
+MODULE_DESCRIPTION("Maxtor USB OneTouch hard drive button driver");
+MODULE_AUTHOR("Nick Sillik <n.sillik@temple.edu>");
+MODULE_LICENSE("GPL");
+#define ONETOUCH_PKT_LEN        0x02
+#define ONETOUCH_BUTTON         KEY_PROG1
+static int onetouch_connect_input(struct us_data *ss);
 static void onetouch_release_input(void *onetouch_);
 struct usb_onetouch {
@@ -52,6 +59,46 @@ struct usb_onetouch {
        unsigned int is_open:1;
 };
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id onetouch_usb_ids[] = {
+#       include "unusual_onetouch.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, onetouch_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev onetouch_unusual_dev_list[] = {
+#       include "unusual_onetouch.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 static void usb_onetouch_irq(struct urb *urb)
 {
        struct usb_onetouch *onetouch = urb->context;
@@ -127,7 +174,7 @@ static void usb_onetouch_pm_hook(struct us_data *us, int action)
 }
 #endif /* CONFIG_PM */
-int onetouch_connect_input(struct us_data *ss)
+static int onetouch_connect_input(struct us_data *ss)
 {
        struct usb_device *udev = ss->pusb_dev;
        struct usb_host_interface *interface;
@@ -236,3 +283,46 @@ static void onetouch_release_input(void *onetouch_)
                                onetouch->data, onetouch->data_dma);
        }
 }
+static int onetouch_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - onetouch_usb_ids) + onetouch_unusual_dev_list);
+        if (result)
+                return result;
+        /* Use default transport and protocol */
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver onetouch_driver = {
+        .name =         "ums-onetouch",
+        .probe =        onetouch_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     onetouch_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init onetouch_init(void)
+{
+        return usb_register(&onetouch_driver);
+}
+static void __exit onetouch_exit(void)
+{
+        usb_deregister(&onetouch_driver);
+}
+module_init(onetouch_init);
+module_exit(onetouch_exit);
diff --git a/drivers/usb/storage/onetouch.h b/drivers/usb/storage/onetouch.h
deleted file mode 100644
index 41c7aa8f0446..000000000000
--- a/drivers/usb/storage/onetouch.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef _ONETOUCH_H_
-#define _ONETOUCH_H_
-#define ONETOUCH_PKT_LEN        0x02
-#define ONETOUCH_BUTTON         KEY_PROG1
-int onetouch_connect_input(struct us_data *ss);
-#endif
diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
index be441d84bc64..fc310f75eada 100644
--- a/drivers/usb/storage/protocol.c
+++ b/drivers/usb/storage/protocol.c
@@ -121,6 +121,7 @@ void usb_stor_transparent_scsi_command(struct scsi_cmnd *srb,
        /* send the command to the transport layer */
        usb_stor_invoke_transport(srb, us);
 }
+EXPORT_SYMBOL_GPL(usb_stor_transparent_scsi_command);
 /***********************************************************************
 * Scatter-gather transfer buffer access routines
@@ -199,6 +200,7 @@ unsigned int usb_stor_access_xfer_buf(unsigned char *buffer,
        /* Return the amount actually transferred */
        return cnt;
 }
+EXPORT_SYMBOL_GPL(usb_stor_access_xfer_buf);
 /* Store the contents of buffer into srb's transfer buffer and set the
 * SCSI residue.
@@ -215,3 +217,4 @@ void usb_stor_set_xfer_buf(unsigned char *buffer,
        if (buflen < scsi_bufflen(srb))
                scsi_set_resid(srb, scsi_bufflen(srb) - buflen);
 }
+EXPORT_SYMBOL_GPL(usb_stor_set_xfer_buf);
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 727c506417cc..4ca3b5860643 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -135,6 +135,12 @@ static int slave_configure(struct scsi_device *sdev)
                if (sdev->request_queue->max_sectors > max_sectors)
                        blk_queue_max_sectors(sdev->request_queue,
                                              max_sectors);
+        } else if (sdev->type == TYPE_TAPE) {
+                /* Tapes need much higher max_sector limits, so just
+                 * raise it to the maximum possible (4 GB / 512) and
+                 * let the queue segment size sort out the real limit.
+                 */
+                blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
        }
        /* Some USB host controllers can't do DMA; they have to use PIO.
@@ -563,4 +569,4 @@ unsigned char usb_stor_sense_invalidCDB[18] = {
        [7]     = 0x0a,                     /* additional length */
        [12]    = 0x24                      /* Invalid Field in CDB */
 };
+EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index 531ae5c5abf3..ab5f9f37575a 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -41,6 +41,7 @@
 */
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <scsi/scsi.h>
@@ -51,7 +52,53 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "sddr09.h"
+MODULE_DESCRIPTION("Driver for SanDisk SDDR-09 SmartMedia reader");
+MODULE_AUTHOR("Andries Brouwer <aeb@cwi.nl>, Robert Baruch <autophile@starband.net>");
+MODULE_LICENSE("GPL");
+static int usb_stor_sddr09_dpcm_init(struct us_data *us);
+static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us);
+static int usb_stor_sddr09_init(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id sddr09_usb_ids[] = {
+#       include "unusual_sddr09.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, sddr09_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev sddr09_unusual_dev_list[] = {
+#       include "unusual_sddr09.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
@@ -723,7 +770,7 @@ sddr09_read_data(struct us_data *us,
        len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
        buffer = kmalloc(len, GFP_NOIO);
        if (buffer == NULL) {
-                printk("sddr09_read_data: Out of memory\n");
+                printk(KERN_WARNING "sddr09_read_data: Out of memory\n");
                return -ENOMEM;
        }
@@ -838,7 +885,8 @@ sddr09_write_lba(struct us_data *us, unsigned int lba,
        if (pba == UNDEF) {
                pba = sddr09_find_unused_pba(info, lba);
                if (!pba) {
-                        printk("sddr09_write_lba: Out of unused blocks\n");
+                        printk(KERN_WARNING
+                               "sddr09_write_lba: Out of unused blocks\n");
                        return -ENOSPC;
                }
                info->pba_to_lba[pba] = lba;
@@ -849,7 +897,7 @@ sddr09_write_lba(struct us_data *us, unsigned int lba,
        if (pba == 1) {
                /* Maybe it is impossible to write to PBA 1.
                   Fake success, but don't do anything. */
-                printk("sddr09: avoid writing to pba 1\n");
+                printk(KERN_WARNING "sddr09: avoid writing to pba 1\n");
                return 0;
        }
@@ -954,7 +1002,7 @@ sddr09_write_data(struct us_data *us,
        blocklen = (pagelen << info->blockshift);
        blockbuffer = kmalloc(blocklen, GFP_NOIO);
        if (!blockbuffer) {
-                printk("sddr09_write_data: Out of memory\n");
+                printk(KERN_WARNING "sddr09_write_data: Out of memory\n");
                return -ENOMEM;
        }
@@ -965,7 +1013,7 @@ sddr09_write_data(struct us_data *us,
        len = min(sectors, (unsigned int) info->blocksize) * info->pagesize;
        buffer = kmalloc(len, GFP_NOIO);
        if (buffer == NULL) {
-                printk("sddr09_write_data: Out of memory\n");
+                printk(KERN_WARNING "sddr09_write_data: Out of memory\n");
                kfree(blockbuffer);
                return -ENOMEM;
        }
@@ -1112,7 +1160,7 @@ sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
        if (result) {
                US_DEBUGP("Result of read_deviceID is %d\n", result);
-                printk("sddr09: could not read card info\n");
+                printk(KERN_WARNING "sddr09: could not read card info\n");
                return NULL;
        }
@@ -1153,7 +1201,7 @@ sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
                sprintf(blurbtxt + strlen(blurbtxt),
                        ", WP");
-        printk("%s\n", blurbtxt);
+        printk(KERN_WARNING "%s\n", blurbtxt);
        return cardinfo;
 }
@@ -1184,7 +1232,7 @@ sddr09_read_map(struct us_data *us) {
        alloc_len = (alloc_blocks << CONTROL_SHIFT);
        buffer = kmalloc(alloc_len, GFP_NOIO);
        if (buffer == NULL) {
-                printk("sddr09_read_map: out of memory\n");
+                printk(KERN_WARNING "sddr09_read_map: out of memory\n");
                result = -1;
                goto done;
        }
@@ -1198,7 +1246,7 @@ sddr09_read_map(struct us_data *us) {
        info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO);
        if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) {
-                printk("sddr09_read_map: out of memory\n");
+                printk(KERN_WARNING "sddr09_read_map: out of memory\n");
                result = -1;
                goto done;
        }
@@ -1238,7 +1286,8 @@ sddr09_read_map(struct us_data *us) {
                        if (ptr[j] != 0)
                                goto nonz;
                info->pba_to_lba[i] = UNUSABLE;
-                printk("sddr09: PBA %d has no logical mapping\n", i);
+                printk(KERN_WARNING "sddr09: PBA %d has no logical mapping\n",
+                       i);
                continue;
        nonz:
@@ -1251,7 +1300,8 @@ sddr09_read_map(struct us_data *us) {
        nonff:
                /* normal PBAs start with six FFs */
                if (j < 6) {
-                        printk("sddr09: PBA %d has no logical mapping: "
+                        printk(KERN_WARNING
+                               "sddr09: PBA %d has no logical mapping: "
                               "reserved area = %02X%02X%02X%02X "
                               "data status %02X block status %02X\n",
                               i, ptr[0], ptr[1], ptr[2], ptr[3],
@@ -1261,7 +1311,8 @@ sddr09_read_map(struct us_data *us) {
                }
                if ((ptr[6] >> 4) != 0x01) {
-                        printk("sddr09: PBA %d has invalid address field "
+                        printk(KERN_WARNING
+                               "sddr09: PBA %d has invalid address field "
                               "%02X%02X/%02X%02X\n",
                               i, ptr[6], ptr[7], ptr[11], ptr[12]);
                        info->pba_to_lba[i] = UNUSABLE;
@@ -1270,7 +1321,8 @@ sddr09_read_map(struct us_data *us) {
                /* check even parity */
                if (parity[ptr[6] ^ ptr[7]]) {
-                        printk("sddr09: Bad parity in LBA for block %d"
+                        printk(KERN_WARNING
+                               "sddr09: Bad parity in LBA for block %d"
                               " (%02X %02X)\n", i, ptr[6], ptr[7]);
                        info->pba_to_lba[i] = UNUSABLE;
                        continue;
@@ -1289,7 +1341,8 @@ sddr09_read_map(struct us_data *us) {
                 */
                if (lba >= 1000) {
-                        printk("sddr09: Bad low LBA %d for block %d\n",
+                        printk(KERN_WARNING
+                               "sddr09: Bad low LBA %d for block %d\n",
                               lba, i);
                        goto possibly_erase;
                }
@@ -1297,7 +1350,8 @@ sddr09_read_map(struct us_data *us) {
                lba += 1000*(i/0x400);
                if (info->lba_to_pba[lba] != UNDEF) {
-                        printk("sddr09: LBA %d seen for PBA %d and %d\n",
+                        printk(KERN_WARNING
+                               "sddr09: LBA %d seen for PBA %d and %d\n",
                               lba, info->lba_to_pba[lba], i);
                        goto possibly_erase;
                }
@@ -1399,7 +1453,7 @@ sddr09_common_init(struct us_data *us) {
 * unusual devices list but called from here then LUN 0 of the combo reader
 * is not recognized. But I do not know what precisely these calls do.
 */
-int
+static int
 usb_stor_sddr09_dpcm_init(struct us_data *us) {
        int result;
        unsigned char *data = us->iobuf;
@@ -1449,7 +1503,7 @@ usb_stor_sddr09_dpcm_init(struct us_data *us) {
 /*
 * Transport for the Microtech DPCM-USB
 */
-int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        int ret;
@@ -1491,7 +1545,7 @@ int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
 /*
 * Transport for the Sandisk SDDR-09
 */
-int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        static unsigned char sensekey = 0, sensecode = 0;
        static unsigned char havefakesense = 0;
@@ -1690,7 +1744,60 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
 /*
 * Initialization routine for the sddr09 subdriver
 */
-int
+static int
 usb_stor_sddr09_init(struct us_data *us) {
        return sddr09_common_init(us);
 }
+static int sddr09_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - sddr09_usb_ids) + sddr09_unusual_dev_list);
+        if (result)
+                return result;
+        if (us->protocol == US_PR_DPCM_USB) {
+                us->transport_name = "Control/Bulk-EUSB/SDDR09";
+                us->transport = dpcm_transport;
+                us->transport_reset = usb_stor_CB_reset;
+                us->max_lun = 1;
+        } else {
+                us->transport_name = "EUSB/SDDR09";
+                us->transport = sddr09_transport;
+                us->transport_reset = usb_stor_CB_reset;
+                us->max_lun = 0;
+        }
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver sddr09_driver = {
+        .name =         "ums-sddr09",
+        .probe =        sddr09_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     sddr09_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init sddr09_init(void)
+{
+        return usb_register(&sddr09_driver);
+}
+static void __exit sddr09_exit(void)
+{
+        usb_deregister(&sddr09_driver);
+}
+module_init(sddr09_init);
+module_exit(sddr09_exit);
diff --git a/drivers/usb/storage/sddr09.h b/drivers/usb/storage/sddr09.h
deleted file mode 100644
index b701172e12e3..000000000000
--- a/drivers/usb/storage/sddr09.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* Driver for SanDisk SDDR-09 SmartMedia reader
- * Header File
- *
- * Current development and maintenance by:
- *   (c) 2000 Robert Baruch (autophile@dol.net)
- *   (c) 2002 Andries Brouwer (aeb@cwi.nl)
- *
- * See sddr09.c for more explanation
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef _USB_SHUTTLE_EUSB_SDDR09_H
-#define _USB_SHUTTLE_EUSB_SDDR09_H
-/* Sandisk SDDR-09 stuff */
-extern int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us);
-extern int usb_stor_sddr09_init(struct us_data *us);
-/* Microtech DPCM-USB stuff */
-extern int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us);
-extern int usb_stor_sddr09_dpcm_init(struct us_data *us);
-#endif
diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c
index 0d8df7577899..44dfed7754ed 100644
--- a/drivers/usb/storage/sddr55.c
+++ b/drivers/usb/storage/sddr55.c
@@ -24,6 +24,7 @@
 #include <linux/jiffies.h>
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <scsi/scsi.h>
@@ -33,7 +34,48 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "sddr55.h"
+MODULE_DESCRIPTION("Driver for SanDisk SDDR-55 SmartMedia reader");
+MODULE_AUTHOR("Simon Munton");
+MODULE_LICENSE("GPL");
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id sddr55_usb_ids[] = {
+#       include "unusual_sddr55.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, sddr55_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev sddr55_unusual_dev_list[] = {
+#       include "unusual_sddr55.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
@@ -513,7 +555,8 @@ static int sddr55_read_deviceID(struct us_data *us,
 }
-int sddr55_reset(struct us_data *us) {
+static int sddr55_reset(struct us_data *us)
+{
        return 0;
 }
@@ -703,7 +746,9 @@ static int sddr55_read_map(struct us_data *us) {
                
                if (info->lba_to_pba[lba + zone * 1000] != NOT_ALLOCATED &&
                    !info->force_read_only) {
-                        printk("sddr55: map inconsistency at LBA %04X\n", lba + zone * 1000);
+                        printk(KERN_WARNING
+                               "sddr55: map inconsistency at LBA %04X\n",
+                               lba + zone * 1000);
                        info->force_read_only = 1;
                }
@@ -732,7 +777,7 @@ static void sddr55_card_info_destructor(void *extra) {
 /*
 * Transport for the Sandisk SDDR-55
 */
-int sddr55_transport(struct scsi_cmnd *srb, struct us_data *us)
+static int sddr55_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
        int result;
        static unsigned char inquiry_response[8] = {
@@ -929,3 +974,49 @@ int sddr55_transport(struct scsi_cmnd *srb, struct us_data *us)
        return USB_STOR_TRANSPORT_FAILED; // FIXME: sense buffer?
 }
+static int sddr55_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - sddr55_usb_ids) + sddr55_unusual_dev_list);
+        if (result)
+                return result;
+        us->transport_name = "SDDR55";
+        us->transport = sddr55_transport;
+        us->transport_reset = sddr55_reset;
+        us->max_lun = 0;
+        result = usb_stor_probe2(us);
+        return result;
+}
+static struct usb_driver sddr55_driver = {
+        .name =         "ums-sddr55",
+        .probe =        sddr55_probe,
+        .disconnect =   usb_stor_disconnect,
+        .suspend =      usb_stor_suspend,
+        .resume =       usb_stor_resume,
+        .reset_resume = usb_stor_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
+        .post_reset =   usb_stor_post_reset,
+        .id_table =     sddr55_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init sddr55_init(void)
+{
+        return usb_register(&sddr55_driver);
+}
+static void __exit sddr55_exit(void)
+{
+        usb_deregister(&sddr55_driver);
+}
+module_init(sddr55_init);
+module_exit(sddr55_exit);
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index ae6d64810d2a..b62a28814ebe 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -42,6 +42,7 @@
 */
 #include <linux/errno.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/cdrom.h>
@@ -52,7 +53,100 @@
 #include "transport.h"
 #include "protocol.h"
 #include "debug.h"
-#include "shuttle_usbat.h"
+MODULE_DESCRIPTION("Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable");
+MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>, Robert Baruch <autophile@starband.net>");
+MODULE_LICENSE("GPL");
+/* Supported device types */
+#define USBAT_DEV_HP8200        0x01
+#define USBAT_DEV_FLASH         0x02
+#define USBAT_EPP_PORT          0x10
+#define USBAT_EPP_REGISTER      0x30
+#define USBAT_ATA               0x40
+#define USBAT_ISA               0x50
+/* Commands (need to be logically OR'd with an access type */
+#define USBAT_CMD_READ_REG              0x00
+#define USBAT_CMD_WRITE_REG             0x01
+#define USBAT_CMD_READ_BLOCK    0x02
+#define USBAT_CMD_WRITE_BLOCK   0x03
+#define USBAT_CMD_COND_READ_BLOCK       0x04
+#define USBAT_CMD_COND_WRITE_BLOCK      0x05
+#define USBAT_CMD_WRITE_REGS    0x07
+/* Commands (these don't need an access type) */
+#define USBAT_CMD_EXEC_CMD      0x80
+#define USBAT_CMD_SET_FEAT      0x81
+#define USBAT_CMD_UIO           0x82
+/* Methods of accessing UIO register */
+#define USBAT_UIO_READ  1
+#define USBAT_UIO_WRITE 0
+/* Qualifier bits */
+#define USBAT_QUAL_FCQ  0x20    /* full compare */
+#define USBAT_QUAL_ALQ  0x10    /* auto load subcount */
+/* USBAT Flash Media status types */
+#define USBAT_FLASH_MEDIA_NONE  0
+#define USBAT_FLASH_MEDIA_CF    1
+/* USBAT Flash Media change types */
+#define USBAT_FLASH_MEDIA_SAME  0
+#define USBAT_FLASH_MEDIA_CHANGED       1
+/* USBAT ATA registers */
+#define USBAT_ATA_DATA      0x10  /* read/write data (R/W) */
+#define USBAT_ATA_FEATURES  0x11  /* set features (W) */
+#define USBAT_ATA_ERROR     0x11  /* error (R) */
+#define USBAT_ATA_SECCNT    0x12  /* sector count (R/W) */
+#define USBAT_ATA_SECNUM    0x13  /* sector number (R/W) */
+#define USBAT_ATA_LBA_ME    0x14  /* cylinder low (R/W) */
+#define USBAT_ATA_LBA_HI    0x15  /* cylinder high (R/W) */
+#define USBAT_ATA_DEVICE    0x16  /* head/device selection (R/W) */
+#define USBAT_ATA_STATUS    0x17  /* device status (R) */
+#define USBAT_ATA_CMD       0x17  /* device command (W) */
+#define USBAT_ATA_ALTSTATUS 0x0E  /* status (no clear IRQ) (R) */
+/* USBAT User I/O Data registers */
+#define USBAT_UIO_EPAD          0x80 /* Enable Peripheral Control Signals */
+#define USBAT_UIO_CDT           0x40 /* Card Detect (Read Only) */
+                                     /* CDT = ACKD & !UI1 & !UI0 */
+#define USBAT_UIO_1             0x20 /* I/O 1 */
+#define USBAT_UIO_0             0x10 /* I/O 0 */
+#define USBAT_UIO_EPP_ATA       0x08 /* 1=EPP mode, 0=ATA mode */
+#define USBAT_UIO_UI1           0x04 /* Input 1 */
+#define USBAT_UIO_UI0           0x02 /* Input 0 */
+#define USBAT_UIO_INTR_ACK      0x01 /* Interrupt (ATA/ISA)/Acknowledge (EPP) */
+/* USBAT User I/O Enable registers */
+#define USBAT_UIO_DRVRST        0x80 /* Reset Peripheral */
+#define USBAT_UIO_ACKD          0x40 /* Enable Card Detect */
+#define USBAT_UIO_OE1           0x20 /* I/O 1 set=output/clr=input */
+                                     /* If ACKD=1, set OE1 to 1 also. */
+#define USBAT_UIO_OE0           0x10 /* I/O 0 set=output/clr=input */
+#define USBAT_UIO_ADPRST        0x01 /* Reset SCM chip */
+/* USBAT Features */
+#define USBAT_FEAT_ETEN 0x80    /* External trigger enable */
+#define USBAT_FEAT_U1   0x08
+#define USBAT_FEAT_U0   0x04
+#define USBAT_FEAT_ET1  0x02
+#define USBAT_FEAT_ET2  0x01
+struct usbat_info {
+        int devicetype;
+        /* Used for Flash readers only */
+        unsigned long sectors;     /* total sector count */
+        unsigned long ssize;       /* sector size in bytes */
+        unsigned char sense_key;
+        unsigned long sense_asc;   /* additional sense code */
+        unsigned long sense_ascq;  /* additional sense code qualifier */
+};
 #define short_pack(LSB,MSB) ( ((u16)(LSB)) | ( ((u16)(MSB))<<8 ) )
 #define LSB_of(s) ((s)&0xFF)
@@ -63,6 +157,48 @@ static int transferred = 0;
 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
+static int init_usbat_cd(struct us_data *us);
+static int init_usbat_flash(struct us_data *us);
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+struct usb_device_id usbat_usb_ids[] = {
+#       include "unusual_usbat.h"
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, usbat_usb_ids);
+#undef UNUSUAL_DEV
+/*
+ * The flags table
+ */
+#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
+                    vendor_name, product_name, use_protocol, use_transport, \
+                    init_function, Flags) \
+{ \
+        .vendorName = vendor_name,      \
+        .productName = product_name,    \
+        .useProtocol = use_protocol,    \
+        .useTransport = use_transport,  \
+        .initFunction = init_function,  \
+}
+static struct us_unusual_dev usbat_unusual_dev_list[] = {
+#       include "unusual_usbat.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
 /*
 * Convenience function to produce an ATA read/write sectors command
 * Use cmd=0x20 for read, cmd=0x30 for write
@@ -1684,37 +1820,61 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
        return USB_STOR_TRANSPORT_FAILED;
 }
-int init_usbat_cd(struct us_data *us)
+static int init_usbat_cd(struct us_data *us)
 {
        return init_usbat(us, USBAT_DEV_HP8200);
 }
+static int init_usbat_flash(struct us_data *us)
-int init_usbat_flash(struct us_data *us)
 {
        return init_usbat(us, USBAT_DEV_FLASH);
 }
-int init_usbat_probe(struct us_data *us)
+static int usbat_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
 {
-        return init_usbat(us, 0);
+        struct us_data *us;
+        int result;
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - usbat_usb_ids) + usbat_unusual_dev_list);
+        if (result)
+                return result;
+        /* The actual transport will be determined later by the
+         * initialization routine; this is just a placeholder.
+         */
+        us->transport_name = "Shuttle USBAT";
+        us->transport = usbat_flash_transport;
+        us->transport_reset = usb_stor_CB_reset;
+        us->max_lun = 1;
+        result = usb_stor_probe2(us);
+        return result;
 }
-/*
+static struct usb_driver usbat_driver = {
- * Default transport function. Attempts to detect which transport function
+        .name =         "ums-usbat",
- * should be called, makes it the new default, and calls it.
+        .probe =        usbat_probe,
- *
+        .disconnect =   usb_stor_disconnect,
- * This function should never be called. Our usbat_init() function detects the
+        .suspend =      usb_stor_suspend,
- * device type and changes the us->transport ptr to the transport function
+        .resume =       usb_stor_resume,
- * relevant to the device.
+        .reset_resume = usb_stor_reset_resume,
- * However, we'll support this impossible(?) case anyway.
+        .pre_reset =    usb_stor_pre_reset,
- */
+        .post_reset =   usb_stor_post_reset,
-int usbat_transport(struct scsi_cmnd *srb, struct us_data *us)
+        .id_table =     usbat_usb_ids,
+        .soft_unbind =  1,
+};
+static int __init usbat_init(void)
 {
-        struct usbat_info *info = (struct usbat_info*) (us->extra);
+        return usb_register(&usbat_driver);
+}
-        if (usbat_set_transport(us, info, 0))
-                return USB_STOR_TRANSPORT_ERROR;
-        return us->transport(srb, us);  
+static void __exit usbat_exit(void)
+{
+        usb_deregister(&usbat_driver);
 }
+module_init(usbat_init);
+module_exit(usbat_exit);
diff --git a/drivers/usb/storage/shuttle_usbat.h b/drivers/usb/storage/shuttle_usbat.h
deleted file mode 100644
index d8bfc43e9044..000000000000
--- a/drivers/usb/storage/shuttle_usbat.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/* Driver for SCM Microsystems USB-ATAPI cable
- * Header File
- *
- * Current development and maintenance by:
- *   (c) 2000 Robert Baruch (autophile@dol.net)
- *   (c) 2004, 2005 Daniel Drake <dsd@gentoo.org>
- *
- * See shuttle_usbat.c for more explanation
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef _USB_SHUTTLE_USBAT_H
-#define _USB_SHUTTLE_USBAT_H
-/* Supported device types */
-#define USBAT_DEV_HP8200        0x01
-#define USBAT_DEV_FLASH         0x02
-#define USBAT_EPP_PORT          0x10
-#define USBAT_EPP_REGISTER      0x30
-#define USBAT_ATA               0x40
-#define USBAT_ISA               0x50
-/* Commands (need to be logically OR'd with an access type */
-#define USBAT_CMD_READ_REG              0x00
-#define USBAT_CMD_WRITE_REG             0x01
-#define USBAT_CMD_READ_BLOCK    0x02
-#define USBAT_CMD_WRITE_BLOCK   0x03
-#define USBAT_CMD_COND_READ_BLOCK       0x04
-#define USBAT_CMD_COND_WRITE_BLOCK      0x05
-#define USBAT_CMD_WRITE_REGS    0x07
-/* Commands (these don't need an access type) */
-#define USBAT_CMD_EXEC_CMD      0x80
-#define USBAT_CMD_SET_FEAT      0x81
-#define USBAT_CMD_UIO           0x82
-/* Methods of accessing UIO register */
-#define USBAT_UIO_READ  1
-#define USBAT_UIO_WRITE 0
-/* Qualifier bits */
-#define USBAT_QUAL_FCQ  0x20    /* full compare */
-#define USBAT_QUAL_ALQ  0x10    /* auto load subcount */
-/* USBAT Flash Media status types */
-#define USBAT_FLASH_MEDIA_NONE  0
-#define USBAT_FLASH_MEDIA_CF    1
-/* USBAT Flash Media change types */
-#define USBAT_FLASH_MEDIA_SAME  0
-#define USBAT_FLASH_MEDIA_CHANGED       1
-/* USBAT ATA registers */
-#define USBAT_ATA_DATA      0x10  /* read/write data (R/W) */
-#define USBAT_ATA_FEATURES  0x11  /* set features (W) */
-#define USBAT_ATA_ERROR     0x11  /* error (R) */
-#define USBAT_ATA_SECCNT    0x12  /* sector count (R/W) */
-#define USBAT_ATA_SECNUM    0x13  /* sector number (R/W) */
-#define USBAT_ATA_LBA_ME    0x14  /* cylinder low (R/W) */
-#define USBAT_ATA_LBA_HI    0x15  /* cylinder high (R/W) */
-#define USBAT_ATA_DEVICE    0x16  /* head/device selection (R/W) */
-#define USBAT_ATA_STATUS    0x17  /* device status (R) */
-#define USBAT_ATA_CMD       0x17  /* device command (W) */
-#define USBAT_ATA_ALTSTATUS 0x0E  /* status (no clear IRQ) (R) */
-/* USBAT User I/O Data registers */
-#define USBAT_UIO_EPAD          0x80 /* Enable Peripheral Control Signals */
-#define USBAT_UIO_CDT           0x40 /* Card Detect (Read Only) */
-                                     /* CDT = ACKD & !UI1 & !UI0 */
-#define USBAT_UIO_1             0x20 /* I/O 1 */
-#define USBAT_UIO_0             0x10 /* I/O 0 */
-#define USBAT_UIO_EPP_ATA       0x08 /* 1=EPP mode, 0=ATA mode */
-#define USBAT_UIO_UI1           0x04 /* Input 1 */
-#define USBAT_UIO_UI0           0x02 /* Input 0 */
-#define USBAT_UIO_INTR_ACK      0x01 /* Interrupt (ATA/ISA)/Acknowledge (EPP) */
-/* USBAT User I/O Enable registers */
-#define USBAT_UIO_DRVRST        0x80 /* Reset Peripheral */
-#define USBAT_UIO_ACKD          0x40 /* Enable Card Detect */
-#define USBAT_UIO_OE1           0x20 /* I/O 1 set=output/clr=input */
-                                     /* If ACKD=1, set OE1 to 1 also. */
-#define USBAT_UIO_OE0           0x10 /* I/O 0 set=output/clr=input */
-#define USBAT_UIO_ADPRST        0x01 /* Reset SCM chip */
-/* USBAT Features */
-#define USBAT_FEAT_ETEN 0x80    /* External trigger enable */
-#define USBAT_FEAT_U1   0x08
-#define USBAT_FEAT_U0   0x04
-#define USBAT_FEAT_ET1  0x02
-#define USBAT_FEAT_ET2  0x01
-extern int usbat_transport(struct scsi_cmnd *srb, struct us_data *us);
-extern int init_usbat_cd(struct us_data *us);
-extern int init_usbat_flash(struct us_data *us);
-extern int init_usbat_probe(struct us_data *us);
-struct usbat_info {
-        int devicetype;
-        /* Used for Flash readers only */
-        unsigned long sectors;     /* total sector count */
-        unsigned long ssize;       /* sector size in bytes */
-        unsigned char sense_key;
-        unsigned long sense_asc;   /* additional sense code */
-        unsigned long sense_ascq;  /* additional sense code qualifier */
-};
-#endif
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index fb65d221cedf..d48c8553539d 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -220,6 +220,7 @@ int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
                status = us->current_urb->actual_length;
        return status;
 }
+EXPORT_SYMBOL_GPL(usb_stor_control_msg);
 /* This is a version of usb_clear_halt() that allows early termination and
 * doesn't read the status from the device -- this is because some devices
@@ -254,6 +255,7 @@ int usb_stor_clear_halt(struct us_data *us, unsigned int pipe)
        US_DEBUGP("%s: result = %d\n", __func__, result);
        return result;
 }
+EXPORT_SYMBOL_GPL(usb_stor_clear_halt);
 /*
@@ -352,6 +354,7 @@ int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
        return interpret_urb_result(us, pipe, size, result,
                        us->current_urb->actual_length);
 }
+EXPORT_SYMBOL_GPL(usb_stor_ctrl_transfer);
 /*
 * Receive one interrupt buffer, without timeouts, but allowing early
@@ -407,6 +410,7 @@ int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
        return interpret_urb_result(us, pipe, length, result, 
                        us->current_urb->actual_length);
 }
+EXPORT_SYMBOL_GPL(usb_stor_bulk_transfer_buf);
 /*
 * Transfer a scatter-gather list via bulk transfer
@@ -474,6 +478,7 @@ int usb_stor_bulk_srb(struct us_data* us, unsigned int pipe,
        scsi_set_resid(srb, scsi_bufflen(srb) - partial);
        return result;
 }
+EXPORT_SYMBOL_GPL(usb_stor_bulk_srb);
 /*
 * Transfer an entire SCSI command's worth of data payload over the bulk
@@ -509,6 +514,7 @@ int usb_stor_bulk_transfer_sg(struct us_data* us, unsigned int pipe,
                *residual = length_left;
        return result;
 }
+EXPORT_SYMBOL_GPL(usb_stor_bulk_transfer_sg);
 /***********************************************************************
 * Transport routines
@@ -940,6 +946,7 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
                usb_stor_clear_halt(us, pipe);
        return USB_STOR_TRANSPORT_FAILED;
 }
+EXPORT_SYMBOL_GPL(usb_stor_CB_transport);
 /*
 * Bulk only transport
@@ -1156,6 +1163,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
        /* we should never get here, but if we do, we're in trouble */
        return USB_STOR_TRANSPORT_ERROR;
 }
+EXPORT_SYMBOL_GPL(usb_stor_Bulk_transport);
 /***********************************************************************
 * Reset routines
@@ -1230,6 +1238,7 @@ int usb_stor_CB_reset(struct us_data *us)
                                 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                                 0, us->ifnum, us->iobuf, CB_RESET_CMD_SIZE);
 }
+EXPORT_SYMBOL_GPL(usb_stor_CB_reset);
 /* This issues a Bulk-only Reset to the device in question, including
 * clearing the subsequent endpoint halts that may occur.
@@ -1242,6 +1251,7 @@ int usb_stor_Bulk_reset(struct us_data *us)
                                 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                                 0, us->ifnum, NULL, 0);
 }
+EXPORT_SYMBOL_GPL(usb_stor_Bulk_reset);
 /* Issue a USB port reset to the device.  The caller must not hold
 * us->dev_mutex.
diff --git a/drivers/usb/storage/freecom.h b/drivers/usb/storage/unusual_alauda.h
index 20d0fe6ba0c8..8c412f885dd2 100644
--- a/drivers/usb/storage/freecom.h
+++ b/drivers/usb/storage/unusual_alauda.h
@@ -1,13 +1,4 @@
-/* Driver for Freecom USB/IDE adaptor
+/* Unusual Devices File for the Alauda-based card readers
- *
- * Freecom v0.1:
- *
- * First release
- *
- * Current development and maintenance by:
- *   (c) 2000 David Brown <usb-storage@davidb.org>
- *
- * See freecom.c for more explanation
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
@@ -24,11 +15,17 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#ifndef _FREECOM_USB_H
+#if defined(CONFIG_USB_STORAGE_ALAUDA) || \
-#define _FREECOM_USB_H
+                defined(CONFIG_USB_STORAGE_ALAUDA_MODULE)
+UNUSUAL_DEV(  0x0584, 0x0008, 0x0102, 0x0102,
+                "Fujifilm",
+                "DPC-R1 (Alauda)",
+                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0),
-extern int freecom_transport(struct scsi_cmnd *srb, struct us_data *us);
+UNUSUAL_DEV(  0x07b4, 0x010a, 0x0102, 0x0102,
-extern int usb_stor_freecom_reset(struct us_data *us);
+                "Olympus",
-extern int freecom_init (struct us_data *us);
+                "MAUSB-10 (Alauda)",
+                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0),
-#endif
+#endif /* defined(CONFIG_USB_STORAGE_ALAUDA) || ... */
diff --git a/drivers/usb/storage/unusual_cypress.h b/drivers/usb/storage/unusual_cypress.h
new file mode 100644
index 000000000000..44be6d75dab6
--- /dev/null
+++ b/drivers/usb/storage/unusual_cypress.h
@@ -0,0 +1,34 @@
+/* Unusual Devices File for devices based on the Cypress USB/ATA bridge
+ *      with support for ATACB
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_CYPRESS_ATACB) || \
+                defined(CONFIG_USB_STORAGE_CYPRESS_ATACB_MODULE)
+/* CY7C68300 : support atacb */
+UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
+                "Cypress",
+                "Cypress AT2LP",
+                US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0),
+/* CY7C68310 : support atacb and atacb2 */
+UNUSUAL_DEV(  0x04b4, 0x6831, 0x0000, 0x9999,
+                "Cypress",
+                "Cypress ISD-300LP",
+                US_SC_CYP_ATACB, US_PR_DEVICE, NULL, 0),
+#endif /* defined(CONFIG_USB_STORAGE_CYPRESS_ATACB) || ... */
diff --git a/drivers/usb/storage/unusual_datafab.h b/drivers/usb/storage/unusual_datafab.h
new file mode 100644
index 000000000000..c9298ce9f223
--- /dev/null
+++ b/drivers/usb/storage/unusual_datafab.h
@@ -0,0 +1,98 @@
+/* Unusual Devices File for the Datafab USB Compact Flash reader
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_DATAFAB) || \
+                defined(CONFIG_USB_STORAGE_DATAFAB_MODULE)
+UNUSUAL_DEV(  0x07c4, 0xa000, 0x0000, 0x0015,
+                "Datafab",
+                "MDCFE-B USB CF Reader",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+/*
+ * The following Datafab-based devices may or may not work
+ * using the current driver...the 0xffff is arbitrary since I
+ * don't know what device versions exist for these guys.
+ *
+ * The 0xa003 and 0xa004 devices in particular I'm curious about.
+ * I'm told they exist but so far nobody has come forward to say that
+ * they work with this driver.  Given the success we've had getting
+ * other Datafab-based cards operational with this driver, I've decided
+ * to leave these two devices in the list.
+ */
+UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff,
+                "SIIG/Datafab",
+                "SIIG/Datafab Memory Stick+CF Reader/Writer",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+/* Reported by Josef Reisinger <josef.reisinger@netcologne.de> */
+UNUSUAL_DEV( 0x07c4, 0xa002, 0x0000, 0xffff,
+                "Datafab/Unknown",
+                "MD2/MD3 Disk enclosure",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                US_FL_SINGLE_LUN),
+UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff,
+                "Datafab/Unknown",
+                "Datafab-based Reader",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff,
+                "Datafab/Unknown",
+                "Datafab-based Reader",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff,
+                "PNY/Datafab",
+                "PNY/Datafab CF+SM Reader",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff,
+                "Simple Tech/Datafab",
+                "Simple Tech/Datafab CF+SM Reader",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+/* Submitted by Olaf Hering <olh@suse.de> */
+UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
+                "Datafab Systems, Inc.",
+                "USB to CF + SM Combo (LC1)",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+/* Reported by Felix Moeller <felix@derklecks.de>
+ * in Germany this is sold by Hama with the productnumber 46952
+ * as "DualSlot CompactFlash(TM) & MStick Drive USB"
+ */
+UNUSUAL_DEV(  0x07c4, 0xa10b, 0x0000, 0xffff,
+                "DataFab Systems Inc.",
+                "USB CF+MS",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                0),
+UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
+                "Acomdata",
+                "CF",
+                US_SC_SCSI, US_PR_DATAFAB, NULL,
+                US_FL_SINGLE_LUN),
+#endif /* defined(CONFIG_USB_STORAGE_DATAFAB) || ... */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index cfde74a6faa3..1c1f643e8a78 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -53,6 +53,11 @@
 * as opposed to devices that do something strangely or wrongly.
 */
+#if !defined(CONFIG_USB_STORAGE_SDDR09) && \
+                !defined(CONFIG_USB_STORAGE_SDDR09_MODULE)
+#define NO_SDDR09
+#endif
 /* patch submitted by Vivian Bregier <Vivian.Bregier@imag.fr>
 */
 UNUSUAL_DEV(  0x03eb, 0x2002, 0x0100, 0x0100,
@@ -80,18 +85,6 @@ UNUSUAL_DEV(  0x03f0, 0x0107, 0x0200, 0x0200,
                "CD-Writer+",
                US_SC_8070, US_PR_CB, NULL, 0),
-#ifdef CONFIG_USB_STORAGE_USBAT
-UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001,
-                "HP",
-                "CD-Writer+ 8200e",
-                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
-UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
-                "HP",
-                "CD-Writer+ CD-4e",
-                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
-#endif
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV(  0x03f0, 0x070c, 0x0000, 0x0000,
                "HP",
@@ -246,12 +239,7 @@ UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_SINGLE_LUN ),
-#ifdef CONFIG_USB_STORAGE_SDDR09
+#ifdef NO_SDDR09
-UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
-                "Microtech",
-                "CameraMate (DPCM_USB)",
-                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ),
-#else
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                "Microtech",
                "CameraMate",
@@ -288,13 +276,6 @@ UNUSUAL_DEV(  0x0457, 0x0151, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_NOT_LOCKABLE ),
-#ifdef CONFIG_USB_STORAGE_KARMA
-UNUSUAL_DEV(  0x045a, 0x5210, 0x0101, 0x0101,
-                "Rio",
-                "Rio Karma",
-                US_SC_SCSI, US_PR_KARMA, rio_karma_init, 0),
-#endif
 /* Reported by Tamas Kerecsen <kerecsen@bigfoot.com>
 * Obviously the PROM has not been customized by the VAR;
 * the Vendor and Product string descriptors are:
@@ -375,22 +356,6 @@ UNUSUAL_DEV(  0x04b3, 0x4001, 0x0110, 0x0110,
                US_SC_DEVICE, US_PR_CB, NULL,
                US_FL_MAX_SECTORS_MIN),
-#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
-/* CY7C68300 : support atacb */
-UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
-                "Cypress",
-                "Cypress AT2LP",
-                US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
-                0),
-/* CY7C68310 : support atacb and atacb2 */
-UNUSUAL_DEV(  0x04b4, 0x6831, 0x0000, 0x9999,
-                "Cypress",
-                "Cypress ISD-300LP",
-                US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
-                0),
-#endif
 /* Reported by Simon Levitt <simon@whattf.com>
 * This entry needs Sub and Proto fields */
 UNUSUAL_DEV(  0x04b8, 0x0601, 0x0100, 0x0100,
@@ -467,20 +432,7 @@ UNUSUAL_DEV(  0x04e6, 0x0002, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init, 
                US_FL_SCM_MULT_TARG ),
-#ifdef CONFIG_USB_STORAGE_SDDR09
+#ifdef NO_SDDR09
-UNUSUAL_DEV(  0x04e6, 0x0003, 0x0000, 0x9999,
-                "Sandisk",
-                "ImageMate SDDR09",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
-                0),
-/* This entry is from Andries.Brouwer@cwi.nl */
-UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
-                "SCM Microsystems",
-                "eUSB SmartMedia / CompactFlash Adapter",
-                US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
-                0),
-#else
 UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
                "SCM Microsystems",
                "eUSB CompactFlash Adapter",
@@ -535,14 +487,6 @@ UNUSUAL_DEV(  0x04e6, 0x0101, 0x0200, 0x0200,
                "CD-RW Device",
                US_SC_8020, US_PR_CB, NULL, 0),
-#ifdef CONFIG_USB_STORAGE_USBAT
-UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
-                "Shuttle/SCM",
-                "USBAT-02",
-                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
-                US_FL_SINGLE_LUN),
-#endif
 /* Reported by Dmitry Khlystov <adminimus@gmail.com> */
 UNUSUAL_DEV(  0x04e8, 0x507c, 0x0220, 0x0220,
                "Samsung",
@@ -645,14 +589,6 @@ UNUSUAL_DEV(  0x054c, 0x0025, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_SINGLE_LUN ),
-#ifdef CONFIG_USB_STORAGE_ISD200
-UNUSUAL_DEV(  0x054c, 0x002b, 0x0100, 0x0110,
-                "Sony",
-                "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-#endif
 /* Submitted by Olaf Hering, <olh@suse.de> SuSE Bugzilla #49049 */
 UNUSUAL_DEV(  0x054c, 0x002c, 0x0501, 0x2000,
                "Sony",
@@ -749,13 +685,6 @@ UNUSUAL_DEV(  0x057b, 0x0022, 0x0000, 0x9999,
                "Silicon Media R/W",
                US_SC_DEVICE, US_PR_DEVICE, NULL, 0),
-#ifdef CONFIG_USB_STORAGE_ALAUDA
-UNUSUAL_DEV(  0x0584, 0x0008, 0x0102, 0x0102,
-                "Fujifilm",
-                "DPC-R1 (Alauda)",
-                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0 ),
-#endif
 /* Reported by RTE <raszilki@yandex.ru> */
 UNUSUAL_DEV(  0x058f, 0x6387, 0x0141, 0x0141,
                "JetFlash",
@@ -798,32 +727,6 @@ UNUSUAL_DEV(  0x05ab, 0x0060, 0x1104, 0x1110,
                US_SC_SCSI, US_PR_BULK, NULL,
                US_FL_NEED_OVERRIDE ),
-#ifdef CONFIG_USB_STORAGE_ISD200
-UNUSUAL_DEV(  0x05ab, 0x0031, 0x0100, 0x0110,
-                "In-System",
-                "USB/IDE Bridge (ATA/ATAPI)",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-UNUSUAL_DEV(  0x05ab, 0x0301, 0x0100, 0x0110,
-                "In-System",
-                "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-UNUSUAL_DEV(  0x05ab, 0x0351, 0x0100, 0x0110,
-                "In-System",
-                "Portable USB Harddrive V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-UNUSUAL_DEV(  0x05ab, 0x5701, 0x0100, 0x0110,
-                "In-System",
-                "USB Storage Adapter V2",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-#endif
 /* Submitted by Sven Anderson <sven-linux@anderson.de>
 * There are at least four ProductIDs used for iPods, so I added 0x1202 and
 * 0x1204. They just need the US_FL_FIX_CAPACITY. As the bcdDevice appears
@@ -877,14 +780,6 @@ UNUSUAL_DEV(  0x05c6, 0x1000, 0x0000, 0x9999,
                US_SC_DEVICE, US_PR_DEVICE, option_ms_init,
                0),
-#ifdef CONFIG_USB_STORAGE_JUMPSHOT
-UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
-                "Lexar",
-                "Jumpshot USB CF Reader",
-                US_SC_SCSI, US_PR_JUMPSHOT, NULL,
-                US_FL_NEED_OVERRIDE ),
-#endif
 /* Reported by Blake Matheny <bmatheny@purdue.edu> */
 UNUSUAL_DEV(  0x05dc, 0xb002, 0x0000, 0x0113,
                "Lexar",
@@ -935,14 +830,6 @@ UNUSUAL_DEV(  0x0644, 0x0000, 0x0100, 0x0100,
                "Floppy Drive",
                US_SC_UFI, US_PR_CB, NULL, 0 ),
-#ifdef CONFIG_USB_STORAGE_SDDR09
-UNUSUAL_DEV(  0x066b, 0x0105, 0x0100, 0x0100,
-                "Olympus",
-                "Camedia MAUSB-2",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
-                0),
-#endif
 /* Reported by Darsen Lu <darsen@micro.ee.nthu.edu.tw> */
 UNUSUAL_DEV( 0x066f, 0x8000, 0x0001, 0x0001,
                "SigmaTel",
@@ -1043,35 +930,12 @@ UNUSUAL_DEV(  0x0781, 0x0002, 0x0009, 0x0009,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_FIX_CAPACITY ),
-#ifdef CONFIG_USB_STORAGE_USBAT
-UNUSUAL_DEV(  0x0781, 0x0005, 0x0005, 0x0005,
-                "Sandisk",
-                "ImageMate SDDR-05b",
-                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
-                US_FL_SINGLE_LUN ),
-#endif
 UNUSUAL_DEV(  0x0781, 0x0100, 0x0100, 0x0100,
                "Sandisk",
                "ImageMate SDDR-12",
                US_SC_SCSI, US_PR_CB, NULL,
                US_FL_SINGLE_LUN ),
-#ifdef CONFIG_USB_STORAGE_SDDR09
-UNUSUAL_DEV(  0x0781, 0x0200, 0x0000, 0x9999,
-                "Sandisk",
-                "ImageMate SDDR-09",
-                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
-                0),
-#endif
-#ifdef CONFIG_USB_STORAGE_FREECOM
-UNUSUAL_DEV(  0x07ab, 0xfc01, 0x0000, 0x9999,
-                "Freecom",
-                "USB-IDE",
-                US_SC_QIC, US_PR_FREECOM, freecom_init, 0),
-#endif
 /* Reported by Eero Volotinen <eero@ping-viini.org> */
 UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0000, 0x9999,
                "Freecom Technologies",
@@ -1091,12 +955,7 @@ UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
                US_FL_SCM_MULT_TARG ),
-#ifdef CONFIG_USB_STORAGE_SDDR09
+#ifdef NO_SDDR09
-UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
-                "Microtech",
-                "CameraMate (DPCM_USB)",
-                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ),
-#else
 UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
                "Microtech",
                "CameraMate",
@@ -1104,108 +963,6 @@ UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
                US_FL_SINGLE_LUN ),
 #endif
-#ifdef CONFIG_USB_STORAGE_ALAUDA
-UNUSUAL_DEV(  0x07b4, 0x010a, 0x0102, 0x0102,
-                "Olympus",
-                "MAUSB-10 (Alauda)",
-                US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0 ),
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-UNUSUAL_DEV(  0x07c4, 0xa000, 0x0000, 0x0015,
-                "Datafab",
-                "MDCFE-B USB CF Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-/*
- * The following Datafab-based devices may or may not work
- * using the current driver...the 0xffff is arbitrary since I
- * don't know what device versions exist for these guys.
- *
- * The 0xa003 and 0xa004 devices in particular I'm curious about.
- * I'm told they exist but so far nobody has come forward to say that
- * they work with this driver.  Given the success we've had getting
- * other Datafab-based cards operational with this driver, I've decided
- * to leave these two devices in the list.
- */
-UNUSUAL_DEV( 0x07c4, 0xa001, 0x0000, 0xffff,
-                "SIIG/Datafab",
-                "SIIG/Datafab Memory Stick+CF Reader/Writer",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-/* Reported by Josef Reisinger <josef.reisinger@netcologne.de> */
-UNUSUAL_DEV( 0x07c4, 0xa002, 0x0000, 0xffff,
-                "Datafab/Unknown",
-                "MD2/MD3 Disk enclosure",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                US_FL_SINGLE_LUN ),
-UNUSUAL_DEV( 0x07c4, 0xa003, 0x0000, 0xffff,
-                "Datafab/Unknown",
-                "Datafab-based Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-UNUSUAL_DEV( 0x07c4, 0xa004, 0x0000, 0xffff,
-                "Datafab/Unknown",
-                "Datafab-based Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-UNUSUAL_DEV( 0x07c4, 0xa005, 0x0000, 0xffff,
-                "PNY/Datafab",
-                "PNY/Datafab CF+SM Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-UNUSUAL_DEV( 0x07c4, 0xa006, 0x0000, 0xffff,
-                "Simple Tech/Datafab",
-                "Simple Tech/Datafab CF+SM Reader",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-#endif
-                
-#ifdef CONFIG_USB_STORAGE_SDDR55
-/* Contributed by Peter Waechtler */
-UNUSUAL_DEV( 0x07c4, 0xa103, 0x0000, 0x9999,
-                "Datafab",
-                "MDSM-B reader",
-                US_SC_SCSI, US_PR_SDDR55, NULL,
-                US_FL_FIX_INQUIRY ),
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-/* Submitted by Olaf Hering <olh@suse.de> */
-UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
-                "Datafab Systems, Inc.",
-                "USB to CF + SM Combo (LC1)",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR55
-/* SM part - aeb <Andries.Brouwer@cwi.nl> */
-UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
-                "Datafab Systems, Inc.",
-                "USB to CF + SM Combo (LC1)",
-                US_SC_SCSI, US_PR_SDDR55, NULL,
-                US_FL_SINGLE_LUN ),
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-/* Reported by Felix Moeller <felix@derklecks.de>
- * in Germany this is sold by Hama with the productnumber 46952
- * as "DualSlot CompactFlash(TM) & MStick Drive USB"
- */
-UNUSUAL_DEV(  0x07c4, 0xa10b, 0x0000, 0xffff,
-                "DataFab Systems Inc.",
-                "USB CF+MS",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                0 ),
-#endif
 /* Datafab KECF-USB / Sagatek DCS-CF / Simpletech Flashlink UCF-100
 * Only revision 1.13 tested (same for all of the above devices,
 * based on the Datafab DF-UG-07 chip).  Needed for US_FL_FIX_INQUIRY.
@@ -1409,29 +1166,6 @@ UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_SANE_SENSE ),
-#ifdef CONFIG_USB_STORAGE_ISD200
-UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
-                "ATI",
-                "USB Cable 205",
-                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
-                0 ),
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
-                "Acomdata",
-                "CF",
-                US_SC_SCSI, US_PR_DATAFAB, NULL,
-                US_FL_SINGLE_LUN ),
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR55
-UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
-                "Acomdata",
-                "SM",
-                US_SC_SCSI, US_PR_SDDR55, NULL,
-                US_FL_SINGLE_LUN ),
-#endif
 UNUSUAL_DEV(  0x0d49, 0x7310, 0x0000, 0x9999,
                "Maxtor",
                "USB to SATA",
@@ -1448,23 +1182,6 @@ UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_SINGLE_LUN ),
-/* Submitted by: Nick Sillik <n.sillik@temple.edu>
- * Needed for OneTouch extension to usb-storage
- *
- */
-#ifdef CONFIG_USB_STORAGE_ONETOUCH
-        UNUSUAL_DEV(  0x0d49, 0x7000, 0x0000, 0x9999,
-                        "Maxtor",
-                        "OneTouch External Harddrive",
-                        US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
-                        0),
-        UNUSUAL_DEV(  0x0d49, 0x7010, 0x0000, 0x9999,
-                        "Maxtor",
-                        "OneTouch External Harddrive",
-                        US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
-                        0),
-#endif
 /* Submitted by Joris Struyve <joris@struyve.be> */
 UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
                "Medion",
@@ -2117,14 +1834,6 @@ UNUSUAL_DEV(  0x4146, 0xba01, 0x0100, 0x0100,
                "Micro Mini 1GB",
                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
-#ifdef CONFIG_USB_STORAGE_SDDR55
-UNUSUAL_DEV(  0x55aa, 0xa103, 0x0000, 0x9999, 
-                "Sandisk",
-                "ImageMate SDDR55",
-                US_SC_SCSI, US_PR_SDDR55, NULL,
-                US_FL_SINGLE_LUN),
-#endif
 /* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
 UNUSUAL_DEV(  0xed06, 0x4500, 0x0001, 0x0001,
                "DataStor",
diff --git a/drivers/usb/storage/cypress_atacb.h b/drivers/usb/storage/unusual_freecom.h
index fbada898d56b..375867942391 100644
--- a/drivers/usb/storage/cypress_atacb.h
+++ b/drivers/usb/storage/unusual_freecom.h
@@ -1,8 +1,4 @@
-/*
+/* Unusual Devices File for the Freecom USB/IDE adaptor
- * Support for emulating SAT (ata pass through) on devices based
- *       on the Cypress USB/ATA bridge supporting ATACB.
- *
- * Copyright (c) 2008 Matthieu Castet (castet.matthieu@free.fr)
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
@@ -19,7 +15,12 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#ifndef _CYPRESS_ATACB_H_
+#if defined(CONFIG_USB_STORAGE_FREECOM) || \
-#define _CYPRESS_ATACB_H_
+                defined(CONFIG_USB_STORAGE_FREECOM_MODULE)
-extern void cypress_atacb_passthrough(struct scsi_cmnd*, struct us_data*);
-#endif
+UNUSUAL_DEV(  0x07ab, 0xfc01, 0x0000, 0x9999,
+                "Freecom",
+                "USB-IDE",
+                US_SC_QIC, US_PR_FREECOM, init_freecom, 0),
+#endif /* defined(CONFIG_USB_STORAGE_FREECOM) || ... */
diff --git a/drivers/usb/storage/unusual_isd200.h b/drivers/usb/storage/unusual_isd200.h
new file mode 100644
index 000000000000..0d99dde3382a
--- /dev/null
+++ b/drivers/usb/storage/unusual_isd200.h
@@ -0,0 +1,57 @@
+/* Unusual Devices File for In-System Design, Inc. ISD200 ASIC
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_ISD200) || \
+                defined(CONFIG_USB_STORAGE_ISD200_MODULE)
+UNUSUAL_DEV(  0x054c, 0x002b, 0x0100, 0x0110,
+                "Sony",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+UNUSUAL_DEV(  0x05ab, 0x0031, 0x0100, 0x0110,
+                "In-System",
+                "USB/IDE Bridge (ATA/ATAPI)",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+UNUSUAL_DEV(  0x05ab, 0x0301, 0x0100, 0x0110,
+                "In-System",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+UNUSUAL_DEV(  0x05ab, 0x0351, 0x0100, 0x0110,
+                "In-System",
+                "Portable USB Harddrive V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+UNUSUAL_DEV(  0x05ab, 0x5701, 0x0100, 0x0110,
+                "In-System",
+                "USB Storage Adapter V2",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
+                "ATI",
+                "USB Cable 205",
+                US_SC_ISD200, US_PR_BULK, isd200_Initialization,
+                0),
+#endif /* defined(CONFIG_USB_STORAGE_ISD200) || ... */
diff --git a/drivers/usb/storage/sddr55.h b/drivers/usb/storage/unusual_jumpshot.h
index a815a0470c84..2e549b1c2c62 100644
--- a/drivers/usb/storage/sddr55.h
+++ b/drivers/usb/storage/unusual_jumpshot.h
@@ -1,10 +1,4 @@
-/* Driver for SanDisk SDDR-55 SmartMedia reader
+/* Unusual Devices File for the Lexar "Jumpshot" Compact Flash reader
- * Header File
- *
- * Current development and maintenance by:
- *   (c) 2002 Simon Munton
- *
- * See sddr55.c for more explanation
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
@@ -21,12 +15,13 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#ifndef _USB_SHUTTLE_EUSB_SDDR55_H
+#if defined(CONFIG_USB_STORAGE_JUMPSHOT) || \
-#define _USB_SHUTTLE_EUSB_SDDR55_H
+                defined(CONFIG_USB_STORAGE_JUMPSHOT_MODULE)
-/* Sandisk SDDR-55 stuff */
-extern int sddr55_transport(struct scsi_cmnd *srb, struct us_data *us);
+UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
-extern int sddr55_reset(struct us_data *us);
+                "Lexar",
+                "Jumpshot USB CF Reader",
+                US_SC_SCSI, US_PR_JUMPSHOT, NULL,
+                US_FL_NEED_OVERRIDE),
-#endif
+#endif /* defined(CONFIG_USB_STORAGE_JUMPSHOT) || ... */
diff --git a/drivers/usb/storage/isd200.h b/drivers/usb/storage/unusual_karma.h
index 0a35f4fa78f8..12ae3a03e802 100644
--- a/drivers/usb/storage/isd200.h
+++ b/drivers/usb/storage/unusual_karma.h
@@ -1,11 +1,4 @@
-/* Header File for In-System Design, Inc. ISD200 ASIC
+/* Unusual Devices File for the Rio Karma
- *
- * First release
- *
- * Current development and maintenance by:
- *   (c) 2000 In-System Design, Inc. (support@in-system.com)
- *
- * See isd200.c for more information.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
@@ -22,10 +15,12 @@
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#ifndef _USB_ISD200_H
+#if defined(CONFIG_USB_STORAGE_KARMA) || \
-#define _USB_ISD200_H
+                defined(CONFIG_USB_STORAGE_KARMA_MODULE)
-extern void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us);
+UNUSUAL_DEV(  0x045a, 0x5210, 0x0101, 0x0101,
-extern int isd200_Initialization(struct us_data *us);
+                "Rio",
+                "Rio Karma",
+                US_SC_SCSI, US_PR_KARMA, rio_karma_init, 0),
-#endif
+#endif /* defined(CONFIG_USB_STORAGE_KARMA) || ... */
diff --git a/drivers/usb/storage/unusual_onetouch.h b/drivers/usb/storage/unusual_onetouch.h
new file mode 100644
index 000000000000..bd9306b637df
--- /dev/null
+++ b/drivers/usb/storage/unusual_onetouch.h
@@ -0,0 +1,36 @@
+/* Unusual Devices File for the Maxtor OneTouch USB hard drive's button
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_ONETOUCH) || \
+                defined(CONFIG_USB_STORAGE_ONETOUCH_MODULE)
+/* Submitted by: Nick Sillik <n.sillik@temple.edu>
+ * Needed for OneTouch extension to usb-storage
+ */
+UNUSUAL_DEV(  0x0d49, 0x7000, 0x0000, 0x9999,
+                "Maxtor",
+                "OneTouch External Harddrive",
+                US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
+                0),
+UNUSUAL_DEV(  0x0d49, 0x7010, 0x0000, 0x9999,
+                "Maxtor",
+                "OneTouch External Harddrive",
+                US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
+                0),
+#endif /* defined(CONFIG_USB_STORAGE_ONETOUCH) || ... */
diff --git a/drivers/usb/storage/unusual_sddr09.h b/drivers/usb/storage/unusual_sddr09.h
new file mode 100644
index 000000000000..50cab511a4d7
--- /dev/null
+++ b/drivers/usb/storage/unusual_sddr09.h
@@ -0,0 +1,56 @@
+/* Unusual Devices File for SanDisk SDDR-09 SmartMedia reader
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_SDDR09) || \
+                defined(CONFIG_USB_STORAGE_SDDR09_MODULE)
+UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
+                "Microtech",
+                "CameraMate (DPCM_USB)",
+                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0),
+UNUSUAL_DEV(  0x04e6, 0x0003, 0x0000, 0x9999,
+                "Sandisk",
+                "ImageMate SDDR09",
+                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                0),
+/* This entry is from Andries.Brouwer@cwi.nl */
+UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
+                "SCM Microsystems",
+                "eUSB SmartMedia / CompactFlash Adapter",
+                US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
+                0),
+UNUSUAL_DEV(  0x066b, 0x0105, 0x0100, 0x0100,
+                "Olympus",
+                "Camedia MAUSB-2",
+                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                0),
+UNUSUAL_DEV(  0x0781, 0x0200, 0x0000, 0x9999,
+                "Sandisk",
+                "ImageMate SDDR-09",
+                US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init,
+                0),
+UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
+                "Microtech",
+                "CameraMate (DPCM_USB)",
+                US_SC_SCSI, US_PR_DPCM_USB, NULL, 0),
+#endif /* defined(CONFIG_USB_STORAGE_SDDR09) || ... */
diff --git a/drivers/usb/storage/unusual_sddr55.h b/drivers/usb/storage/unusual_sddr55.h
new file mode 100644
index 000000000000..ae81ef7a1cfd
--- /dev/null
+++ b/drivers/usb/storage/unusual_sddr55.h
@@ -0,0 +1,44 @@
+/* Unusual Devices File for SanDisk SDDR-55 SmartMedia reader
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_SDDR55) || \
+                defined(CONFIG_USB_STORAGE_SDDR55_MODULE)
+/* Contributed by Peter Waechtler */
+UNUSUAL_DEV( 0x07c4, 0xa103, 0x0000, 0x9999,
+                "Datafab",
+                "MDSM-B reader",
+                US_SC_SCSI, US_PR_SDDR55, NULL,
+                US_FL_FIX_INQUIRY),
+/* SM part - aeb <Andries.Brouwer@cwi.nl> */
+UNUSUAL_DEV(  0x07c4, 0xa109, 0x0000, 0xffff,
+                "Datafab Systems, Inc.",
+                "USB to CF + SM Combo (LC1)",
+                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
+                "Acomdata",
+                "SM",
+                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+UNUSUAL_DEV(  0x55aa, 0xa103, 0x0000, 0x9999,
+                "Sandisk",
+                "ImageMate SDDR55",
+                US_SC_SCSI, US_PR_SDDR55, NULL, 0),
+#endif /* defined(CONFIG_USB_STORAGE_SDDR55) || ... */
diff --git a/drivers/usb/storage/unusual_usbat.h b/drivers/usb/storage/unusual_usbat.h
new file mode 100644
index 000000000000..80e869f10180
--- /dev/null
+++ b/drivers/usb/storage/unusual_usbat.h
@@ -0,0 +1,43 @@
+/* Unusual Devices File for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#if defined(CONFIG_USB_STORAGE_USBAT) || \
+                defined(CONFIG_USB_STORAGE_USBAT_MODULE)
+UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001,
+                "HP",
+                "CD-Writer+ 8200e",
+                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
+UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
+                "HP",
+                "CD-Writer+ CD-4e",
+                US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
+UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
+                "Shuttle/SCM",
+                "USBAT-02",
+                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
+                US_FL_SINGLE_LUN),
+UNUSUAL_DEV(  0x0781, 0x0005, 0x0005, 0x0005,
+                "Sandisk",
+                "ImageMate SDDR-05b",
+                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
+                US_FL_SINGLE_LUN),
+#endif /* defined(CONFIG_USB_STORAGE_USBAT) || ... */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 4becf495ca2d..8060b85fe1a3 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -5,7 +5,7 @@
 *
 * Developed with the assistance of:
 *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
- *   (c) 2003 Alan Stern (stern@rowland.harvard.edu)
+ *   (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu)
 *
 * Initial work by:
 *   (c) 1999 Michael Gee (michael@linuxspecific.com)
@@ -66,39 +66,6 @@
 #include "debug.h"
 #include "initializers.h"
-#ifdef CONFIG_USB_STORAGE_USBAT
-#include "shuttle_usbat.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR09
-#include "sddr09.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR55
-#include "sddr55.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_FREECOM
-#include "freecom.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_ISD200
-#include "isd200.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-#include "datafab.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_JUMPSHOT
-#include "jumpshot.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_ONETOUCH
-#include "onetouch.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_ALAUDA
-#include "alauda.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_KARMA
-#include "karma.h"
-#endif
-#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
-#include "cypress_atacb.h"
-#endif
 #include "sierra_ms.h"
 #include "option_ms.h"
@@ -118,36 +85,8 @@ MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
 /*
 * The entries in this table correspond, line for line,
- * with the entries of us_unusual_dev_list[].
+ * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
 */
-#ifndef CONFIG_USB_LIBUSUAL
-#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
-                    vendorName, productName,useProtocol, useTransport, \
-                    initFunction, flags) \
-{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
-#define COMPLIANT_DEV   UNUSUAL_DEV
-#define USUAL_DEV(useProto, useTrans, useType) \
-{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
-  .driver_info = (USB_US_TYPE_STOR<<24) }
-static struct usb_device_id storage_usb_ids [] = {
-#       include "unusual_devs.h"
-#undef UNUSUAL_DEV
-#undef COMPLIANT_DEV
-#undef USUAL_DEV
-        /* Terminating entry */
-        { }
-};
-MODULE_DEVICE_TABLE (usb, storage_usb_ids);
-#endif /* CONFIG_USB_LIBUSUAL */
-/* This is the list of devices we recognize, along with their flag data */
 /* The vendor name should be kept at eight characters or less, and
 * the product name should be kept at 16 characters or less. If a device
@@ -179,18 +118,17 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids);
 static struct us_unusual_dev us_unusual_dev_list[] = {
 #       include "unusual_devs.h" 
-#       undef UNUSUAL_DEV
+        { }             /* Terminating entry */
-#       undef COMPLIANT_DEV
-#       undef USUAL_DEV
-        /* Terminating entry */
-        { NULL }
 };
+#undef UNUSUAL_DEV
+#undef COMPLIANT_DEV
+#undef USUAL_DEV
 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
-static int storage_suspend(struct usb_interface *iface, pm_message_t message)
+int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
 {
        struct us_data *us = usb_get_intfdata(iface);
@@ -207,8 +145,9 @@ static int storage_suspend(struct usb_interface *iface, pm_message_t message)
        mutex_unlock(&us->dev_mutex);
        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_stor_suspend);
-static int storage_resume(struct usb_interface *iface)
+int usb_stor_resume(struct usb_interface *iface)
 {
        struct us_data *us = usb_get_intfdata(iface);
@@ -221,8 +160,9 @@ static int storage_resume(struct usb_interface *iface)
        mutex_unlock(&us->dev_mutex);
        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_stor_resume);
-static int storage_reset_resume(struct usb_interface *iface)
+int usb_stor_reset_resume(struct usb_interface *iface)
 {
        struct us_data *us = usb_get_intfdata(iface);
@@ -235,6 +175,7 @@ static int storage_reset_resume(struct usb_interface *iface)
         * the device */
        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
 #endif /* CONFIG_PM */
@@ -243,7 +184,7 @@ static int storage_reset_resume(struct usb_interface *iface)
 * a USB port reset, whether from this driver or a different one.
 */
-static int storage_pre_reset(struct usb_interface *iface)
+int usb_stor_pre_reset(struct usb_interface *iface)
 {
        struct us_data *us = usb_get_intfdata(iface);
@@ -253,8 +194,9 @@ static int storage_pre_reset(struct usb_interface *iface)
        mutex_lock(&us->dev_mutex);
        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
-static int storage_post_reset(struct usb_interface *iface)
+int usb_stor_post_reset(struct usb_interface *iface)
 {
        struct us_data *us = usb_get_intfdata(iface);
@@ -269,6 +211,7 @@ static int storage_post_reset(struct usb_interface *iface)
        mutex_unlock(&us->dev_mutex);
        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_stor_post_reset);
 /*
 * fill_inquiry_response takes an unsigned char array (which must
@@ -311,6 +254,7 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
        usb_stor_set_xfer_buf(data, data_len, us->srb);
 }
+EXPORT_SYMBOL_GPL(fill_inquiry_response);
 static int usb_stor_control_thread(void * __us)
 {
@@ -551,20 +495,13 @@ static void adjust_quirks(struct us_data *us)
                        vid, pid, f);
 }
-/* Find an unusual_dev descriptor (always succeeds in the current code) */
-static struct us_unusual_dev *find_unusual(const struct usb_device_id *id)
-{
-        const int id_index = id - storage_usb_ids;
-        return &us_unusual_dev_list[id_index];
-}
 /* Get the unusual_devs entries and the string descriptors */
-static int get_device_info(struct us_data *us, const struct usb_device_id *id)
+static int get_device_info(struct us_data *us, const struct usb_device_id *id,
+                struct us_unusual_dev *unusual_dev)
 {
        struct usb_device *dev = us->pusb_dev;
        struct usb_interface_descriptor *idesc =
                &us->pusb_intf->cur_altsetting->desc;
-        struct us_unusual_dev *unusual_dev = find_unusual(id);
        /* Store the entries */
        us->unusual_dev = unusual_dev;
@@ -629,7 +566,7 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
 }
 /* Get the transport settings */
-static int get_transport(struct us_data *us)
+static void get_transport(struct us_data *us)
 {
        switch (us->protocol) {
        case US_PR_CB:
@@ -651,100 +588,11 @@ static int get_transport(struct us_data *us)
                us->transport = usb_stor_Bulk_transport;
                us->transport_reset = usb_stor_Bulk_reset;
                break;
-#ifdef CONFIG_USB_STORAGE_USBAT
-        case US_PR_USBAT:
-                us->transport_name = "Shuttle USBAT";
-                us->transport = usbat_transport;
-                us->transport_reset = usb_stor_CB_reset;
-                us->max_lun = 1;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR09
-        case US_PR_EUSB_SDDR09:
-                us->transport_name = "EUSB/SDDR09";
-                us->transport = sddr09_transport;
-                us->transport_reset = usb_stor_CB_reset;
-                us->max_lun = 0;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_SDDR55
-        case US_PR_SDDR55:
-                us->transport_name = "SDDR55";
-                us->transport = sddr55_transport;
-                us->transport_reset = sddr55_reset;
-                us->max_lun = 0;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_DPCM
-        case US_PR_DPCM_USB:
-                us->transport_name = "Control/Bulk-EUSB/SDDR09";
-                us->transport = dpcm_transport;
-                us->transport_reset = usb_stor_CB_reset;
-                us->max_lun = 1;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_FREECOM
-        case US_PR_FREECOM:
-                us->transport_name = "Freecom";
-                us->transport = freecom_transport;
-                us->transport_reset = usb_stor_freecom_reset;
-                us->max_lun = 0;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_DATAFAB
-        case US_PR_DATAFAB:
-                us->transport_name  = "Datafab Bulk-Only";
-                us->transport = datafab_transport;
-                us->transport_reset = usb_stor_Bulk_reset;
-                us->max_lun = 1;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_JUMPSHOT
-        case US_PR_JUMPSHOT:
-                us->transport_name  = "Lexar Jumpshot Control/Bulk";
-                us->transport = jumpshot_transport;
-                us->transport_reset = usb_stor_Bulk_reset;
-                us->max_lun = 1;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_ALAUDA
-        case US_PR_ALAUDA:
-                us->transport_name  = "Alauda Control/Bulk";
-                us->transport = alauda_transport;
-                us->transport_reset = usb_stor_Bulk_reset;
-                us->max_lun = 1;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_KARMA
-        case US_PR_KARMA:
-                us->transport_name = "Rio Karma/Bulk";
-                us->transport = rio_karma_transport;
-                us->transport_reset = usb_stor_Bulk_reset;
-                break;
-#endif
-        default:
-                return -EIO;
        }
-        US_DEBUGP("Transport: %s\n", us->transport_name);
-        /* fix for single-lun devices */
-        if (us->fflags & US_FL_SINGLE_LUN)
-                us->max_lun = 0;
-        return 0;
 }
 /* Get the protocol settings */
-static int get_protocol(struct us_data *us)
+static void get_protocol(struct us_data *us)
 {
        switch (us->subclass) {
        case US_SC_RBC:
@@ -779,26 +627,7 @@ static int get_protocol(struct us_data *us)
                us->protocol_name = "Uniform Floppy Interface (UFI)";
                us->proto_handler = usb_stor_ufi_command;
                break;
-#ifdef CONFIG_USB_STORAGE_ISD200
-        case US_SC_ISD200:
-                us->protocol_name = "ISD200 ATA/ATAPI";
-                us->proto_handler = isd200_ata_command;
-                break;
-#endif
-#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
-        case US_SC_CYP_ATACB:
-                us->protocol_name = "Transparent SCSI with Cypress ATACB";
-                us->proto_handler = cypress_atacb_passthrough;
-                break;
-#endif
-        default:
-                return -EIO;
        }
-        US_DEBUGP("Protocol: %s\n", us->protocol_name);
-        return 0;
 }
 /* Get the pipe settings */
@@ -846,12 +675,12 @@ static int get_pipes(struct us_data *us)
        us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
        us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
        us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
-                ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                usb_endpoint_num(ep_out));
        us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 
-                ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                usb_endpoint_num(ep_in));
        if (ep_int) {
                us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
-                        ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                        usb_endpoint_num(ep_int));
                us->ep_bInterval = ep_int->bInterval;
        }
        return 0;
@@ -1012,17 +841,15 @@ static int usb_stor_scan_thread(void * __us)
 }
-/* Probe to see if we can drive a newly-connected USB device */
+/* First part of general USB mass-storage probing */
-static int storage_probe(struct usb_interface *intf,
+int usb_stor_probe1(struct us_data **pus,
-                         const struct usb_device_id *id)
+                struct usb_interface *intf,
+                const struct usb_device_id *id,
+                struct us_unusual_dev *unusual_dev)
 {
        struct Scsi_Host *host;
        struct us_data *us;
        int result;
-        struct task_struct *th;
-        if (usb_usual_check_type(id, USB_US_TYPE_STOR))
-                return -ENXIO;
        US_DEBUGP("USB Mass Storage device detected\n");
@@ -1041,7 +868,7 @@ static int storage_probe(struct usb_interface *intf,
         * Allow 16-byte CDBs and thus > 2TB
         */
        host->max_cmd_len = 16;
-        us = host_to_us(host);
+        *pus = us = host_to_us(host);
        memset(us, 0, sizeof(struct us_data));
        mutex_init(&(us->dev_mutex));
        init_completion(&us->cmnd_ready);
@@ -1054,24 +881,46 @@ static int storage_probe(struct usb_interface *intf,
        if (result)
                goto BadDevice;
-        /*
+        /* Get the unusual_devs entries and the descriptors */
-         * Get the unusual_devs entries and the descriptors
+        result = get_device_info(us, id, unusual_dev);
-         *
-         * id_index is calculated in the declaration to be the index number
-         * of the match from the usb_device_id table, so we can find the
-         * corresponding entry in the private table.
-         */
-        result = get_device_info(us, id);
        if (result)
                goto BadDevice;
-        /* Get the transport, protocol, and pipe settings */
+        /* Get standard transport and protocol settings */
-        result = get_transport(us);
+        get_transport(us);
-        if (result)
+        get_protocol(us);
-                goto BadDevice;
-        result = get_protocol(us);
+        /* Give the caller a chance to fill in specialized transport
-        if (result)
+         * or protocol settings.
+         */
+        return 0;
+BadDevice:
+        US_DEBUGP("storage_probe() failed\n");
+        release_everything(us);
+        return result;
+}
+EXPORT_SYMBOL_GPL(usb_stor_probe1);
+/* Second part of general USB mass-storage probing */
+int usb_stor_probe2(struct us_data *us)
+{
+        struct task_struct *th;
+        int result;
+        /* Make sure the transport and protocol have both been set */
+        if (!us->transport || !us->proto_handler) {
+                result = -ENXIO;
                goto BadDevice;
+        }
+        US_DEBUGP("Transport: %s\n", us->transport_name);
+        US_DEBUGP("Protocol: %s\n", us->protocol_name);
+        /* fix for single-lun devices */
+        if (us->fflags & US_FL_SINGLE_LUN)
+                us->max_lun = 0;
+        /* Find the endpoints and calculate pipe values */
        result = get_pipes(us);
        if (result)
                goto BadDevice;
@@ -1080,7 +929,7 @@ static int storage_probe(struct usb_interface *intf,
        result = usb_stor_acquire_resources(us);
        if (result)
                goto BadDevice;
-        result = scsi_add_host(host, &intf->dev);
+        result = scsi_add_host(us_to_host(us), &us->pusb_intf->dev);
        if (result) {
                printk(KERN_WARNING USB_STORAGE
                        "Unable to add the scsi host\n");
@@ -1108,9 +957,10 @@ BadDevice:
        release_everything(us);
        return result;
 }
+EXPORT_SYMBOL_GPL(usb_stor_probe2);
-/* Handle a disconnect event from the USB core */
+/* Handle a USB mass-storage disconnect */
-static void storage_disconnect(struct usb_interface *intf)
+void usb_stor_disconnect(struct usb_interface *intf)
 {
        struct us_data *us = usb_get_intfdata(intf);
@@ -1118,6 +968,42 @@ static void storage_disconnect(struct usb_interface *intf)
        quiesce_and_remove_host(us);
        release_everything(us);
 }
+EXPORT_SYMBOL_GPL(usb_stor_disconnect);
+/* The main probe routine for standard devices */
+static int storage_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        struct us_data *us;
+        int result;
+        /*
+         * If libusual is configured, let it decide whether a standard
+         * device should be handled by usb-storage or by ub.
+         * If the device isn't standard (is handled by a subdriver
+         * module) then don't accept it.
+         */
+        if (usb_usual_check_type(id, USB_US_TYPE_STOR) ||
+                        usb_usual_ignore_device(intf))
+                return -ENXIO;
+        /*
+         * Call the general probe procedures.
+         *
+         * The unusual_dev_list array is parallel to the usb_storage_usb_ids
+         * table, so we use the index of the id entry to find the
+         * corresponding unusual_devs entry.
+         */
+        result = usb_stor_probe1(&us, intf, id,
+                        (id - usb_storage_usb_ids) + us_unusual_dev_list);
+        if (result)
+                return result;
+        /* No special transport or protocol settings in the main module */
+        result = usb_stor_probe2(us);
+        return result;
+}
 /***********************************************************************
 * Initialization and registration
@@ -1126,15 +1012,13 @@ static void storage_disconnect(struct usb_interface *intf)
 static struct usb_driver usb_storage_driver = {
        .name =         "usb-storage",
        .probe =        storage_probe,
-        .disconnect =   storage_disconnect,
+        .disconnect =   usb_stor_disconnect,
-#ifdef CONFIG_PM
+        .suspend =      usb_stor_suspend,
-        .suspend =      storage_suspend,
+        .resume =       usb_stor_resume,
-        .resume =       storage_resume,
+        .reset_resume = usb_stor_reset_resume,
-        .reset_resume = storage_reset_resume,
+        .pre_reset =    usb_stor_pre_reset,
-#endif
+        .post_reset =   usb_stor_post_reset,
-        .pre_reset =    storage_pre_reset,
+        .id_table =     usb_storage_usb_ids,
-        .post_reset =   storage_post_reset,
-        .id_table =     storage_usb_ids,
        .soft_unbind =  1,
 };
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 65e674e4be99..2609efb2bd7e 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -177,4 +177,25 @@ extern void fill_inquiry_response(struct us_data *us,
 #define scsi_unlock(host)       spin_unlock_irq(host->host_lock)
 #define scsi_lock(host)         spin_lock_irq(host->host_lock)
+/* General routines provided by the usb-storage standard core */
+#ifdef CONFIG_PM
+extern int usb_stor_suspend(struct usb_interface *iface, pm_message_t message);
+extern int usb_stor_resume(struct usb_interface *iface);
+extern int usb_stor_reset_resume(struct usb_interface *iface);
+#else
+#define usb_stor_suspend        NULL
+#define usb_stor_resume         NULL
+#define usb_stor_reset_resume   NULL
+#endif
+extern int usb_stor_pre_reset(struct usb_interface *iface);
+extern int usb_stor_post_reset(struct usb_interface *iface);
+extern int usb_stor_probe1(struct us_data **pus,
+                struct usb_interface *intf,
+                const struct usb_device_id *id,
+                struct us_unusual_dev *unusual_dev);
+extern int usb_stor_probe2(struct us_data *us);
+extern void usb_stor_disconnect(struct usb_interface *intf);
 #endif
diff --git a/drivers/usb/storage/usual-tables.c b/drivers/usb/storage/usual-tables.c
new file mode 100644
index 000000000000..468bde7d1971
--- /dev/null
+++ b/drivers/usb/storage/usual-tables.c
@@ -0,0 +1,116 @@
+/* Driver for USB Mass Storage devices
+ * Usual Tables File for usb-storage and libusual
+ *
+ * Copyright (C) 2009 Alan Stern (stern@rowland.harvard.edu)
+ *
+ * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
+ * information about this driver.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb_usual.h>
+/*
+ * The table of devices
+ */
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+#define COMPLIANT_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags) }
+#define USUAL_DEV(useProto, useTrans, useType) \
+{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
+  .driver_info = ((useType)<<24) }
+struct usb_device_id usb_storage_usb_ids[] = {
+#       include "unusual_devs.h"
+        { }             /* Terminating entry */
+};
+EXPORT_SYMBOL_GPL(usb_storage_usb_ids);
+MODULE_DEVICE_TABLE(usb, usb_storage_usb_ids);
+#undef UNUSUAL_DEV
+#undef COMPLIANT_DEV
+#undef USUAL_DEV
+/*
+ * The table of devices to ignore
+ */
+struct ignore_entry {
+        u16     vid, pid, bcdmin, bcdmax;
+};
+#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{                                       \
+        .vid    = id_vendor,            \
+        .pid    = id_product,           \
+        .bcdmin = bcdDeviceMin,         \
+        .bcdmax = bcdDeviceMax,         \
+}
+static struct ignore_entry ignore_ids[] = {
+#       include "unusual_alauda.h"
+#       include "unusual_cypress.h"
+#       include "unusual_datafab.h"
+#       include "unusual_freecom.h"
+#       include "unusual_isd200.h"
+#       include "unusual_jumpshot.h"
+#       include "unusual_karma.h"
+#       include "unusual_onetouch.h"
+#       include "unusual_sddr09.h"
+#       include "unusual_sddr55.h"
+#       include "unusual_usbat.h"
+        { }             /* Terminating entry */
+};
+#undef UNUSUAL_DEV
+/* Return an error if a device is in the ignore_ids list */
+int usb_usual_ignore_device(struct usb_interface *intf)
+{
+        struct usb_device *udev;
+        unsigned vid, pid, bcd;
+        struct ignore_entry *p;
+        udev = interface_to_usbdev(intf);
+        vid = le16_to_cpu(udev->descriptor.idVendor);
+        pid = le16_to_cpu(udev->descriptor.idProduct);
+        bcd = le16_to_cpu(udev->descriptor.bcdDevice);
+        for (p = ignore_ids; p->vid; ++p) {
+                if (p->vid == vid && p->pid == pid &&
+                                p->bcdmin <= bcd && p->bcdmax >= bcd)
+                        return -ENXIO;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usb_usual_ignore_device);
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index be76084c8d7e..60ba631e99c2 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -410,7 +410,9 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i
        }
        /* let the user know what node this device is now attached to */
-        info("USB Skeleton device now attached to USBSkel-%d", interface->minor);
+        dev_info(&interface->dev,
+                 "USB Skeleton device now attached to USBSkel-%d",
+                 interface->minor);
        return 0;
 error:
@@ -441,7 +443,7 @@ static void skel_disconnect(struct usb_interface *interface)
        /* decrement our usage count */
        kref_put(&dev->kref, skel_delete);
-        info("USB Skeleton #%d now disconnected", minor);
+        dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor);
 }
 static void skel_draw_down(struct usb_skel *dev)
diff --git a/drivers/usb/wusbcore/cbaf.c b/drivers/usb/wusbcore/cbaf.c
index 1335cbe1191d..25eae405f622 100644
--- a/drivers/usb/wusbcore/cbaf.c
+++ b/drivers/usb/wusbcore/cbaf.c
@@ -638,8 +638,7 @@ static void cbaf_disconnect(struct usb_interface *iface)
        usb_put_intf(iface);
        kfree(cbaf->buffer);
        /* paranoia: clean up crypto keys */
-        memset(cbaf, 0, sizeof(*cbaf));
+        kzfree(cbaf);
-        kfree(cbaf);
 }
 static struct usb_device_id cbaf_id_table[] = {
diff --git a/drivers/usb/wusbcore/devconnect.c b/drivers/usb/wusbcore/devconnect.c
index 8e18141bb2e0..f0aac0cf315a 100644
--- a/drivers/usb/wusbcore/devconnect.c
+++ b/drivers/usb/wusbcore/devconnect.c
@@ -889,6 +889,8 @@ static void wusb_dev_add_ncb(struct usb_device *usb_dev)
        if (usb_dev->wusb == 0 || usb_dev->devnum == 1)
                return;         /* skip non wusb and wusb RHs */
+        usb_set_device_state(usb_dev, USB_STATE_UNAUTHENTICATED);
        wusbhc = wusbhc_get_by_usb_dev(usb_dev);
        if (wusbhc == NULL)
                goto error_nodev;
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index f4aa28eca70d..8118db7f1d8d 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -312,6 +312,7 @@ int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
        result = wusb_set_dev_addr(wusbhc, wusb_dev, 0);
        if (result < 0)
                goto error_addr0;
+        usb_set_device_state(usb_dev, USB_STATE_DEFAULT);
        usb_ep0_reinit(usb_dev);
        /* Set new (authenticated) address. */
@@ -327,6 +328,7 @@ int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
        result = wusb_set_dev_addr(wusbhc, wusb_dev, new_address);
        if (result < 0)
                goto error_addr;
+        usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
        usb_ep0_reinit(usb_dev);
        usb_dev->authenticated = 1;
 error_addr:
diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c
index 62bd4441b5e0..378f27745a1d 100644
--- a/drivers/video/au1100fb.c
+++ b/drivers/video/au1100fb.c
@@ -457,7 +457,7 @@ static struct fb_ops au1100fb_ops =
 /* AU1100 LCD controller device driver */
-static int __init au1100fb_drv_probe(struct device *dev)
+static int __init au1100fb_drv_probe(struct platform_device *dev)
 {
        struct au1100fb_device *fbdev = NULL;
        struct resource *regs_res;
@@ -475,7 +475,7 @@ static int __init au1100fb_drv_probe(struct device *dev)
        fbdev->panel = &known_lcd_panels[drv_info.panel_idx];
-        dev_set_drvdata(dev, (void*)fbdev);
+        platform_set_drvdata(dev, (void *)fbdev);
        /* Allocate region for our registers and map them */
        if (!(regs_res = platform_get_resource(to_platform_device(dev),
@@ -583,19 +583,19 @@ failed:
                fb_dealloc_cmap(&fbdev->info.cmap);
        }
        kfree(fbdev);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
        return 0;
 }
-int au1100fb_drv_remove(struct device *dev)
+int au1100fb_drv_remove(struct platform_device *dev)
 {
        struct au1100fb_device *fbdev = NULL;
        if (!dev)
                return -ENODEV;
-        fbdev = (struct au1100fb_device*) dev_get_drvdata(dev);
+        fbdev = (struct au1100fb_device *) platform_get_drvdata(dev);
 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
        au1100fb_fb_blank(VESA_POWERDOWN, &fbdev->info);
@@ -620,9 +620,9 @@ int au1100fb_drv_remove(struct device *dev)
 static u32 sys_clksrc;
 static struct au1100fb_regs fbregs;
-int au1100fb_drv_suspend(struct device *dev, pm_message_t state)
+int au1100fb_drv_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct au1100fb_device *fbdev = dev_get_drvdata(dev);
+        struct au1100fb_device *fbdev = platform_get_drvdata(dev);
        if (!fbdev)
                return 0;
@@ -641,9 +641,9 @@ int au1100fb_drv_suspend(struct device *dev, pm_message_t state)
        return 0;
 }
-int au1100fb_drv_resume(struct device *dev)
+int au1100fb_drv_resume(struct platform_device *dev)
 {
-        struct au1100fb_device *fbdev = dev_get_drvdata(dev);
+        struct au1100fb_device *fbdev = platform_get_drvdata(dev);
        if (!fbdev)
                return 0;
@@ -663,10 +663,11 @@ int au1100fb_drv_resume(struct device *dev)
 #define au1100fb_drv_resume NULL
 #endif
-static struct device_driver au1100fb_driver = {
+static struct platform_driver au1100fb_driver = {
-        .name           = "au1100-lcd",
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = "au1100-lcd",
+                .owner          = THIS_MODULE,
+        },
        .probe          = au1100fb_drv_probe,
        .remove         = au1100fb_drv_remove,
        .suspend        = au1100fb_drv_suspend,
@@ -753,12 +754,12 @@ int __init au1100fb_init(void)
                return ret;
        }
-        return driver_register(&au1100fb_driver);
+        return platform_driver_register(&au1100fb_driver);
 }
 void __exit au1100fb_cleanup(void)
 {
-        driver_unregister(&au1100fb_driver);
+        platform_driver_unregister(&au1100fb_driver);
        kfree(drv_info.opt_mode);
 }
diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c
index 03e57ef88378..0d96f1d2d4c5 100644
--- a/drivers/video/au1200fb.c
+++ b/drivers/video/au1200fb.c
@@ -1622,7 +1622,7 @@ static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
 /* AU1200 LCD controller device driver */
-static int au1200fb_drv_probe(struct device *dev)
+static int au1200fb_drv_probe(struct platform_device *dev)
 {
        struct au1200fb_device *fbdev;
        unsigned long page;
@@ -1645,7 +1645,7 @@ static int au1200fb_drv_probe(struct device *dev)
                /* Allocate the framebuffer to the maximum screen size */
                fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
-                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                fbdev->fb_mem = dma_alloc_noncoherent(&dev->dev,
                                PAGE_ALIGN(fbdev->fb_len),
                                &fbdev->fb_phys, GFP_KERNEL);
                if (!fbdev->fb_mem) {
@@ -1715,7 +1715,7 @@ failed:
        return ret;
 }
-static int au1200fb_drv_remove(struct device *dev)
+static int au1200fb_drv_remove(struct platform_device *dev)
 {
        struct au1200fb_device *fbdev;
        int plane;
@@ -1733,7 +1733,8 @@ static int au1200fb_drv_remove(struct device *dev)
                /* Clean up all probe data */
                unregister_framebuffer(&fbdev->fb_info);
                if (fbdev->fb_mem)
-                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                        dma_free_noncoherent(&dev->dev,
+                                        PAGE_ALIGN(fbdev->fb_len),
                                        fbdev->fb_mem, fbdev->fb_phys);
                if (fbdev->fb_info.cmap.len != 0)
                        fb_dealloc_cmap(&fbdev->fb_info.cmap);
@@ -1747,22 +1748,24 @@ static int au1200fb_drv_remove(struct device *dev)
 }
 #ifdef CONFIG_PM
-static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+static int au1200fb_drv_suspend(struct platform_device *dev, u32 state)
 {
        /* TODO */
        return 0;
 }
-static int au1200fb_drv_resume(struct device *dev, u32 level)
+static int au1200fb_drv_resume(struct platform_device *dev)
 {
        /* TODO */
        return 0;
 }
 #endif /* CONFIG_PM */
-static struct device_driver au1200fb_driver = {
+static struct platform_driver au1200fb_driver = {
-        .name           = "au1200-lcd",
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = "au1200-lcd",
+                .owner          = THIS_MODULE,
+        },
        .probe          = au1200fb_drv_probe,
        .remove         = au1200fb_drv_remove,
 #ifdef CONFIG_PM
@@ -1906,12 +1909,12 @@ static int __init au1200fb_init(void)
                printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
        #endif
-        return driver_register(&au1200fb_driver);
+        return platform_driver_register(&au1200fb_driver);
 }
 static void __exit au1200fb_cleanup(void)
 {
-        driver_unregister(&au1200fb_driver);
+        platform_driver_unregister(&au1200fb_driver);
 }
 module_init(au1200fb_init);
diff --git a/drivers/video/pmag-ba-fb.c b/drivers/video/pmag-ba-fb.c
index 3a3f80f65219..0573ec685a57 100644
--- a/drivers/video/pmag-ba-fb.c
+++ b/drivers/video/pmag-ba-fb.c
@@ -151,7 +151,7 @@ static int __init pmagbafb_probe(struct device *dev)
        info = framebuffer_alloc(sizeof(struct pmagbafb_par), dev);
        if (!info) {
-                printk(KERN_ERR "%s: Cannot allocate memory\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot allocate memory\n", dev_name(dev));
                return -ENOMEM;
        }
@@ -160,7 +160,7 @@ static int __init pmagbafb_probe(struct device *dev)
        if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
                printk(KERN_ERR "%s: Cannot allocate color map\n",
-                       dev->bus_id);
+                       dev_name(dev));
                err = -ENOMEM;
                goto err_alloc;
        }
@@ -173,8 +173,9 @@ static int __init pmagbafb_probe(struct device *dev)
        /* Request the I/O MEM resource.  */
        start = tdev->resource.start;
        len = tdev->resource.end - start + 1;
-        if (!request_mem_region(start, len, dev->bus_id)) {
+        if (!request_mem_region(start, len, dev_name(dev))) {
-                printk(KERN_ERR "%s: Cannot reserve FB region\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot reserve FB region\n",
+                       dev_name(dev));
                err = -EBUSY;
                goto err_cmap;
        }
@@ -183,7 +184,7 @@ static int __init pmagbafb_probe(struct device *dev)
        info->fix.mmio_start = start;
        par->mmio = ioremap_nocache(info->fix.mmio_start, info->fix.mmio_len);
        if (!par->mmio) {
-                printk(KERN_ERR "%s: Cannot map MMIO\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map MMIO\n", dev_name(dev));
                err = -ENOMEM;
                goto err_resource;
        }
@@ -194,7 +195,7 @@ static int __init pmagbafb_probe(struct device *dev)
        info->screen_base = ioremap_nocache(info->fix.smem_start,
                                            info->fix.smem_len);
        if (!info->screen_base) {
-                printk(KERN_ERR "%s: Cannot map FB\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map FB\n", dev_name(dev));
                err = -ENOMEM;
                goto err_mmio_map;
        }
@@ -205,14 +206,14 @@ static int __init pmagbafb_probe(struct device *dev)
        err = register_framebuffer(info);
        if (err < 0) {
                printk(KERN_ERR "%s: Cannot register framebuffer\n",
-                       dev->bus_id);
+                       dev_name(dev));
                goto err_smem_map;
        }
        get_device(dev);
        pr_info("fb%d: %s frame buffer device at %s\n",
-                info->node, info->fix.id, dev->bus_id);
+                info->node, info->fix.id, dev_name(dev));
        return 0;
diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c
index 9b80597241b0..98748723af9f 100644
--- a/drivers/video/pmagb-b-fb.c
+++ b/drivers/video/pmagb-b-fb.c
@@ -258,7 +258,7 @@ static int __init pmagbbfb_probe(struct device *dev)
        info = framebuffer_alloc(sizeof(struct pmagbbfb_par), dev);
        if (!info) {
-                printk(KERN_ERR "%s: Cannot allocate memory\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot allocate memory\n", dev_name(dev));
                return -ENOMEM;
        }
@@ -267,7 +267,7 @@ static int __init pmagbbfb_probe(struct device *dev)
        if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
                printk(KERN_ERR "%s: Cannot allocate color map\n",
-                       dev->bus_id);
+                       dev_name(dev));
                err = -ENOMEM;
                goto err_alloc;
        }
@@ -280,8 +280,9 @@ static int __init pmagbbfb_probe(struct device *dev)
        /* Request the I/O MEM resource.  */
        start = tdev->resource.start;
        len = tdev->resource.end - start + 1;
-        if (!request_mem_region(start, len, dev->bus_id)) {
+        if (!request_mem_region(start, len, dev_name(dev))) {
-                printk(KERN_ERR "%s: Cannot reserve FB region\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot reserve FB region\n",
+                       dev_name(dev));
                err = -EBUSY;
                goto err_cmap;
        }
@@ -290,7 +291,7 @@ static int __init pmagbbfb_probe(struct device *dev)
        info->fix.mmio_start = start;
        par->mmio = ioremap_nocache(info->fix.mmio_start, info->fix.mmio_len);
        if (!par->mmio) {
-                printk(KERN_ERR "%s: Cannot map MMIO\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map MMIO\n", dev_name(dev));
                err = -ENOMEM;
                goto err_resource;
        }
@@ -301,7 +302,7 @@ static int __init pmagbbfb_probe(struct device *dev)
        info->fix.smem_start = start + PMAGB_B_FBMEM;
        par->smem = ioremap_nocache(info->fix.smem_start, info->fix.smem_len);
        if (!par->smem) {
-                printk(KERN_ERR "%s: Cannot map FB\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map FB\n", dev_name(dev));
                err = -ENOMEM;
                goto err_mmio_map;
        }
@@ -316,7 +317,7 @@ static int __init pmagbbfb_probe(struct device *dev)
        err = register_framebuffer(info);
        if (err < 0) {
                printk(KERN_ERR "%s: Cannot register framebuffer\n",
-                       dev->bus_id);
+                       dev_name(dev));
                goto err_smem_map;
        }
@@ -328,7 +329,7 @@ static int __init pmagbbfb_probe(struct device *dev)
                 par->osc1 / 1000, par->osc1 % 1000);
        pr_info("fb%d: %s frame buffer device at %s\n",
-                info->node, info->fix.id, dev->bus_id);
+                info->node, info->fix.id, dev_name(dev));
        pr_info("fb%d: Osc0: %s, Osc1: %s, Osc%u selected\n",
                info->node, freq0, par->osc1 ? freq1 : "disabled",
                par->osc1 != 0);
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 87f826e4c958..e00c1dff55de 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1213,7 +1213,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
        dev->core.driver_data = info;
        dev_info(info->device, "%s %s, using %u KiB of video memory\n",
-                 dev_driver_string(info->dev), info->dev->bus_id,
+                 dev_driver_string(info->dev), dev_name(info->dev),
                 info->fix.smem_len >> 10);
        task = kthread_run(ps3fbd, info, DEVICE_NAME);
diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c
index 0a0fd48a8566..53f8f1100e81 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -61,7 +61,7 @@
 #include <mach-dreamcast/mach/sysasic.h>
 #endif
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
 #include <linux/pagemap.h>
 #include <mach/dma.h>
 #include <asm/dma.h>
@@ -188,7 +188,7 @@ static unsigned int is_blanked = 0;		/* Is the screen blanked? */
 static unsigned long pvr2fb_map;
 #endif
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
 static unsigned int shdma = PVR2_CASCADE_CHAN;
 static unsigned int pvr2dma = ONCHIP_NR_DMA_CHANNELS;
 #endif
@@ -207,7 +207,7 @@ static irqreturn_t pvr2fb_interrupt(int irq, void *dev_id);
 static int pvr2_init_cable(void);
 static int pvr2_get_param(const struct pvr2_params *p, const char *s,
                            int val, int size);
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
 static ssize_t pvr2fb_write(struct fb_info *info, const char *buf,
                            size_t count, loff_t *ppos);
 #endif
@@ -218,7 +218,7 @@ static struct fb_ops pvr2fb_ops = {
        .fb_blank       = pvr2fb_blank,
        .fb_check_var   = pvr2fb_check_var,
        .fb_set_par     = pvr2fb_set_par,
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
        .fb_write       = pvr2fb_write,
 #endif
        .fb_fillrect    = cfb_fillrect,
@@ -671,7 +671,7 @@ static int pvr2_init_cable(void)
        return cable_type;
 }
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
 static ssize_t pvr2fb_write(struct fb_info *info, const char *buf,
                            size_t count, loff_t *ppos)
 {
@@ -743,7 +743,7 @@ out_unmap:
        return ret;
 }
-#endif /* CONFIG_SH_DMA */
+#endif /* CONFIG_PVR2_DMA */
 /**
 * pvr2fb_common_init
@@ -893,7 +893,7 @@ static int __init pvr2fb_dc_init(void)
                return -EBUSY;
        }
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
        if (request_dma(pvr2dma, "pvr2") != 0) {
                free_irq(HW_EVENT_VSYNC, 0);
                return -EBUSY;
@@ -915,7 +915,7 @@ static void __exit pvr2fb_dc_exit(void)
        }
        free_irq(HW_EVENT_VSYNC, 0);
-#ifdef CONFIG_SH_DMA
+#ifdef CONFIG_PVR2_DMA
        free_dma(pvr2dma);
 #endif
 }
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index 2c5d069e5f06..92ea0ab44ce2 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -33,6 +33,8 @@ struct sh_mobile_lcdc_chan {
        struct fb_info info;
        dma_addr_t dma_handle;
        struct fb_deferred_io defio;
+        unsigned long frame_end;
+        wait_queue_head_t frame_end_wait;
 };
 struct sh_mobile_lcdc_priv {
@@ -226,7 +228,10 @@ static void sh_mobile_lcdc_deferred_io_touch(struct fb_info *info)
 static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
 {
        struct sh_mobile_lcdc_priv *priv = data;
+        struct sh_mobile_lcdc_chan *ch;
        unsigned long tmp;
+        int is_sub;
+        int k;
        /* acknowledge interrupt */
        tmp = lcdc_read(priv, _LDINTR);
@@ -234,8 +239,24 @@ static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
        tmp |= 0x000000ff ^ LDINTR_FS; /* status in low 8 */
        lcdc_write(priv, _LDINTR, tmp);
-        /* disable clocks */
+        /* figure out if this interrupt is for main or sub lcd */
-        sh_mobile_lcdc_clk_off(priv);
+        is_sub = (lcdc_read(priv, _LDSR) & (1 << 10)) ? 1 : 0;
+        /* wake up channel and disable clocks*/
+        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
+                ch = &priv->ch[k];
+                if (!ch->enabled)
+                        continue;
+                if (is_sub == lcdc_chan_is_sublcd(ch)) {
+                        ch->frame_end = 1;
+                        wake_up(&ch->frame_end_wait);
+                        sh_mobile_lcdc_clk_off(priv);
+                }
+        }
        return IRQ_HANDLED;
 }
@@ -448,18 +469,27 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
        struct sh_mobile_lcdc_board_cfg *board_cfg;
        int k;
-        /* tell the board code to disable the panel */
+        /* clean up deferred io and ask board code to disable panel */
        for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
                ch = &priv->ch[k];
-                board_cfg = &ch->cfg.board_cfg;
-                if (board_cfg->display_off)
-                        board_cfg->display_off(board_cfg->board_data);
-                /* cleanup deferred io if enabled */
+                /* deferred io mode:
+                 * flush frame, and wait for frame end interrupt
+                 * clean up deferred io and enable clock
+                 */
                if (ch->info.fbdefio) {
+                        ch->frame_end = 0;
+                        schedule_delayed_work(&ch->info.deferred_work, 0);
+                        wait_event(ch->frame_end_wait, ch->frame_end);
                        fb_deferred_io_cleanup(&ch->info);
                        ch->info.fbdefio = NULL;
+                        sh_mobile_lcdc_clk_on(priv);
                }
+                board_cfg = &ch->cfg.board_cfg;
+                if (board_cfg->display_off)
+                        board_cfg->display_off(board_cfg->board_data);
        }
        /* stop the lcdc */
@@ -652,6 +682,26 @@ static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo *var, int bpp)
        return 0;
 }
+static int sh_mobile_lcdc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        sh_mobile_lcdc_stop(platform_get_drvdata(pdev));
+        return 0;
+}
+static int sh_mobile_lcdc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        return sh_mobile_lcdc_start(platform_get_drvdata(pdev));
+}
+static struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops = {
+        .suspend = sh_mobile_lcdc_suspend,
+        .resume = sh_mobile_lcdc_resume,
+};
 static int sh_mobile_lcdc_remove(struct platform_device *pdev);
 static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
@@ -687,7 +737,7 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
        }
        error = request_irq(i, sh_mobile_lcdc_irq, IRQF_DISABLED,
-                            pdev->dev.bus_id, priv);
+                            dev_name(&pdev->dev), priv);
        if (error) {
                dev_err(&pdev->dev, "unable to request irq\n");
                goto err1;
@@ -707,6 +757,7 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
                        dev_err(&pdev->dev, "unsupported interface type\n");
                        goto err1;
                }
+                init_waitqueue_head(&priv->ch[i].frame_end_wait);
                switch (pdata->ch[i].chan) {
                case LCDC_CHAN_MAINLCD:
@@ -860,6 +911,7 @@ static struct platform_driver sh_mobile_lcdc_driver = {
        .driver         = {
                .name           = "sh_mobile_lcdc_fb",
                .owner          = THIS_MODULE,
+                .pm             = &sh_mobile_lcdc_dev_pm_ops,
        },
        .probe          = sh_mobile_lcdc_probe,
        .remove         = sh_mobile_lcdc_remove,
diff --git a/drivers/video/tmiofb.c b/drivers/video/tmiofb.c
index 7baf2dd12d50..a1eb0862255b 100644
--- a/drivers/video/tmiofb.c
+++ b/drivers/video/tmiofb.c
@@ -751,7 +751,7 @@ static int __devinit tmiofb_probe(struct platform_device *dev)
        }
        retval = request_irq(irq, &tmiofb_irq, IRQF_DISABLED,
-                                        dev->dev.bus_id, info);
+                                        dev_name(&dev->dev), info);
        if (retval)
                goto err_request_irq;
diff --git a/drivers/watchdog/rm9k_wdt.c b/drivers/watchdog/rm9k_wdt.c
index f1ae3729a19e..cce1982a1b58 100644
--- a/drivers/watchdog/rm9k_wdt.c
+++ b/drivers/watchdog/rm9k_wdt.c
@@ -59,8 +59,8 @@ static long wdt_gpi_ioctl(struct file *, unsigned int, unsigned long);
 static int wdt_gpi_notify(struct notifier_block *, unsigned long, void *);
 static const struct resource *wdt_gpi_get_resource(struct platform_device *,
                                                const char *, unsigned int);
-static int __init wdt_gpi_probe(struct device *);
+static int __init wdt_gpi_probe(struct platform_device *);
-static int __exit wdt_gpi_remove(struct device *);
+static int __exit wdt_gpi_remove(struct platform_device *);
 static const char wdt_gpi_name[] = "wdt_gpi";
@@ -346,10 +346,9 @@ static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
 }
 /* No hotplugging on the platform bus - use __init */
-static int __init wdt_gpi_probe(struct device *dev)
+static int __init wdt_gpi_probe(struct platform_device *pdv)
 {
        int res;
-        struct platform_device * const pdv = to_platform_device(dev);
        const struct resource
                * const rr = wdt_gpi_get_resource(pdv, WDT_RESOURCE_REGS,
                                                  IORESOURCE_MEM),
@@ -374,7 +373,7 @@ static int __init wdt_gpi_probe(struct device *dev)
        return res;
 }
-static int __exit wdt_gpi_remove(struct device *dev)
+static int __exit wdt_gpi_remove(struct platform_device *dev)
 {
        int res;
@@ -387,15 +386,13 @@ static int __exit wdt_gpi_remove(struct device *dev)
 /* Device driver init & exit */
-static struct device_driver wdt_gpi_driver = {
+static struct platform_driver wgt_gpi_driver = {
-        .name           = (char *) wdt_gpi_name,
+        .driver = {
-        .bus            = &platform_bus_type,
+                .name           = wdt_gpi_name,
-        .owner          = THIS_MODULE,
+                .owner          = THIS_MODULE,
+        },
        .probe          = wdt_gpi_probe,
-        .remove         = __exit_p(wdt_gpi_remove),
+        .remove         = __devexit_p(wdt_gpi_remove),
-        .shutdown       = NULL,
-        .suspend        = NULL,
-        .resume         = NULL,
 };
 static int __init wdt_gpi_init_module(void)
@@ -403,12 +400,12 @@ static int __init wdt_gpi_init_module(void)
        atomic_set(&opencnt, 1);
        if (timeout > MAX_TIMEOUT_SECONDS)
                timeout = MAX_TIMEOUT_SECONDS;
-        return driver_register(&wdt_gpi_driver);
+        return platform_driver_register(&wdt_gpi_driver);
 }
 static void __exit wdt_gpi_cleanup_module(void)
 {
-        driver_unregister(&wdt_gpi_driver);
+        platform_driver_unregister(&wdt_gpi_driver);
 }
 module_init(wdt_gpi_init_module);
diff --git a/drivers/zorro/zorro.c b/drivers/zorro/zorro.c
index a1585d6f6486..d45fb34e2d23 100644
--- a/drivers/zorro/zorro.c
+++ b/drivers/zorro/zorro.c
@@ -140,7 +140,7 @@ static int __init zorro_init(void)
    /* Initialize the Zorro bus */
    INIT_LIST_HEAD(&zorro_bus.devices);
-    strcpy(zorro_bus.dev.bus_id, "zorro");
+    dev_set_name(&zorro_bus.dev, "zorro");
    error = device_register(&zorro_bus.dev);
    if (error) {
        pr_err("Zorro: Error registering zorro_bus\n");
@@ -167,7 +167,7 @@ static int __init zorro_init(void)
        if (request_resource(zorro_find_parent_resource(z), &z->resource))
            pr_err("Zorro: Address space collision on device %s %pR\n",
                   z->name, &z->resource);
-        sprintf(z->dev.bus_id, "%02x", i);
+        dev_set_name(&z->dev, "%02x", i);
        z->dev.parent = &zorro_bus.dev;
        z->dev.bus = &zorro_bus_type;
        error = device_register(&z->dev);