461 files changed, 29112 insertions, 13681 deletions

diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index feab124d8e..cbfc81579c 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -194,7 +194,7 @@ int acpi_bus_set_power(acpi_handle handle, int state)
 
         if (!device->flags.power_manageable) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
-                                device->dev.kobj.name));
+                                kobject_name(&device->dev.kobj)));
                 return -ENODEV;
         }
         /*
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 1e8287b4f4..1f6fb38de0 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -276,21 +276,12 @@ static void acpi_timer_check_state(int state, struct acpi_processor *pr,
 
 static void acpi_propagate_timer_broadcast(struct acpi_processor *pr)
 {
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
         unsigned long reason;
 
         reason = pr->power.timer_broadcast_on_state < INT_MAX ?
                 CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
 
         clockevents_notify(reason, &pr->id);
-#else
-        cpumask_t mask = cpumask_of_cpu(pr->id);
-
-        if (pr->power.timer_broadcast_on_state < INT_MAX)
-                on_each_cpu(switch_APIC_timer_to_ipi, &mask, 1, 1);
-        else
-                on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1);
-#endif
 }
 
 /* Power(C) State timer broadcast control */
@@ -298,8 +289,6 @@ static void acpi_state_timer_broadcast(struct acpi_processor *pr,
                                        struct acpi_processor_cx *cx,
                                        int broadcast)
 {
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
-
         int state = cx - pr->power.states;
 
         if (state >= pr->power.timer_broadcast_on_state) {
@@ -309,7 +298,6 @@ static void acpi_state_timer_broadcast(struct acpi_processor *pr,
                         CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
                 clockevents_notify(reason, &pr->id);
         }
-#endif
 }
 
 #else
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 64620d6687..5b4d462117 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -319,16 +319,18 @@ static int acpi_bus_match(struct device *dev, struct device_driver *drv)
         return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 }
 
-static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
-                              char *buffer, int buffer_size)
+static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
+        int len;
 
-        strcpy(buffer, "MODALIAS=");
-        if (create_modalias(acpi_dev, buffer + 9, buffer_size - 9) > 0) {
-                envp[0] = buffer;
-                envp[1] = NULL;
-        }
+        if (add_uevent_var(env, "MODALIAS="))
+                return -ENOMEM;
+        len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
+                              sizeof(env->buf) - env->buflen);
+        if (len >= (sizeof(env->buf) - env->buflen))
+                return -ENOMEM;
+        env->buflen += len;
         return 0;
 }
 
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index d05891f162..b8a2095cb5 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -316,7 +316,7 @@ static int acpi_video_output_get(struct output_device *od)
 {
         unsigned long state;
         struct acpi_video_device *vd =
-                (struct acpi_video_device *)class_get_devdata(&od->class_dev);
+                (struct acpi_video_device *)dev_get_drvdata(&od->dev);
         acpi_video_device_get_state(vd, &state);
         return (int)state;
 }
@@ -325,7 +325,7 @@ static int acpi_video_output_set(struct output_device *od)
 {
         unsigned long state = od->request_state;
         struct acpi_video_device *vd=
-                (struct acpi_video_device *)class_get_devdata(&od->class_dev);
+                (struct acpi_video_device *)dev_get_drvdata(&od->dev);
         return acpi_video_device_set_state(vd, state);
 }
 
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 268e301775..6b94fb7be5 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -44,15 +44,12 @@ static int amba_match(struct device *dev, struct device_driver *drv)
 }
 
 #ifdef CONFIG_HOTPLUG
-static int amba_uevent(struct device *dev, char **envp, int nr_env, char *buf, int bufsz)
+static int amba_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct amba_device *pcdev = to_amba_device(dev);
-        int retval = 0, i = 0, len = 0;
+        int retval = 0;
 
-        retval = add_uevent_var(envp, nr_env, &i,
-                                buf, bufsz, &len,
-                                "AMBA_ID=%08x", pcdev->periphid);
-        envp[i] = NULL;
+        retval = add_uevent_var(env, "AMBA_ID=%08x", pcdev->periphid);
         return retval;
 }
 #else
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index d8046a113c..4672066167 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -173,6 +173,15 @@ config SATA_INIC162X
         help
           This option enables support for Initio 162x Serial ATA.
 
+config PATA_ACPI
+        tristate "ACPI firmware driver for PATA"
+        depends on ATA_ACPI
+        help
+          This option enables an ACPI method driver which drives
+          motherboard PATA controller interfaces through the ACPI
+          firmware in the BIOS. This driver can sometimes handle
+          otherwise unsupported hardware.
+
 config PATA_ALI
         tristate "ALi PATA support (Experimental)"
         depends on PCI && EXPERIMENTAL
@@ -192,16 +201,25 @@ config PATA_AMD
           If unsure, say N.
 
 config PATA_ARTOP
-        tristate "ARTOP 6210/6260 PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "ARTOP 6210/6260 PATA support"
+        depends on PCI
         help
           This option enables support for ARTOP PATA controllers.
 
           If unsure, say N.
 
+config PATA_AT32
+        tristate "Atmel AVR32 PATA support (Experimental)"
+        depends on AVR32 && PLATFORM_AT32AP && EXPERIMENTAL
+        help
+          This option enables support for the IDE devices on the
+          Atmel AT32AP platform.
+
+          If unsure, say N.
+
 config PATA_ATIIXP
-        tristate "ATI PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "ATI PATA support"
+        depends on PCI
         help
           This option enables support for the ATI ATA interfaces
           found on the many ATI chipsets.
@@ -219,8 +237,8 @@ config PATA_CMD640_PCI
           If unsure, say N.
 
 config PATA_CMD64X
-        tristate "CMD64x PATA support (Very Experimental)"
-        depends on PCI&& EXPERIMENTAL
+        tristate "CMD64x PATA support"
+        depends on PCI
         help
           This option enables support for the CMD64x series chips
           except for the CMD640.
@@ -282,8 +300,8 @@ config ATA_GENERIC
           If unsure, say N.
 
 config PATA_HPT366
-        tristate "HPT 366/368 PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "HPT 366/368 PATA support"
+        depends on PCI
         help
           This option enables support for the HPT 366 and 368
           PATA controllers via the new ATA layer.
@@ -432,6 +450,15 @@ config PATA_NS87410
 
           If unsure, say N.
 
+config PATA_NS87415
+        tristate "Nat Semi NS87415 PATA support (Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables support for the National Semiconductor
+          NS87415 PCI-IDE controller.
+
+          If unsure, say N.
+
 config PATA_OPTI
         tristate "OPTI621/6215 PATA support (Very Experimental)"
         depends on PCI && EXPERIMENTAL
@@ -596,4 +623,20 @@ config PATA_SCC
 
           If unsure, say N.
 
+config PATA_BF54X
+        tristate "Blackfin 54x ATAPI support"
+        depends on BF542 || BF548 || BF549
+        help
+          This option enables support for the built-in ATAPI controller on
+          Blackfin 54x family chips.
+
+          If unsure, say N.
+
+config PATA_BF54X_DMA
+        bool "DMA mode"
+        depends on PATA_BF54X
+        default y
+        help
+          Enable DMA mode for Blackfin ATAPI controller.
+
 endif # ATA
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 8149c68ac2..2a63645003 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_PDC_ADMA)		+= pdc_adma.o
 obj-$(CONFIG_PATA_ALI)          += pata_ali.o
 obj-$(CONFIG_PATA_AMD)          += pata_amd.o
 obj-$(CONFIG_PATA_ARTOP)        += pata_artop.o
+obj-$(CONFIG_PATA_AT32)         += pata_at32.o
 obj-$(CONFIG_PATA_ATIIXP)       += pata_atiixp.o
 obj-$(CONFIG_PATA_CMD640_PCI)   += pata_cmd640.o
 obj-$(CONFIG_PATA_CMD64X)       += pata_cmd64x.o
@@ -39,6 +40,7 @@ obj-$(CONFIG_PATA_IT8213)	+= pata_it8213.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
 obj-$(CONFIG_PATA_NETCELL)      += pata_netcell.o
 obj-$(CONFIG_PATA_NS87410)      += pata_ns87410.o
+obj-$(CONFIG_PATA_NS87415)      += pata_ns87415.o
 obj-$(CONFIG_PATA_OPTI)         += pata_opti.o
 obj-$(CONFIG_PATA_OPTIDMA)      += pata_optidma.o
 obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
@@ -61,12 +63,16 @@ obj-$(CONFIG_PATA_SIS)		+= pata_sis.o
 obj-$(CONFIG_PATA_TRIFLEX)      += pata_triflex.o
 obj-$(CONFIG_PATA_IXP4XX_CF)    += pata_ixp4xx_cf.o
 obj-$(CONFIG_PATA_SCC)          += pata_scc.o
+obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
+# Should be last but two libata driver
+obj-$(CONFIG_PATA_ACPI)         += pata_acpi.o
 # Should be last but one libata driver
 obj-$(CONFIG_ATA_GENERIC)       += ata_generic.o
 # Should be last libata driver
 obj-$(CONFIG_PATA_LEGACY)       += pata_legacy.o
 
-libata-objs     := libata-core.o libata-scsi.o libata-sff.o libata-eh.o
+libata-objs     := libata-core.o libata-scsi.o libata-sff.o libata-eh.o \
+                   libata-pmp.o
 libata-$(CONFIG_ATA_ACPI)       += libata-acpi.o
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index c16820325d..10bc3f64c4 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -46,7 +46,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "ahci"
-#define DRV_VERSION     "2.3"
+#define DRV_VERSION     "3.0"
 
 
 enum {
@@ -77,11 +77,10 @@ enum {
         RX_FIS_UNK              = 0x60, /* offset of Unknown FIS data */
 
         board_ahci              = 0,
-        board_ahci_pi           = 1,
-        board_ahci_vt8251       = 2,
-        board_ahci_ign_iferr    = 3,
-        board_ahci_sb600        = 4,
-        board_ahci_mv           = 5,
+        board_ahci_vt8251       = 1,
+        board_ahci_ign_iferr    = 2,
+        board_ahci_sb600        = 3,
+        board_ahci_mv           = 4,
 
         /* global controller registers */
         HOST_CAP                = 0x00, /* host capabilities */
@@ -97,6 +96,7 @@ enum {
 
         /* HOST_CAP bits */
         HOST_CAP_SSC            = (1 << 14), /* Slumber capable */
+        HOST_CAP_PMP            = (1 << 17), /* Port Multiplier support */
         HOST_CAP_CLO            = (1 << 24), /* Command List Override support */
         HOST_CAP_SSS            = (1 << 27), /* Staggered Spin-up */
         HOST_CAP_SNTF           = (1 << 29), /* SNotification register */
@@ -144,7 +144,8 @@ enum {
                                   PORT_IRQ_IF_ERR |
                                   PORT_IRQ_CONNECT |
                                   PORT_IRQ_PHYRDY |
-                                  PORT_IRQ_UNK_FIS,
+                                  PORT_IRQ_UNK_FIS |
+                                  PORT_IRQ_BAD_PMP,
         PORT_IRQ_ERROR          = PORT_IRQ_FREEZE |
                                   PORT_IRQ_TF_ERR |
                                   PORT_IRQ_HBUS_DATA_ERR,
@@ -154,6 +155,7 @@ enum {
 
         /* PORT_CMD bits */
         PORT_CMD_ATAPI          = (1 << 24), /* Device is ATAPI */
+        PORT_CMD_PMP            = (1 << 17), /* PMP attached */
         PORT_CMD_LIST_ON        = (1 << 15), /* cmd list DMA engine running */
         PORT_CMD_FIS_ON         = (1 << 14), /* FIS DMA engine running */
         PORT_CMD_FIS_RX         = (1 << 4), /* Enable FIS receive DMA engine */
@@ -167,19 +169,22 @@ enum {
         PORT_CMD_ICC_PARTIAL    = (0x2 << 28), /* Put i/f in partial state */
         PORT_CMD_ICC_SLUMBER    = (0x6 << 28), /* Put i/f in slumber state */
 
+        /* hpriv->flags bits */
+        AHCI_HFLAG_NO_NCQ               = (1 << 0),
+        AHCI_HFLAG_IGN_IRQ_IF_ERR       = (1 << 1), /* ignore IRQ_IF_ERR */
+        AHCI_HFLAG_IGN_SERR_INTERNAL    = (1 << 2), /* ignore SERR_INTERNAL */
+        AHCI_HFLAG_32BIT_ONLY           = (1 << 3), /* force 32bit */
+        AHCI_HFLAG_MV_PATA              = (1 << 4), /* PATA port */
+        AHCI_HFLAG_NO_MSI               = (1 << 5), /* no PCI MSI */
+        AHCI_HFLAG_NO_PMP               = (1 << 6), /* no PMP */
+
         /* ap->flags bits */
-        AHCI_FLAG_NO_NCQ                = (1 << 24),
-        AHCI_FLAG_IGN_IRQ_IF_ERR        = (1 << 25), /* ignore IRQ_IF_ERR */
-        AHCI_FLAG_HONOR_PI              = (1 << 26), /* honor PORTS_IMPL */
-        AHCI_FLAG_IGN_SERR_INTERNAL     = (1 << 27), /* ignore SERR_INTERNAL */
-        AHCI_FLAG_32BIT_ONLY            = (1 << 28), /* force 32bit */
-        AHCI_FLAG_MV_PATA               = (1 << 29), /* PATA port */
-        AHCI_FLAG_NO_MSI                = (1 << 30), /* no PCI MSI */
+        AHCI_FLAG_NO_HOTPLUG            = (1 << 24), /* ignore PxSERR.DIAG.N */
 
         AHCI_FLAG_COMMON                = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                           ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                          ATA_FLAG_SKIP_D2H_BSY |
-                                          ATA_FLAG_ACPI_SATA,
+                                          ATA_FLAG_ACPI_SATA | ATA_FLAG_AN,
+        AHCI_LFLAG_COMMON               = ATA_LFLAG_SKIP_D2H_BSY,
 };
 
 struct ahci_cmd_hdr {
@@ -198,6 +203,7 @@ struct ahci_sg {
 };
 
 struct ahci_host_priv {
+        unsigned int            flags;          /* AHCI_HFLAG_* */
         u32                     cap;            /* cap to use */
         u32                     port_map;       /* port map to use */
         u32                     saved_cap;      /* saved initial cap */
@@ -205,6 +211,7 @@ struct ahci_host_priv {
 };
 
 struct ahci_port_priv {
+        struct ata_link         *active_link;
         struct ahci_cmd_hdr     *cmd_slot;
         dma_addr_t              cmd_slot_dma;
         void                    *cmd_tbl;
@@ -215,6 +222,7 @@ struct ahci_port_priv {
         unsigned int            ncq_saw_d2h:1;
         unsigned int            ncq_saw_dmas:1;
         unsigned int            ncq_saw_sdb:1;
+        u32                     intr_mask;      /* interrupts to enable */
 };
 
 static int ahci_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
@@ -229,6 +237,8 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc);
 static u8 ahci_check_status(struct ata_port *ap);
 static void ahci_freeze(struct ata_port *ap);
 static void ahci_thaw(struct ata_port *ap);
+static void ahci_pmp_attach(struct ata_port *ap);
+static void ahci_pmp_detach(struct ata_port *ap);
 static void ahci_error_handler(struct ata_port *ap);
 static void ahci_vt8251_error_handler(struct ata_port *ap);
 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
@@ -262,20 +272,17 @@ static struct scsi_host_template ahci_sht = {
 };
 
 static const struct ata_port_operations ahci_ops = {
-        .port_disable           = ata_port_disable,
-
         .check_status           = ahci_check_status,
         .check_altstatus        = ahci_check_status,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = ahci_tf_read,
 
+        .qc_defer               = sata_pmp_qc_defer_cmd_switch,
         .qc_prep                = ahci_qc_prep,
         .qc_issue               = ahci_qc_issue,
 
         .irq_clear              = ahci_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = ahci_scr_read,
         .scr_write              = ahci_scr_write,
@@ -286,6 +293,9 @@ static const struct ata_port_operations ahci_ops = {
         .error_handler          = ahci_error_handler,
         .post_internal_cmd      = ahci_post_internal_cmd,
 
+        .pmp_attach             = ahci_pmp_attach,
+        .pmp_detach             = ahci_pmp_detach,
+
 #ifdef CONFIG_PM
         .port_suspend           = ahci_port_suspend,
         .port_resume            = ahci_port_resume,
@@ -296,20 +306,17 @@ static const struct ata_port_operations ahci_ops = {
 };
 
 static const struct ata_port_operations ahci_vt8251_ops = {
-        .port_disable           = ata_port_disable,
-
         .check_status           = ahci_check_status,
         .check_altstatus        = ahci_check_status,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = ahci_tf_read,
 
+        .qc_defer               = sata_pmp_qc_defer_cmd_switch,
         .qc_prep                = ahci_qc_prep,
         .qc_issue               = ahci_qc_issue,
 
         .irq_clear              = ahci_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = ahci_scr_read,
         .scr_write              = ahci_scr_write,
@@ -320,6 +327,9 @@ static const struct ata_port_operations ahci_vt8251_ops = {
         .error_handler          = ahci_vt8251_error_handler,
         .post_internal_cmd      = ahci_post_internal_cmd,
 
+        .pmp_attach             = ahci_pmp_attach,
+        .pmp_detach             = ahci_pmp_detach,
+
 #ifdef CONFIG_PM
         .port_suspend           = ahci_port_suspend,
         .port_resume            = ahci_port_resume,
@@ -329,53 +339,52 @@ static const struct ata_port_operations ahci_vt8251_ops = {
         .port_stop              = ahci_port_stop,
 };
 
+#define AHCI_HFLAGS(flags)      .private_data   = (void *)(flags)
+
 static const struct ata_port_info ahci_port_info[] = {
         /* board_ahci */
         {
                 .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
-                .udma_mask      = ATA_UDMA6,
-                .port_ops       = &ahci_ops,
-        },
-        /* board_ahci_pi */
-        {
-                .flags          = AHCI_FLAG_COMMON | AHCI_FLAG_HONOR_PI,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_vt8251 */
         {
-                .flags          = AHCI_FLAG_COMMON | ATA_FLAG_HRST_TO_RESUME |
-                                  AHCI_FLAG_NO_NCQ,
+                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON | ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_vt8251_ops,
         },
         /* board_ahci_ign_iferr */
         {
-                .flags          = AHCI_FLAG_COMMON | AHCI_FLAG_IGN_IRQ_IF_ERR,
+                AHCI_HFLAGS     (AHCI_HFLAG_IGN_IRQ_IF_ERR),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_sb600 */
         {
-                .flags          = AHCI_FLAG_COMMON |
-                                  AHCI_FLAG_IGN_SERR_INTERNAL |
-                                  AHCI_FLAG_32BIT_ONLY,
+                AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL |
+                                 AHCI_HFLAG_32BIT_ONLY | AHCI_HFLAG_NO_PMP),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_mv */
         {
-                .sht            = &ahci_sht,
+                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
+                                 AHCI_HFLAG_MV_PATA),
                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                  ATA_FLAG_SKIP_D2H_BSY | AHCI_FLAG_HONOR_PI |
-                                  AHCI_FLAG_NO_NCQ | AHCI_FLAG_NO_MSI |
-                                  AHCI_FLAG_MV_PATA,
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
@@ -394,23 +403,25 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */
-        { PCI_VDEVICE(INTEL, 0x2821), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2822), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2824), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2829), board_ahci_pi }, /* ICH8M */
-        { PCI_VDEVICE(INTEL, 0x282a), board_ahci_pi }, /* ICH8M */
-        { PCI_VDEVICE(INTEL, 0x2922), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2923), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2924), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2925), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2927), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2929), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292a), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292b), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292c), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292f), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x294d), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x294e), board_ahci_pi }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */
+        { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */
+        { PCI_VDEVICE(INTEL, 0x2922), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2923), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2924), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2925), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2927), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2929), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292a), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292b), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292c), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292f), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x294d), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x294e), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x502a), board_ahci }, /* Tolapai */
+        { PCI_VDEVICE(INTEL, 0x502b), board_ahci }, /* Tolapai */
 
         /* JMicron 360/1/3/5/6, match class to avoid IDE function */
         { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
@@ -474,6 +485,14 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci },            /* MCP77 */
         { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci },            /* MCP77 */
         { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ab8), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0ab9), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0aba), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abb), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abc), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abd), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abe), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abf), board_ahci },            /* MCP79 */
 
         /* SiS */
         { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */
@@ -524,7 +543,6 @@ static inline void __iomem *ahci_port_base(struct ata_port *ap)
 /**
  *      ahci_save_initial_config - Save and fixup initial config values
  *      @pdev: target PCI device
- *      @pi: associated ATA port info
  *      @hpriv: host private area to store config values
  *
  *      Some registers containing configuration info might be setup by
@@ -538,7 +556,6 @@ static inline void __iomem *ahci_port_base(struct ata_port *ap)
  *      None.
  */
 static void ahci_save_initial_config(struct pci_dev *pdev,
-                                     const struct ata_port_info *pi,
                                      struct ahci_host_priv *hpriv)
 {
         void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
@@ -552,26 +569,22 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
 
         /* some chips have errata preventing 64bit use */
-        if ((cap & HOST_CAP_64) && (pi->flags & AHCI_FLAG_32BIT_ONLY)) {
+        if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) {
                 dev_printk(KERN_INFO, &pdev->dev,
                            "controller can't do 64bit DMA, forcing 32bit\n");
                 cap &= ~HOST_CAP_64;
         }
 
-        if ((cap & HOST_CAP_NCQ) && (pi->flags & AHCI_FLAG_NO_NCQ)) {
+        if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) {
                 dev_printk(KERN_INFO, &pdev->dev,
                            "controller can't do NCQ, turning off CAP_NCQ\n");
                 cap &= ~HOST_CAP_NCQ;
         }
 
-        /* fixup zero port_map */
-        if (!port_map) {
-                port_map = (1 << ahci_nr_ports(cap)) - 1;
-                dev_printk(KERN_WARNING, &pdev->dev,
-                           "PORTS_IMPL is zero, forcing 0x%x\n", port_map);
-
-                /* write the fixed up value to the PI register */
-                hpriv->saved_port_map = port_map;
+        if ((cap && HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "controller can't do PMP, turning off CAP_PMP\n");
+                cap &= ~HOST_CAP_PMP;
         }
 
         /*
@@ -579,7 +592,7 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
          * is asserted through the standard AHCI port
          * presence register, as bit 4 (counting from 0)
          */
-        if (pi->flags & AHCI_FLAG_MV_PATA) {
+        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
                 dev_printk(KERN_ERR, &pdev->dev,
                            "MV_AHCI HACK: port_map %x -> %x\n",
                            hpriv->port_map,
@@ -589,7 +602,7 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         }
 
         /* cross check port_map and cap.n_ports */
-        if (pi->flags & AHCI_FLAG_HONOR_PI) {
+        if (port_map) {
                 u32 tmp_port_map = port_map;
                 int n_ports = ahci_nr_ports(cap);
 
@@ -600,17 +613,26 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
                         }
                 }
 
-                /* Whine if inconsistent.  No need to update cap.
-                 * port_map is used to determine number of ports.
+                /* If n_ports and port_map are inconsistent, whine and
+                 * clear port_map and let it be generated from n_ports.
                  */
-                if (n_ports || tmp_port_map)
+                if (n_ports || tmp_port_map) {
                         dev_printk(KERN_WARNING, &pdev->dev,
                                    "nr_ports (%u) and implemented port map "
-                                   "(0x%x) don't match\n",
+                                   "(0x%x) don't match, using nr_ports\n",
                                    ahci_nr_ports(cap), port_map);
-        } else {
-                /* fabricate port_map from cap.nr_ports */
+                        port_map = 0;
+                }
+        }
+
+        /* fabricate port_map from cap.nr_ports */
+        if (!port_map) {
                 port_map = (1 << ahci_nr_ports(cap)) - 1;
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "forcing PORTS_IMPL to 0x%x\n", port_map);
+
+                /* write the fixed up value to the PI register */
+                hpriv->saved_port_map = port_map;
         }
 
         /* record values to use during operation */
@@ -836,8 +858,14 @@ static int ahci_reset_controller(struct ata_host *host)
         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
         u32 tmp;
 
-        /* global controller reset */
+        /* we must be in AHCI mode, before using anything
+         * AHCI-specific, such as HOST_RESET.
+         */
         tmp = readl(mmio + HOST_CTL);
+        if (!(tmp & HOST_AHCI_EN))
+                writel(tmp | HOST_AHCI_EN, mmio + HOST_CTL);
+
+        /* global controller reset */
         if ((tmp & HOST_RESET) == 0) {
                 writel(tmp | HOST_RESET, mmio + HOST_CTL);
                 readl(mmio + HOST_CTL); /* flush */
@@ -904,13 +932,14 @@ static void ahci_port_init(struct pci_dev *pdev, struct ata_port *ap,
 
 static void ahci_init_controller(struct ata_host *host)
 {
+        struct ahci_host_priv *hpriv = host->private_data;
         struct pci_dev *pdev = to_pci_dev(host->dev);
         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
         int i;
         void __iomem *port_mmio;
         u32 tmp;
 
-        if (host->ports[0]->flags & AHCI_FLAG_MV_PATA) {
+        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
                 port_mmio = __ahci_port_base(host, 4);
 
                 writel(0, port_mmio + PORT_IRQ_MASK);
@@ -1042,9 +1071,10 @@ static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
         return 0;
 }
 
-static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
                              int pmp, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         const char *reason = NULL;
         unsigned long now, msecs;
         struct ata_taskfile tf;
@@ -1052,7 +1082,7 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 DPRINTK("PHY reports no device\n");
                 *class = ATA_DEV_NONE;
                 return 0;
@@ -1061,10 +1091,10 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
         /* prepare for SRST (AHCI-1.1 10.4.1) */
         rc = ahci_kick_engine(ap, 1);
         if (rc)
-                ata_port_printk(ap, KERN_WARNING,
+                ata_link_printk(link, KERN_WARNING,
                                 "failed to reset engine (errno=%d)", rc);
 
-        ata_tf_init(ap->device, &tf);
+        ata_tf_init(link->device, &tf);
 
         /* issue the first D2H Register FIS */
         msecs = 0;
@@ -1109,19 +1139,25 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
         return 0;
 
  fail:
-        ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+        ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
         return rc;
 }
 
-static int ahci_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_softreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
-        return ahci_do_softreset(ap, class, 0, deadline);
+        int pmp = 0;
+
+        if (link->ap->flags & ATA_FLAG_PMP)
+                pmp = SATA_PMP_CTRL_PORT;
+
+        return ahci_do_softreset(link, class, pmp, deadline);
 }
 
-static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_hardreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct ahci_port_priv *pp = ap->private_data;
         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
         struct ata_taskfile tf;
@@ -1132,26 +1168,27 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
         ahci_stop_engine(ap);
 
         /* clear D2H reception area to properly wait for D2H FIS */
-        ata_tf_init(ap->device, &tf);
+        ata_tf_init(link->device, &tf);
         tf.command = 0x80;
         ata_tf_to_fis(&tf, 0, 0, d2h_fis);
 
-        rc = sata_std_hardreset(ap, class, deadline);
+        rc = sata_std_hardreset(link, class, deadline);
 
         ahci_start_engine(ap);
 
-        if (rc == 0 && ata_port_online(ap))
+        if (rc == 0 && ata_link_online(link))
                 *class = ahci_dev_classify(ap);
-        if (*class == ATA_DEV_UNKNOWN)
+        if (rc != -EAGAIN && *class == ATA_DEV_UNKNOWN)
                 *class = ATA_DEV_NONE;
 
         DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
         return rc;
 }
 
-static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
                                  unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         u32 serror;
         int rc;
 
@@ -1159,7 +1196,7 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
 
         ahci_stop_engine(ap);
 
-        rc = sata_port_hardreset(ap, sata_ehc_deb_timing(&ap->eh_context),
+        rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
                                  deadline);
 
         /* vt8251 needs SError cleared for the port to operate */
@@ -1176,12 +1213,13 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
         return rc ?: -EAGAIN;
 }
 
-static void ahci_postreset(struct ata_port *ap, unsigned int *class)
+static void ahci_postreset(struct ata_link *link, unsigned int *class)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port_mmio = ahci_port_base(ap);
         u32 new_tmp, tmp;
 
-        ata_std_postreset(ap, class);
+        ata_std_postreset(link, class);
 
         /* Make sure port's ATAPI bit is set appropriately */
         new_tmp = tmp = readl(port_mmio + PORT_CMD);
@@ -1195,6 +1233,12 @@ static void ahci_postreset(struct ata_port *ap, unsigned int *class)
         }
 }
 
+static int ahci_pmp_softreset(struct ata_link *link, unsigned int *class,
+                              unsigned long deadline)
+{
+        return ahci_do_softreset(link, class, link->pmp, deadline);
+}
+
 static u8 ahci_check_status(struct ata_port *ap)
 {
         void __iomem *mmio = ap->ioaddr.cmd_addr;
@@ -1253,7 +1297,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
          */
         cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
 
-        ata_tf_to_fis(&qc->tf, 0, 1, cmd_tbl);
+        ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl);
         if (is_atapi) {
                 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
                 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
@@ -1266,7 +1310,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
         /*
          * Fill in command slot information.
          */
-        opts = cmd_fis_len | n_elem << 16;
+        opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12);
         if (qc->tf.flags & ATA_TFLAG_WRITE)
                 opts |= AHCI_CMD_WRITE;
         if (is_atapi)
@@ -1277,66 +1321,87 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
 
 static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
 {
+        struct ahci_host_priv *hpriv = ap->host->private_data;
         struct ahci_port_priv *pp = ap->private_data;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        unsigned int err_mask = 0, action = 0;
-        struct ata_queued_cmd *qc;
+        struct ata_eh_info *host_ehi = &ap->link.eh_info;
+        struct ata_link *link = NULL;
+        struct ata_queued_cmd *active_qc;
+        struct ata_eh_info *active_ehi;
         u32 serror;
 
-        ata_ehi_clear_desc(ehi);
+        /* determine active link */
+        ata_port_for_each_link(link, ap)
+                if (ata_link_active(link))
+                        break;
+        if (!link)
+                link = &ap->link;
+
+        active_qc = ata_qc_from_tag(ap, link->active_tag);
+        active_ehi = &link->eh_info;
+
+        /* record irq stat */
+        ata_ehi_clear_desc(host_ehi);
+        ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat);
 
         /* AHCI needs SError cleared; otherwise, it might lock up */
         ahci_scr_read(ap, SCR_ERROR, &serror);
         ahci_scr_write(ap, SCR_ERROR, serror);
-
-        /* analyze @irq_stat */
-        ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
+        host_ehi->serror |= serror;
 
         /* some controllers set IRQ_IF_ERR on device errors, ignore it */
-        if (ap->flags & AHCI_FLAG_IGN_IRQ_IF_ERR)
+        if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR)
                 irq_stat &= ~PORT_IRQ_IF_ERR;
 
         if (irq_stat & PORT_IRQ_TF_ERR) {
-                err_mask |= AC_ERR_DEV;
-                if (ap->flags & AHCI_FLAG_IGN_SERR_INTERNAL)
-                        serror &= ~SERR_INTERNAL;
+                /* If qc is active, charge it; otherwise, the active
+                 * link.  There's no active qc on NCQ errors.  It will
+                 * be determined by EH by reading log page 10h.
+                 */
+                if (active_qc)
+                        active_qc->err_mask |= AC_ERR_DEV;
+                else
+                        active_ehi->err_mask |= AC_ERR_DEV;
+
+                if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL)
+                        host_ehi->serror &= ~SERR_INTERNAL;
+        }
+
+        if (irq_stat & PORT_IRQ_UNK_FIS) {
+                u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
+
+                active_ehi->err_mask |= AC_ERR_HSM;
+                active_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(active_ehi,
+                                  "unknown FIS %08x %08x %08x %08x" ,
+                                  unk[0], unk[1], unk[2], unk[3]);
+        }
+
+        if (ap->nr_pmp_links && (irq_stat & PORT_IRQ_BAD_PMP)) {
+                active_ehi->err_mask |= AC_ERR_HSM;
+                active_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(active_ehi, "incorrect PMP");
         }
 
         if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
-                err_mask |= AC_ERR_HOST_BUS;
-                action |= ATA_EH_SOFTRESET;
+                host_ehi->err_mask |= AC_ERR_HOST_BUS;
+                host_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(host_ehi, "host bus error");
         }
 
         if (irq_stat & PORT_IRQ_IF_ERR) {
-                err_mask |= AC_ERR_ATA_BUS;
-                action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, "interface fatal error");
+                host_ehi->err_mask |= AC_ERR_ATA_BUS;
+                host_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(host_ehi, "interface fatal error");
         }
 
         if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
-                ata_ehi_hotplugged(ehi);
-                ata_ehi_push_desc(ehi, "%s", irq_stat & PORT_IRQ_CONNECT ?
+                ata_ehi_hotplugged(host_ehi);
+                ata_ehi_push_desc(host_ehi, "%s",
+                        irq_stat & PORT_IRQ_CONNECT ?
                         "connection status changed" : "PHY RDY changed");
         }
 
-        if (irq_stat & PORT_IRQ_UNK_FIS) {
-                u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
-
-                err_mask |= AC_ERR_HSM;
-                action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, "unknown FIS %08x %08x %08x %08x",
-                                  unk[0], unk[1], unk[2], unk[3]);
-        }
-
         /* okay, let's hand over to EH */
-        ehi->serror |= serror;
-        ehi->action |= action;
-
-        qc = ata_qc_from_tag(ap, ap->active_tag);
-        if (qc)
-                qc->err_mask |= err_mask;
-        else
-                ehi->err_mask |= err_mask;
 
         if (irq_stat & PORT_IRQ_FREEZE)
                 ata_port_freeze(ap);
@@ -1347,25 +1412,64 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
 static void ahci_port_intr(struct ata_port *ap)
 {
         void __iomem *port_mmio = ap->ioaddr.cmd_addr;
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         struct ahci_port_priv *pp = ap->private_data;
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+        int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING);
         u32 status, qc_active;
         int rc, known_irq = 0;
 
         status = readl(port_mmio + PORT_IRQ_STAT);
         writel(status, port_mmio + PORT_IRQ_STAT);
 
+        /* ignore BAD_PMP while resetting */
+        if (unlikely(resetting))
+                status &= ~PORT_IRQ_BAD_PMP;
+
         if (unlikely(status & PORT_IRQ_ERROR)) {
                 ahci_error_intr(ap, status);
                 return;
         }
 
-        if (ap->sactive)
+        if (status & PORT_IRQ_SDB_FIS) {
+                /* If SNotification is available, leave notification
+                 * handling to sata_async_notification().  If not,
+                 * emulate it by snooping SDB FIS RX area.
+                 *
+                 * Snooping FIS RX area is probably cheaper than
+                 * poking SNotification but some constrollers which
+                 * implement SNotification, ICH9 for example, don't
+                 * store AN SDB FIS into receive area.
+                 */
+                if (hpriv->cap & HOST_CAP_SNTF)
+                        sata_async_notification(ap);
+                else {
+                        /* If the 'N' bit in word 0 of the FIS is set,
+                         * we just received asynchronous notification.
+                         * Tell libata about it.
+                         */
+                        const __le32 *f = pp->rx_fis + RX_FIS_SDB;
+                        u32 f0 = le32_to_cpu(f[0]);
+
+                        if (f0 & (1 << 15))
+                                sata_async_notification(ap);
+                }
+        }
+
+        /* pp->active_link is valid iff any command is in flight */
+        if (ap->qc_active && pp->active_link->sactive)
                 qc_active = readl(port_mmio + PORT_SCR_ACT);
         else
                 qc_active = readl(port_mmio + PORT_CMD_ISSUE);
 
         rc = ata_qc_complete_multiple(ap, qc_active, NULL);
+
+        /* If resetting, spurious or invalid completions are expected,
+         * return unconditionally.
+         */
+        if (resetting)
+                return;
+
         if (rc > 0)
                 return;
         if (rc < 0) {
@@ -1380,7 +1484,7 @@ static void ahci_port_intr(struct ata_port *ap)
         /* if !NCQ, ignore.  No modern ATA device has broken HSM
          * implementation for non-NCQ commands.
          */
-        if (!ap->sactive)
+        if (!ap->link.sactive)
                 return;
 
         if (status & PORT_IRQ_D2H_REG_FIS) {
@@ -1433,7 +1537,7 @@ static void ahci_port_intr(struct ata_port *ap)
         if (!known_irq)
                 ata_port_printk(ap, KERN_INFO, "spurious interrupt "
                                 "(irq_stat 0x%x active_tag 0x%x sactive 0x%x)\n",
-                                status, ap->active_tag, ap->sactive);
+                                status, ap->link.active_tag, ap->link.sactive);
 }
 
 static void ahci_irq_clear(struct ata_port *ap)
@@ -1498,6 +1602,13 @@ static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
         void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+
+        /* Keep track of the currently active link.  It will be used
+         * in completion path to determine whether NCQ phase is in
+         * progress.
+         */
+        pp->active_link = qc->dev->link;
 
         if (qc->tf.protocol == ATA_PROT_NCQ)
                 writel(1 << qc->tag, port_mmio + PORT_SCR_ACT);
@@ -1520,6 +1631,7 @@ static void ahci_thaw(struct ata_port *ap)
         void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
         void __iomem *port_mmio = ahci_port_base(ap);
         u32 tmp;
+        struct ahci_port_priv *pp = ap->private_data;
 
         /* clear IRQ */
         tmp = readl(port_mmio + PORT_IRQ_STAT);
@@ -1527,7 +1639,7 @@ static void ahci_thaw(struct ata_port *ap)
         writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
 
         /* turn IRQ back on */
-        writel(DEF_PORT_IRQ, port_mmio + PORT_IRQ_MASK);
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
 }
 
 static void ahci_error_handler(struct ata_port *ap)
@@ -1539,8 +1651,10 @@ static void ahci_error_handler(struct ata_port *ap)
         }
 
         /* perform recovery */
-        ata_do_eh(ap, ata_std_prereset, ahci_softreset, ahci_hardreset,
-                  ahci_postreset);
+        sata_pmp_do_eh(ap, ata_std_prereset, ahci_softreset,
+                       ahci_hardreset, ahci_postreset,
+                       sata_pmp_std_prereset, ahci_pmp_softreset,
+                       sata_pmp_std_hardreset, sata_pmp_std_postreset);
 }
 
 static void ahci_vt8251_error_handler(struct ata_port *ap)
@@ -1565,11 +1679,44 @@ static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
                 ahci_kick_engine(ap, 1);
 }
 
+static void ahci_pmp_attach(struct ata_port *ap)
+{
+        void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+        u32 cmd;
+
+        cmd = readl(port_mmio + PORT_CMD);
+        cmd |= PORT_CMD_PMP;
+        writel(cmd, port_mmio + PORT_CMD);
+
+        pp->intr_mask |= PORT_IRQ_BAD_PMP;
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+}
+
+static void ahci_pmp_detach(struct ata_port *ap)
+{
+        void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+        u32 cmd;
+
+        cmd = readl(port_mmio + PORT_CMD);
+        cmd &= ~PORT_CMD_PMP;
+        writel(cmd, port_mmio + PORT_CMD);
+
+        pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+}
+
 static int ahci_port_resume(struct ata_port *ap)
 {
         ahci_power_up(ap);
         ahci_start_port(ap);
 
+        if (ap->nr_pmp_links)
+                ahci_pmp_attach(ap);
+        else
+                ahci_pmp_detach(ap);
+
         return 0;
 }
 
@@ -1681,6 +1828,12 @@ static int ahci_port_start(struct ata_port *ap)
         pp->cmd_tbl = mem;
         pp->cmd_tbl_dma = mem_dma;
 
+        /*
+         * Save off initial list of interrupts to be enabled.
+         * This could be changed later
+         */
+        pp->intr_mask = DEF_PORT_IRQ;
+
         ap->private_data = pp;
 
         /* engage engines, captain */
@@ -1830,20 +1983,24 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        if ((pi.flags & AHCI_FLAG_NO_MSI) || pci_enable_msi(pdev))
-                pci_intx(pdev, 1);
-
         hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
         if (!hpriv)
                 return -ENOMEM;
+        hpriv->flags |= (unsigned long)pi.private_data;
+
+        if ((hpriv->flags & AHCI_HFLAG_NO_MSI) || pci_enable_msi(pdev))
+                pci_intx(pdev, 1);
 
         /* save initial config */
-        ahci_save_initial_config(pdev, &pi, hpriv);
+        ahci_save_initial_config(pdev, hpriv);
 
         /* prepare host */
         if (hpriv->cap & HOST_CAP_NCQ)
                 pi.flags |= ATA_FLAG_NCQ;
 
+        if (hpriv->cap & HOST_CAP_PMP)
+                pi.flags |= ATA_FLAG_PMP;
+
         host = ata_host_alloc_pinfo(&pdev->dev, ppi, fls(hpriv->port_map));
         if (!host)
                 return -ENOMEM;
@@ -1854,6 +2011,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 struct ata_port *ap = host->ports[i];
                 void __iomem *port_mmio = ahci_port_base(ap);
 
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar");
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR,
+                                   0x100 + ap->port_no * 0x80, "port");
+
                 /* standard SATA port setup */
                 if (hpriv->port_map & (1 << i))
                         ap->ioaddr.cmd_addr = port_mmio;
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index 9454669547..90329982be 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -34,7 +34,7 @@
 
 /**
  *      generic_set_mode        -       mode setting
- *      @ap: interface to set up
+ *      @link: link to set up
  *      @unused: returned device on error
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -43,24 +43,24 @@
  *      and respect them.
  */
 
-static int generic_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int generic_set_mode(struct ata_link *link, struct ata_device **unused)
 {
+        struct ata_port *ap = link->ap;
         int dma_enabled = 0;
-        int i;
+        struct ata_device *dev;
 
         /* Bits 5 and 6 indicate if DMA is active on master/slave */
         if (ap->ioaddr.bmdma_addr)
                 dma_enabled = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
                         dev->dma_mode = XFER_MW_DMA_0;
                         /* We do need the right mode information for DMA or PIO
                            and this comes from the current configuration flags */
-                        if (dma_enabled & (1 << (5 + i))) {
+                        if (dma_enabled & (1 << (5 + dev->devno))) {
                                 ata_id_to_dma_mode(dev, XFER_MW_DMA_0);
                                 dev->flags &= ~ATA_DFLAG_PIO;
                         } else {
@@ -95,7 +95,6 @@ static struct scsi_host_template generic_sht = {
 static struct ata_port_operations generic_port_ops = {
         .set_mode       = generic_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -121,9 +120,8 @@ static struct ata_port_operations generic_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int all_generic_ide;             /* Set to claim all devices */
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 92c2d5082b..e783e678ac 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -123,7 +123,6 @@ enum {
         ich_pata_33             = 1,    /* ICH up to UDMA 33 only */
         ich_pata_66             = 2,    /* ICH up to 66 Mhz */
         ich_pata_100            = 3,    /* ICH up to UDMA 100 */
-        ich_pata_133            = 4,    /* ICH up to UDMA 133 */
         ich5_sata               = 5,
         ich6_sata               = 6,
         ich6_sata_ahci          = 7,
@@ -199,7 +198,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x24CA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         { 0x8086, 0x24CB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* Intel ICH5 */
-        { 0x8086, 0x24DB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_133 },
+        { 0x8086, 0x24DB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* C-ICH (i810E2) */
         { 0x8086, 0x245B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ESB (855GME/875P + 6300ESB) UDMA 100  */
@@ -207,7 +206,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
         /* ICH6 (and 6) (i915) UDMA 100 */
         { 0x8086, 0x266F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ICH7/7-R (i945, i975) UDMA 100*/
-        { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_133 },
+        { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         { 0x8086, 0x269E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ICH8 Mobile PATA Controller */
         { 0x8086, 0x2850, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
@@ -290,7 +289,6 @@ static struct scsi_host_template piix_sht = {
 };
 
 static const struct ata_port_operations piix_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = piix_set_piomode,
         .set_dmamode            = piix_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -318,13 +316,11 @@ static const struct ata_port_operations piix_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations ich_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = piix_set_piomode,
         .set_dmamode            = ich_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -352,14 +348,11 @@ static const struct ata_port_operations ich_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations piix_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -382,7 +375,6 @@ static const struct ata_port_operations piix_sata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
@@ -445,15 +437,15 @@ static const struct piix_map_db ich8_map_db = {
 };
 
 static const struct piix_map_db tolapai_map_db = {
-        .mask = 0x3,
-        .port_enable = 0x3,
-        .map = {
-                /* PM   PS   SM   SS       MAP */
-                {  P0,  NA,  P1,  NA }, /* 00b */
-                {  RV,  RV,  RV,  RV }, /* 01b */
-                {  RV,  RV,  RV,  RV }, /* 10b */
-                {  RV,  RV,  RV,  RV },
-        },
+        .mask = 0x3,
+        .port_enable = 0x3,
+        .map = {
+                /* PM   PS   SM   SS       MAP */
+                {  P0,  NA,  P1,  NA }, /* 00b */
+                {  RV,  RV,  RV,  RV }, /* 01b */
+                {  RV,  RV,  RV,  RV }, /* 10b */
+                {  RV,  RV,  RV,  RV },
+        },
 };
 
 static const struct piix_map_db *piix_map_db_table[] = {
@@ -466,7 +458,7 @@ static const struct piix_map_db *piix_map_db_table[] = {
 };
 
 static struct ata_port_info piix_port_info[] = {
-        /* piix_pata_33: 0:  PIIX4 at 33MHz */
+        [piix_pata_33] =        /* PIIX4 at 33MHz */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -476,7 +468,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_pata_ops,
         },
 
-        /* ich_pata_33: 1       ICH0 - ICH at 33Mhz*/
+        [ich_pata_33] =         /* ICH0 - ICH at 33Mhz*/
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -485,7 +477,8 @@ static struct ata_port_info piix_port_info[] = {
                 .udma_mask      = ATA_UDMA2, /* UDMA33 */
                 .port_ops       = &ich_pata_ops,
         },
-        /* ich_pata_66: 2       ICH controllers up to 66MHz */
+
+        [ich_pata_66] =         /* ICH controllers up to 66MHz */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -495,7 +488,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &ich_pata_ops,
         },
 
-        /* ich_pata_100: 3 */
+        [ich_pata_100] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
@@ -505,17 +498,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &ich_pata_ops,
         },
 
-        /* ich_pata_133: 4      ICH with full UDMA6 */
-        {
-                .sht            = &piix_sht,
-                .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
-                .pio_mask       = 0x1f, /* pio 0-4 */
-                .mwdma_mask     = 0x06, /* Check: maybe 0x07  */
-                .udma_mask      = ATA_UDMA6, /* UDMA133 */
-                .port_ops       = &ich_pata_ops,
-        },
-
-        /* ich5_sata: 5 */
+        [ich5_sata] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS,
@@ -525,7 +508,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6_sata: 6 */
+        [ich6_sata] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR,
@@ -535,7 +518,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6_sata_ahci: 7 */
+        [ich6_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -546,7 +529,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6m_sata_ahci: 8 */
+        [ich6m_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -557,7 +540,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich8_sata_ahci: 9 */
+        [ich8_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -568,7 +551,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* piix_pata_mwdma: 10:  PIIX3 MWDMA only */
+        [piix_pata_mwdma] =     /* PIIX3 MWDMA only */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -577,7 +560,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_pata_ops,
         },
 
-        /* tolapai_sata_ahci: 11: */
+        [tolapai_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -615,6 +598,7 @@ static const struct ich_laptop ich_laptop[] = {
         { 0x27DF, 0x0005, 0x0280 },     /* ICH7 on Acer 5602WLMi */
         { 0x27DF, 0x1025, 0x0110 },     /* ICH7 on Acer 3682WLMi */
         { 0x27DF, 0x1043, 0x1267 },     /* ICH7 on Asus W5F */
+        { 0x27DF, 0x103C, 0x30A1 },     /* ICH7 on HP Compaq nc2400 */
         { 0x24CA, 0x1025, 0x0061 },     /* ICH4 on ACER Aspire 2023WLMi */
         /* end marker */
         { 0, }
@@ -657,19 +641,20 @@ static int ich_pata_cable_detect(struct ata_port *ap)
 
 /**
  *      piix_pata_prereset - prereset for PATA host controller
- *      @ap: Target port
+ *      @link: Target link
  *      @deadline: deadline jiffies for the operation
  *
  *      LOCKING:
  *      None (inherited from caller).
  */
-static int piix_pata_prereset(struct ata_port *ap, unsigned long deadline)
+static int piix_pata_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->port_no]))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void piix_pata_error_handler(struct ata_port *ap)
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index c059f78ad9..3f75335890 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -14,6 +14,7 @@
 #include <linux/acpi.h>
 #include <linux/libata.h>
 #include <linux/pci.h>
+#include <scsi/scsi_device.h>
 #include "libata.h"
 
 #include <acpi/acpi_bus.h>
@@ -40,11 +41,40 @@ static int is_pci_dev(struct device *dev)
         return (dev->bus == &pci_bus_type);
 }
 
-static void ata_acpi_associate_sata_port(struct ata_port *ap)
+/**
+ * ata_acpi_associate_sata_port - associate SATA port with ACPI objects
+ * @ap: target SATA port
+ *
+ * Look up ACPI objects associated with @ap and initialize acpi_handle
+ * fields of @ap, the port and devices accordingly.
+ *
+ * LOCKING:
+ * EH context.
+ *
+ * RETURNS:
+ * 0 on success, -errno on failure.
+ */
+void ata_acpi_associate_sata_port(struct ata_port *ap)
 {
-        acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
+        WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
+
+        if (!ap->nr_pmp_links) {
+                acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
+
+                ap->link.device->acpi_handle =
+                        acpi_get_child(ap->host->acpi_handle, adr);
+        } else {
+                struct ata_link *link;
+
+                ap->link.device->acpi_handle = NULL;
 
-        ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr);
+                ata_port_for_each_link(link, ap) {
+                        acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
+
+                        link->device->acpi_handle =
+                                acpi_get_child(ap->host->acpi_handle, adr);
+                }
+        }
 }
 
 static void ata_acpi_associate_ide_port(struct ata_port *ap)
@@ -60,12 +90,53 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
                 max_devices++;
 
         for (i = 0; i < max_devices; i++) {
-                struct ata_device *dev = &ap->device[i];
+                struct ata_device *dev = &ap->link.device[i];
 
                 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
         }
 }
 
+static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
+                                     u32 event)
+{
+        char event_string[12];
+        char *envp[] = { event_string, NULL };
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+
+        if (event == 0 || event == 1) {
+               unsigned long flags;
+               spin_lock_irqsave(ap->lock, flags);
+               ata_ehi_clear_desc(ehi);
+               ata_ehi_push_desc(ehi, "ACPI event");
+               ata_ehi_hotplugged(ehi);
+               ata_port_freeze(ap);
+               spin_unlock_irqrestore(ap->lock, flags);
+        }
+
+        if (kobj) {
+                sprintf(event_string, "BAY_EVENT=%d", event);
+                kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
+        }
+}
+
+static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct ata_device *dev = data;
+        struct kobject *kobj = NULL;
+
+        if (dev->sdev)
+                kobj = &dev->sdev->sdev_gendev.kobj;
+
+        ata_acpi_handle_hotplug (dev->link->ap, kobj, event);
+}
+
+static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct ata_port *ap = data;
+
+        ata_acpi_handle_hotplug (ap, &ap->dev->kobj, event);
+}
+
 /**
  * ata_acpi_associate - associate ATA host with ACPI objects
  * @host: target ATA host
@@ -81,7 +152,7 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
  */
 void ata_acpi_associate(struct ata_host *host)
 {
-        int i;
+        int i, j;
 
         if (!is_pci_dev(host->dev) || libata_noacpi)
                 return;
@@ -97,6 +168,22 @@ void ata_acpi_associate(struct ata_host *host)
                         ata_acpi_associate_sata_port(ap);
                 else
                         ata_acpi_associate_ide_port(ap);
+
+                if (ap->acpi_handle)
+                        acpi_install_notify_handler (ap->acpi_handle,
+                                                     ACPI_SYSTEM_NOTIFY,
+                                                     ata_acpi_ap_notify,
+                                                     ap);
+
+                for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
+                        struct ata_device *dev = &ap->link.device[j];
+
+                        if (dev->acpi_handle)
+                                acpi_install_notify_handler (dev->acpi_handle,
+                                                             ACPI_SYSTEM_NOTIFY,
+                                                             ata_acpi_dev_notify,
+                                                             dev);
+                }
         }
 }
 
@@ -113,7 +200,7 @@ void ata_acpi_associate(struct ata_host *host)
  * RETURNS:
  * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
  */
-static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
+int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
 {
         struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
         union acpi_object *out_obj;
@@ -157,6 +244,8 @@ static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
         return rc;
 }
 
+EXPORT_SYMBOL_GPL(ata_acpi_gtm);
+
 /**
  * ata_acpi_stm - execute _STM
  * @ap: target ATA port
@@ -170,7 +259,7 @@ static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
  * RETURNS:
  * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
  */
-static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
+int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
 {
         acpi_status status;
         struct acpi_object_list         input;
@@ -182,10 +271,10 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
         /* Buffers for id may need byteswapping ? */
         in_params[1].type = ACPI_TYPE_BUFFER;
         in_params[1].buffer.length = 512;
-        in_params[1].buffer.pointer = (u8 *)ap->device[0].id;
+        in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
         in_params[2].type = ACPI_TYPE_BUFFER;
         in_params[2].buffer.length = 512;
-        in_params[2].buffer.pointer = (u8 *)ap->device[1].id;
+        in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
 
         input.count = 3;
         input.pointer = in_params;
@@ -202,6 +291,8 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
         return 0;
 }
 
+EXPORT_SYMBOL_GPL(ata_acpi_stm);
+
 /**
  * ata_dev_get_GTF - get the drive bootup default taskfile settings
  * @dev: target ATA device
@@ -226,7 +317,7 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
                            void **ptr_to_free)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         acpi_status status;
         struct acpi_buffer output;
         union acpi_object *out_obj;
@@ -296,6 +387,44 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
 }
 
 /**
+ * ata_acpi_cbl_80wire          -       Check for 80 wire cable
+ * @ap: Port to check
+ *
+ * Return 1 if the ACPI mode data for this port indicates the BIOS selected
+ * an 80wire mode.
+ */
+
+int ata_acpi_cbl_80wire(struct ata_port *ap)
+{
+        struct ata_acpi_gtm gtm;
+        int valid = 0;
+        
+        /* No _GTM data, no information */
+        if (ata_acpi_gtm(ap, &gtm) < 0)
+                return 0;
+                
+        /* Split timing, DMA enabled */
+        if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
+                valid |= 1;
+        if ((gtm.flags & 0x14) == 0x14 && gtm.drive[1].dma < 55)
+                valid |= 2;
+        /* Shared timing, DMA enabled */
+        if ((gtm.flags & 0x11) == 0x01 && gtm.drive[0].dma < 55)
+                valid |= 1;
+        if ((gtm.flags & 0x14) == 0x04 && gtm.drive[0].dma < 55)
+                valid |= 2;
+
+        /* Drive check */
+        if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
+                return 1;
+        if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
+                return 1;
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
+
+/**
  * taskfile_load_raw - send taskfile registers to host controller
  * @dev: target ATA device
  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
@@ -320,7 +449,7 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
 static int taskfile_load_raw(struct ata_device *dev,
                               const struct ata_acpi_gtf *gtf)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf, rtf;
         unsigned int err_mask;
 
@@ -349,7 +478,7 @@ static int taskfile_load_raw(struct ata_device *dev,
                                tf.lbal, tf.lbam, tf.lbah, tf.device);
 
         rtf = tf;
-        err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0, 0);
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR,
                         "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
@@ -424,7 +553,7 @@ static int ata_acpi_exec_tfs(struct ata_device *dev)
  */
 static int ata_acpi_push_id(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         int err;
         acpi_status status;
         struct acpi_object_list input;
@@ -508,7 +637,7 @@ int ata_acpi_on_suspend(struct ata_port *ap)
  */
 void ata_acpi_on_resume(struct ata_port *ap)
 {
-        int i;
+        struct ata_device *dev;
 
         if (ap->acpi_handle && (ap->pflags & ATA_PFLAG_GTM_VALID)) {
                 BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
@@ -518,8 +647,8 @@ void ata_acpi_on_resume(struct ata_port *ap)
         }
 
         /* schedule _GTF */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].flags |= ATA_DFLAG_ACPI_PENDING;
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->flags |= ATA_DFLAG_ACPI_PENDING;
 }
 
 /**
@@ -538,8 +667,8 @@ void ata_acpi_on_resume(struct ata_port *ap)
  */
 int ata_acpi_on_devcfg(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = dev->link->ap;
+        struct ata_eh_context *ehc = &ap->link.eh_context;
         int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
         int rc;
 
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 772be09b46..b05384a8c3 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -59,8 +59,6 @@
 
 #include "libata.h"
 
-#define DRV_VERSION     "2.21"  /* must be exactly four chars */
-
 
 /* debounce timing parameters in msecs { interval, duration, timeout } */
 const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
@@ -70,6 +68,7 @@ const unsigned long sata_deb_timing_long[]		= { 100, 2000, 5000 };
 static unsigned int ata_dev_init_params(struct ata_device *dev,
                                         u16 heads, u16 sectors);
 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
+static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable);
 static void ata_dev_xfermask(struct ata_device *dev);
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
 
@@ -86,6 +85,10 @@ int atapi_dmadir = 0;
 module_param(atapi_dmadir, int, 0444);
 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
 
+int atapi_passthru16 = 1;
+module_param(atapi_passthru16, int, 0444);
+MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");
+
 int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
@@ -94,13 +97,17 @@ static int ata_ignore_hpa = 0;
 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
 MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
 
+static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
+module_param_named(dma, libata_dma_mask, int, 0444);
+MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
+
 static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
 module_param(ata_probe_timeout, int, 0444);
 MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 
-int libata_noacpi = 1;
+int libata_noacpi = 0;
 module_param_named(noacpi, libata_noacpi, int, 0444);
-MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in suspend/resume when set");
+MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
 
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
@@ -235,7 +242,7 @@ static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
         if (dev->flags & ATA_DFLAG_PIO) {
                 tf->protocol = ATA_PROT_PIO;
                 index = dev->multi_count ? 0 : 8;
-        } else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) {
+        } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
                 /* Unable to use DMA due to host limitation */
                 tf->protocol = ATA_PROT_PIO;
                 index = dev->multi_count ? 0 : 8;
@@ -604,7 +611,7 @@ static const char *sata_spd_string(unsigned int spd)
 void ata_dev_disable(struct ata_device *dev)
 {
         if (ata_dev_enabled(dev)) {
-                if (ata_msg_drv(dev->ap))
+                if (ata_msg_drv(dev->link->ap))
                         ata_dev_printk(dev, KERN_WARNING, "disabled\n");
                 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
                                              ATA_DNXFER_QUIET);
@@ -667,37 +674,57 @@ static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
  *      None.
  *
  *      RETURNS:
- *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
- *      the event of failure.
+ *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or
+ *      %ATA_DEV_UNKNOWN the event of failure.
  */
-
 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 {
         /* Apple's open source Darwin code hints that some devices only
          * put a proper signature into the LBA mid/high registers,
          * So, we only check those.  It's sufficient for uniqueness.
+         *
+         * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
+         * signatures for ATA and ATAPI devices attached on SerialATA,
+         * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
+         * spec has never mentioned about using different signatures
+         * for ATA/ATAPI devices.  Then, Serial ATA II: Port
+         * Multiplier specification began to use 0x69/0x96 to identify
+         * port multpliers and 0x3c/0xc3 to identify SEMB device.
+         * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
+         * 0x69/0x96 shortly and described them as reserved for
+         * SerialATA.
+         *
+         * We follow the current spec and consider that 0x69/0x96
+         * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
          */
-
-        if (((tf->lbam == 0) && (tf->lbah == 0)) ||
-            ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
+        if ((tf->lbam == 0) && (tf->lbah == 0)) {
                 DPRINTK("found ATA device by sig\n");
                 return ATA_DEV_ATA;
         }
 
-        if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
-            ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
+        if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
                 DPRINTK("found ATAPI device by sig\n");
                 return ATA_DEV_ATAPI;
         }
 
+        if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
+                DPRINTK("found PMP device by sig\n");
+                return ATA_DEV_PMP;
+        }
+
+        if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
+                printk("ata: SEMB device ignored\n");
+                return ATA_DEV_SEMB_UNSUP; /* not yet */
+        }
+
         DPRINTK("unknown device\n");
         return ATA_DEV_UNKNOWN;
 }
 
 /**
  *      ata_dev_try_classify - Parse returned ATA device signature
- *      @ap: ATA channel to examine
- *      @device: Device to examine (starting at zero)
+ *      @dev: ATA device to classify (starting at zero)
+ *      @present: device seems present
  *      @r_err: Value of error register on completion
  *
  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
@@ -715,15 +742,15 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
  *      RETURNS:
  *      Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
  */
-
-unsigned int
-ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
+unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
+                                  u8 *r_err)
 {
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf;
         unsigned int class;
         u8 err;
 
-        ap->ops->dev_select(ap, device);
+        ap->ops->dev_select(ap, dev->devno);
 
         memset(&tf, 0, sizeof(tf));
 
@@ -733,12 +760,12 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
                 *r_err = err;
 
         /* see if device passed diags: if master then continue and warn later */
-        if (err == 0 && device == 0)
+        if (err == 0 && dev->devno == 0)
                 /* diagnostic fail : do nothing _YET_ */
-                ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;
+                dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
         else if (err == 1)
                 /* do nothing */ ;
-        else if ((device == 0) && (err == 0x81))
+        else if ((dev->devno == 0) && (err == 0x81))
                 /* do nothing */ ;
         else
                 return ATA_DEV_NONE;
@@ -746,10 +773,20 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
         /* determine if device is ATA or ATAPI */
         class = ata_dev_classify(&tf);
 
-        if (class == ATA_DEV_UNKNOWN)
-                return ATA_DEV_NONE;
-        if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
-                return ATA_DEV_NONE;
+        if (class == ATA_DEV_UNKNOWN) {
+                /* If the device failed diagnostic, it's likely to
+                 * have reported incorrect device signature too.
+                 * Assume ATA device if the device seems present but
+                 * device signature is invalid with diagnostic
+                 * failure.
+                 */
+                if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC))
+                        class = ATA_DEV_ATA;
+                else
+                        class = ATA_DEV_NONE;
+        } else if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
+                class = ATA_DEV_NONE;
+
         return class;
 }
 
@@ -816,6 +853,21 @@ void ata_id_c_string(const u16 *id, unsigned char *s,
         *p = '\0';
 }
 
+static u64 ata_id_n_sectors(const u16 *id)
+{
+        if (ata_id_has_lba(id)) {
+                if (ata_id_has_lba48(id))
+                        return ata_id_u64(id, 100);
+                else
+                        return ata_id_u32(id, 60);
+        } else {
+                if (ata_id_current_chs_valid(id))
+                        return ata_id_u32(id, 57);
+                else
+                        return id[1] * id[3] * id[6];
+        }
+}
+
 static u64 ata_tf_to_lba48(struct ata_taskfile *tf)
 {
         u64 sectors = 0;
@@ -843,129 +895,110 @@ static u64 ata_tf_to_lba(struct ata_taskfile *tf)
 }
 
 /**
- *      ata_read_native_max_address_ext -       LBA48 native max query
- *      @dev: Device to query
+ *      ata_read_native_max_address - Read native max address
+ *      @dev: target device
+ *      @max_sectors: out parameter for the result native max address
  *
- *      Perform an LBA48 size query upon the device in question. Return the
- *      actual LBA48 size or zero if the command fails.
- */
-
-static u64 ata_read_native_max_address_ext(struct ata_device *dev)
-{
-        unsigned int err;
-        struct ata_taskfile tf;
-
-        ata_tf_init(dev, &tf);
-
-        tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR;
-        tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
-
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
-
-        return ata_tf_to_lba48(&tf);
-}
-
-/**
- *      ata_read_native_max_address     -       LBA28 native max query
- *      @dev: Device to query
+ *      Perform an LBA48 or LBA28 native size query upon the device in
+ *      question.
  *
- *      Performa an LBA28 size query upon the device in question. Return the
- *      actual LBA28 size or zero if the command fails.
+ *      RETURNS:
+ *      0 on success, -EACCES if command is aborted by the drive.
+ *      -EIO on other errors.
  */
-
-static u64 ata_read_native_max_address(struct ata_device *dev)
+static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
 {
-        unsigned int err;
+        unsigned int err_mask;
         struct ata_taskfile tf;
+        int lba48 = ata_id_has_lba48(dev->id);
 
         ata_tf_init(dev, &tf);
 
-        tf.command = ATA_CMD_READ_NATIVE_MAX;
+        /* always clear all address registers */
         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
+
+        if (lba48) {
+                tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
+                tf.flags |= ATA_TFLAG_LBA48;
+        } else
+                tf.command = ATA_CMD_READ_NATIVE_MAX;
+
         tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
+        tf.device |= ATA_LBA;
 
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_WARNING, "failed to read native "
+                               "max address (err_mask=0x%x)\n", err_mask);
+                if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
+                        return -EACCES;
+                return -EIO;
+        }
 
-        return ata_tf_to_lba(&tf);
+        if (lba48)
+                *max_sectors = ata_tf_to_lba48(&tf);
+        else
+                *max_sectors = ata_tf_to_lba(&tf);
+        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
+                (*max_sectors)--;
+        return 0;
 }
 
 /**
- *      ata_set_native_max_address_ext  -       LBA48 native max set
- *      @dev: Device to query
+ *      ata_set_max_sectors - Set max sectors
+ *      @dev: target device
  *      @new_sectors: new max sectors value to set for the device
  *
- *      Perform an LBA48 size set max upon the device in question. Return the
- *      actual LBA48 size or zero if the command fails.
+ *      Set max sectors of @dev to @new_sectors.
+ *
+ *      RETURNS:
+ *      0 on success, -EACCES if command is aborted or denied (due to
+ *      previous non-volatile SET_MAX) by the drive.  -EIO on other
+ *      errors.
  */
-
-static u64 ata_set_native_max_address_ext(struct ata_device *dev, u64 new_sectors)
+static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
 {
-        unsigned int err;
+        unsigned int err_mask;
         struct ata_taskfile tf;
+        int lba48 = ata_id_has_lba48(dev->id);
 
         new_sectors--;
 
         ata_tf_init(dev, &tf);
 
-        tf.command = ATA_CMD_SET_MAX_EXT;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR;
-        tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
-
-        tf.lbal = (new_sectors >> 0) & 0xff;
-        tf.lbam = (new_sectors >> 8) & 0xff;
-        tf.lbah = (new_sectors >> 16) & 0xff;
-
-        tf.hob_lbal = (new_sectors >> 24) & 0xff;
-        tf.hob_lbam = (new_sectors >> 32) & 0xff;
-        tf.hob_lbah = (new_sectors >> 40) & 0xff;
-
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
-
-        return ata_tf_to_lba48(&tf);
-}
-
-/**
- *      ata_set_native_max_address      -       LBA28 native max set
- *      @dev: Device to query
- *      @new_sectors: new max sectors value to set for the device
- *
- *      Perform an LBA28 size set max upon the device in question. Return the
- *      actual LBA28 size or zero if the command fails.
- */
+        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
 
-static u64 ata_set_native_max_address(struct ata_device *dev, u64 new_sectors)
-{
-        unsigned int err;
-        struct ata_taskfile tf;
+        if (lba48) {
+                tf.command = ATA_CMD_SET_MAX_EXT;
+                tf.flags |= ATA_TFLAG_LBA48;
 
-        new_sectors--;
+                tf.hob_lbal = (new_sectors >> 24) & 0xff;
+                tf.hob_lbam = (new_sectors >> 32) & 0xff;
+                tf.hob_lbah = (new_sectors >> 40) & 0xff;
+        } else {
+                tf.command = ATA_CMD_SET_MAX;
 
-        ata_tf_init(dev, &tf);
+                tf.device |= (new_sectors >> 24) & 0xf;
+        }
 
-        tf.command = ATA_CMD_SET_MAX;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
         tf.protocol |= ATA_PROT_NODATA;
+        tf.device |= ATA_LBA;
 
         tf.lbal = (new_sectors >> 0) & 0xff;
         tf.lbam = (new_sectors >> 8) & 0xff;
         tf.lbah = (new_sectors >> 16) & 0xff;
-        tf.device |= ((new_sectors >> 24) & 0x0f) | 0x40;
 
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_WARNING, "failed to set "
+                               "max address (err_mask=0x%x)\n", err_mask);
+                if (err_mask == AC_ERR_DEV &&
+                    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
+                        return -EACCES;
+                return -EIO;
+        }
 
-        return ata_tf_to_lba(&tf);
+        return 0;
 }
 
 /**
@@ -975,60 +1008,93 @@ static u64 ata_set_native_max_address(struct ata_device *dev, u64 new_sectors)
  *      Read the size of an LBA28 or LBA48 disk with HPA features and resize
  *      it if required to the full size of the media. The caller must check
  *      the drive has the HPA feature set enabled.
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
  */
-
-static u64 ata_hpa_resize(struct ata_device *dev)
+static int ata_hpa_resize(struct ata_device *dev)
 {
-        u64 sectors = dev->n_sectors;
-        u64 hpa_sectors;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
+        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
+        u64 sectors = ata_id_n_sectors(dev->id);
+        u64 native_sectors;
+        int rc;
 
-        if (ata_id_has_lba48(dev->id))
-                hpa_sectors = ata_read_native_max_address_ext(dev);
-        else
-                hpa_sectors = ata_read_native_max_address(dev);
+        /* do we need to do it? */
+        if (dev->class != ATA_DEV_ATA ||
+            !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
+            (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
+                return 0;
 
-        if (hpa_sectors > sectors) {
-                ata_dev_printk(dev, KERN_INFO,
-                        "Host Protected Area detected:\n"
-                        "\tcurrent size: %lld sectors\n"
-                        "\tnative size: %lld sectors\n",
-                        (long long)sectors, (long long)hpa_sectors);
-
-                if (ata_ignore_hpa) {
-                        if (ata_id_has_lba48(dev->id))
-                                hpa_sectors = ata_set_native_max_address_ext(dev, hpa_sectors);
-                        else
-                                hpa_sectors = ata_set_native_max_address(dev,
-                                                                hpa_sectors);
-
-                        if (hpa_sectors) {
-                                ata_dev_printk(dev, KERN_INFO, "native size "
-                                        "increased to %lld sectors\n",
-                                        (long long)hpa_sectors);
-                                return hpa_sectors;
-                        }
+        /* read native max address */
+        rc = ata_read_native_max_address(dev, &native_sectors);
+        if (rc) {
+                /* If HPA isn't going to be unlocked, skip HPA
+                 * resizing from the next try.
+                 */
+                if (!ata_ignore_hpa) {
+                        ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
+                                       "broken, will skip HPA handling\n");
+                        dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
+
+                        /* we can continue if device aborted the command */
+                        if (rc == -EACCES)
+                                rc = 0;
                 }
-        } else if (hpa_sectors < sectors)
-                ata_dev_printk(dev, KERN_WARNING, "%s 1: hpa sectors (%lld) "
-                               "is smaller than sectors (%lld)\n", __FUNCTION__,
-                               (long long)hpa_sectors, (long long)sectors);
 
-        return sectors;
-}
+                return rc;
+        }
 
-static u64 ata_id_n_sectors(const u16 *id)
-{
-        if (ata_id_has_lba(id)) {
-                if (ata_id_has_lba48(id))
-                        return ata_id_u64(id, 100);
-                else
-                        return ata_id_u32(id, 60);
-        } else {
-                if (ata_id_current_chs_valid(id))
-                        return ata_id_u32(id, 57);
-                else
-                        return id[1] * id[3] * id[6];
+        /* nothing to do? */
+        if (native_sectors <= sectors || !ata_ignore_hpa) {
+                if (!print_info || native_sectors == sectors)
+                        return 0;
+
+                if (native_sectors > sectors)
+                        ata_dev_printk(dev, KERN_INFO,
+                                "HPA detected: current %llu, native %llu\n",
+                                (unsigned long long)sectors,
+                                (unsigned long long)native_sectors);
+                else if (native_sectors < sectors)
+                        ata_dev_printk(dev, KERN_WARNING,
+                                "native sectors (%llu) is smaller than "
+                                "sectors (%llu)\n",
+                                (unsigned long long)native_sectors,
+                                (unsigned long long)sectors);
+                return 0;
         }
+
+        /* let's unlock HPA */
+        rc = ata_set_max_sectors(dev, native_sectors);
+        if (rc == -EACCES) {
+                /* if device aborted the command, skip HPA resizing */
+                ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
+                               "(%llu -> %llu), skipping HPA handling\n",
+                               (unsigned long long)sectors,
+                               (unsigned long long)native_sectors);
+                dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
+                return 0;
+        } else if (rc)
+                return rc;
+
+        /* re-read IDENTIFY data */
+        rc = ata_dev_reread_id(dev, 0);
+        if (rc) {
+                ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
+                               "data after HPA resizing\n");
+                return rc;
+        }
+
+        if (print_info) {
+                u64 new_sectors = ata_id_n_sectors(dev->id);
+                ata_dev_printk(dev, KERN_INFO,
+                        "HPA unlocked: %llu -> %llu, native %llu\n",
+                        (unsigned long long)sectors,
+                        (unsigned long long)new_sectors,
+                        (unsigned long long)native_sectors);
+        }
+
+        return 0;
 }
 
 /**
@@ -1150,7 +1216,7 @@ void ata_dev_select(struct ata_port *ap, unsigned int device,
         ap->ops->dev_select(ap, device);
 
         if (wait) {
-                if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
+                if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
                         msleep(150);
                 ata_wait_idle(ap);
         }
@@ -1328,6 +1394,7 @@ static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
  *      @dma_dir: Data tranfer direction of the command
  *      @sg: sg list for the data buffer of the command
  *      @n_elem: Number of sg entries
+ *      @timeout: Timeout in msecs (0 for default)
  *
  *      Executes libata internal command with timeout.  @tf contains
  *      command on entry and result on return.  Timeout and error
@@ -1344,13 +1411,15 @@ static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
 unsigned ata_exec_internal_sg(struct ata_device *dev,
                               struct ata_taskfile *tf, const u8 *cdb,
                               int dma_dir, struct scatterlist *sg,
-                              unsigned int n_elem)
+                              unsigned int n_elem, unsigned long timeout)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         u8 command = tf->command;
         struct ata_queued_cmd *qc;
         unsigned int tag, preempted_tag;
         u32 preempted_sactive, preempted_qc_active;
+        int preempted_nr_active_links;
         DECLARE_COMPLETION_ONSTACK(wait);
         unsigned long flags;
         unsigned int err_mask;
@@ -1386,12 +1455,14 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
         qc->dev = dev;
         ata_qc_reinit(qc);
 
-        preempted_tag = ap->active_tag;
-        preempted_sactive = ap->sactive;
+        preempted_tag = link->active_tag;
+        preempted_sactive = link->sactive;
         preempted_qc_active = ap->qc_active;
-        ap->active_tag = ATA_TAG_POISON;
-        ap->sactive = 0;
+        preempted_nr_active_links = ap->nr_active_links;
+        link->active_tag = ATA_TAG_POISON;
+        link->sactive = 0;
         ap->qc_active = 0;
+        ap->nr_active_links = 0;
 
         /* prepare & issue qc */
         qc->tf = *tf;
@@ -1416,7 +1487,10 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
 
         spin_unlock_irqrestore(ap->lock, flags);
 
-        rc = wait_for_completion_timeout(&wait, ata_probe_timeout);
+        if (!timeout)
+                timeout = ata_probe_timeout * 1000 / HZ;
+
+        rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
 
         ata_port_flush_task(ap);
 
@@ -1467,9 +1541,10 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
         err_mask = qc->err_mask;
 
         ata_qc_free(qc);
-        ap->active_tag = preempted_tag;
-        ap->sactive = preempted_sactive;
+        link->active_tag = preempted_tag;
+        link->sactive = preempted_sactive;
         ap->qc_active = preempted_qc_active;
+        ap->nr_active_links = preempted_nr_active_links;
 
         /* XXX - Some LLDDs (sata_mv) disable port on command failure.
          * Until those drivers are fixed, we detect the condition
@@ -1500,6 +1575,7 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
  *      @dma_dir: Data tranfer direction of the command
  *      @buf: Data buffer of the command
  *      @buflen: Length of data buffer
+ *      @timeout: Timeout in msecs (0 for default)
  *
  *      Wrapper around ata_exec_internal_sg() which takes simple
  *      buffer instead of sg list.
@@ -1512,7 +1588,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
  */
 unsigned ata_exec_internal(struct ata_device *dev,
                            struct ata_taskfile *tf, const u8 *cdb,
-                           int dma_dir, void *buf, unsigned int buflen)
+                           int dma_dir, void *buf, unsigned int buflen,
+                           unsigned long timeout)
 {
         struct scatterlist *psg = NULL, sg;
         unsigned int n_elem = 0;
@@ -1524,7 +1601,8 @@ unsigned ata_exec_internal(struct ata_device *dev,
                 n_elem++;
         }
 
-        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem);
+        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
+                                    timeout);
 }
 
 /**
@@ -1551,7 +1629,7 @@ unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
         tf.flags |= ATA_TFLAG_DEVICE;
         tf.protocol = ATA_PROT_NODATA;
 
-        return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 }
 
 /**
@@ -1566,7 +1644,7 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 {
         /* Controller doesn't support  IORDY. Probably a pointless check
            as the caller should know this */
-        if (adev->ap->flags & ATA_FLAG_NO_IORDY)
+        if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
                 return 0;
         /* PIO3 and higher it is mandatory */
         if (adev->pio_mode > XFER_PIO_2)
@@ -1613,6 +1691,9 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
  *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
  *      for pre-ATA4 drives.
  *
+ *      FIXME: ATA_CMD_ID_ATA is optional for early drives and right
+ *      now we abort if we hit that case. 
+ *
  *      LOCKING:
  *      Kernel thread context (may sleep)
  *
@@ -1622,7 +1703,7 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
 int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                     unsigned int flags, u16 *id)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         unsigned int class = *p_class;
         struct ata_taskfile tf;
         unsigned int err_mask = 0;
@@ -1663,7 +1744,7 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
         tf.flags |= ATA_TFLAG_POLLING;
 
         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
-                                     id, sizeof(id[0]) * ATA_ID_WORDS);
+                                     id, sizeof(id[0]) * ATA_ID_WORDS, 0);
         if (err_mask) {
                 if (err_mask & AC_ERR_NODEV_HINT) {
                         DPRINTK("ata%u.%d: NODEV after polling detection\n",
@@ -1722,7 +1803,8 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                 tf.feature = SETFEATURES_SPINUP;
                 tf.protocol = ATA_PROT_NODATA;
                 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-                err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+                err_mask = ata_exec_internal(dev, &tf, NULL,
+                                             DMA_NONE, NULL, 0, 0);
                 if (err_mask && id[2] != 0x738c) {
                         rc = -EIO;
                         reason = "SPINUP failed";
@@ -1740,10 +1822,13 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                 /*
                  * The exact sequence expected by certain pre-ATA4 drives is:
                  * SRST RESET
-                 * IDENTIFY
-                 * INITIALIZE DEVICE PARAMETERS
+                 * IDENTIFY (optional in early ATA)
+                 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
                  * anything else..
                  * Some drives were very specific about that exact sequence.
+                 *
+                 * Note that ATA4 says lba is mandatory so the second check
+                 * shoud never trigger.
                  */
                 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
                         err_mask = ata_dev_init_params(dev, id[3], id[6]);
@@ -1774,13 +1859,14 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
 
 static inline u8 ata_dev_knobble(struct ata_device *dev)
 {
-        return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
+        struct ata_port *ap = dev->link->ap;
+        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
 }
 
 static void ata_dev_config_ncq(struct ata_device *dev,
                                char *desc, size_t desc_sz)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
 
         if (!ata_id_has_ncq(dev->id)) {
@@ -1817,8 +1903,8 @@ static void ata_dev_config_ncq(struct ata_device *dev,
  */
 int ata_dev_configure(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = dev->link->ap;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
         int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
         const u16 *id = dev->id;
         unsigned int xfer_mask;
@@ -1844,6 +1930,11 @@ int ata_dev_configure(struct ata_device *dev)
         if (rc)
                 return rc;
 
+        /* massage HPA, do it early as it might change IDENTIFY data */
+        rc = ata_hpa_resize(dev);
+        if (rc)
+                return rc;
+
         /* print device capabilities */
         if (ata_msg_probe(ap))
                 ata_dev_printk(dev, KERN_DEBUG,
@@ -1911,10 +2002,6 @@ int ata_dev_configure(struct ata_device *dev)
                                         dev->flags |= ATA_DFLAG_FLUSH_EXT;
                         }
 
-                        if (!(dev->horkage & ATA_HORKAGE_BROKEN_HPA) &&
-                            ata_id_hpa_enabled(dev->id))
-                                dev->n_sectors = ata_hpa_resize(dev);
-
                         /* config NCQ */
                         ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
 
@@ -1963,7 +2050,9 @@ int ata_dev_configure(struct ata_device *dev)
 
         /* ATAPI-specific feature tests */
         else if (dev->class == ATA_DEV_ATAPI) {
-                char *cdb_intr_string = "";
+                const char *cdb_intr_string = "";
+                const char *atapi_an_string = "";
+                u32 sntf;
 
                 rc = atapi_cdb_len(id);
                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
@@ -1975,6 +2064,28 @@ int ata_dev_configure(struct ata_device *dev)
                 }
                 dev->cdb_len = (unsigned int) rc;
 
+                /* Enable ATAPI AN if both the host and device have
+                 * the support.  If PMP is attached, SNTF is required
+                 * to enable ATAPI AN to discern between PHY status
+                 * changed notifications and ATAPI ANs.
+                 */
+                if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
+                    (!ap->nr_pmp_links ||
+                     sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
+                        unsigned int err_mask;
+
+                        /* issue SET feature command to turn this on */
+                        err_mask = ata_dev_set_AN(dev, SETFEATURES_SATA_ENABLE);
+                        if (err_mask)
+                                ata_dev_printk(dev, KERN_ERR,
+                                        "failed to enable ATAPI AN "
+                                        "(err_mask=0x%x)\n", err_mask);
+                        else {
+                                dev->flags |= ATA_DFLAG_AN;
+                                atapi_an_string = ", ATAPI AN";
+                        }
+                }
+
                 if (ata_id_cdb_intr(dev->id)) {
                         dev->flags |= ATA_DFLAG_CDB_INTR;
                         cdb_intr_string = ", CDB intr";
@@ -1983,10 +2094,10 @@ int ata_dev_configure(struct ata_device *dev)
                 /* print device info to dmesg */
                 if (ata_msg_drv(ap) && print_info)
                         ata_dev_printk(dev, KERN_INFO,
-                                       "ATAPI: %s, %s, max %s%s\n",
+                                       "ATAPI: %s, %s, max %s%s%s\n",
                                        modelbuf, fwrevbuf,
                                        ata_mode_string(xfer_mask),
-                                       cdb_intr_string);
+                                       cdb_intr_string, atapi_an_string);
         }
 
         /* determine max_sectors */
@@ -2103,21 +2214,19 @@ int ata_bus_probe(struct ata_port *ap)
 {
         unsigned int classes[ATA_MAX_DEVICES];
         int tries[ATA_MAX_DEVICES];
-        int i, rc;
+        int rc;
         struct ata_device *dev;
 
         ata_port_probe(ap);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                tries[i] = ATA_PROBE_MAX_TRIES;
+        ata_link_for_each_dev(dev, &ap->link)
+                tries[dev->devno] = ATA_PROBE_MAX_TRIES;
 
  retry:
         /* reset and determine device classes */
         ap->ops->phy_reset(ap);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, &ap->link) {
                 if (!(ap->flags & ATA_FLAG_DISABLED) &&
                     dev->class != ATA_DEV_UNKNOWN)
                         classes[dev->devno] = dev->class;
@@ -2132,18 +2241,16 @@ int ata_bus_probe(struct ata_port *ap)
         /* after the reset the device state is PIO 0 and the controller
            state is undefined. Record the mode */
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].pio_mode = XFER_PIO_0;
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->pio_mode = XFER_PIO_0;
 
         /* read IDENTIFY page and configure devices. We have to do the identify
            specific sequence bass-ackwards so that PDIAG- is released by
            the slave device */
 
-        for (i = ATA_MAX_DEVICES - 1; i >=  0; i--) {
-                dev = &ap->device[i];
-
-                if (tries[i])
-                        dev->class = classes[i];
+        ata_link_for_each_dev(dev, &ap->link) {
+                if (tries[dev->devno])
+                        dev->class = classes[dev->devno];
 
                 if (!ata_dev_enabled(dev))
                         continue;
@@ -2158,33 +2265,42 @@ int ata_bus_probe(struct ata_port *ap)
         if (ap->ops->cable_detect)
                 ap->cbl = ap->ops->cable_detect(ap);
 
+        /* We may have SATA bridge glue hiding here irrespective of the
+           reported cable types and sensed types */
+        ata_link_for_each_dev(dev, &ap->link) {
+                if (!ata_dev_enabled(dev))
+                        continue;
+                /* SATA drives indicate we have a bridge. We don't know which
+                   end of the link the bridge is which is a problem */
+                if (ata_id_is_sata(dev->id))
+                        ap->cbl = ATA_CBL_SATA;
+        }
+
         /* After the identify sequence we can now set up the devices. We do
            this in the normal order so that the user doesn't get confused */
 
-        for(i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, &ap->link) {
                 if (!ata_dev_enabled(dev))
                         continue;
 
-                ap->eh_context.i.flags |= ATA_EHI_PRINTINFO;
+                ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
                 rc = ata_dev_configure(dev);
-                ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
+                ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
                 if (rc)
                         goto fail;
         }
 
         /* configure transfer mode */
-        rc = ata_set_mode(ap, &dev);
+        rc = ata_set_mode(&ap->link, &dev);
         if (rc)
                 goto fail;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ata_dev_enabled(&ap->device[i]))
+        ata_link_for_each_dev(dev, &ap->link)
+                if (ata_dev_enabled(dev))
                         return 0;
 
         /* no device present, disable port */
         ata_port_disable(ap);
-        ap->ops->port_disable(ap);
         return -ENODEV;
 
  fail:
@@ -2204,7 +2320,7 @@ int ata_bus_probe(struct ata_port *ap)
                         /* This is the last chance, better to slow
                          * down than lose it.
                          */
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(&ap->link);
                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
                 }
         }
@@ -2233,28 +2349,28 @@ void ata_port_probe(struct ata_port *ap)
 
 /**
  *      sata_print_link_status - Print SATA link status
- *      @ap: SATA port to printk link status about
+ *      @link: SATA link to printk link status about
  *
  *      This function prints link speed and status of a SATA link.
  *
  *      LOCKING:
  *      None.
  */
-void sata_print_link_status(struct ata_port *ap)
+void sata_print_link_status(struct ata_link *link)
 {
         u32 sstatus, scontrol, tmp;
 
-        if (sata_scr_read(ap, SCR_STATUS, &sstatus))
+        if (sata_scr_read(link, SCR_STATUS, &sstatus))
                 return;
-        sata_scr_read(ap, SCR_CONTROL, &scontrol);
+        sata_scr_read(link, SCR_CONTROL, &scontrol);
 
-        if (ata_port_online(ap)) {
+        if (ata_link_online(link)) {
                 tmp = (sstatus >> 4) & 0xf;
-                ata_port_printk(ap, KERN_INFO,
+                ata_link_printk(link, KERN_INFO,
                                 "SATA link up %s (SStatus %X SControl %X)\n",
                                 sata_spd_string(tmp), sstatus, scontrol);
         } else {
-                ata_port_printk(ap, KERN_INFO,
+                ata_link_printk(link, KERN_INFO,
                                 "SATA link down (SStatus %X SControl %X)\n",
                                 sstatus, scontrol);
         }
@@ -2274,32 +2390,33 @@ void sata_print_link_status(struct ata_port *ap)
  */
 void __sata_phy_reset(struct ata_port *ap)
 {
-        u32 sstatus;
+        struct ata_link *link = &ap->link;
         unsigned long timeout = jiffies + (HZ * 5);
+        u32 sstatus;
 
         if (ap->flags & ATA_FLAG_SATA_RESET) {
                 /* issue phy wake/reset */
-                sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
+                sata_scr_write_flush(link, SCR_CONTROL, 0x301);
                 /* Couldn't find anything in SATA I/II specs, but
                  * AHCI-1.1 10.4.2 says at least 1 ms. */
                 mdelay(1);
         }
         /* phy wake/clear reset */
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
+        sata_scr_write_flush(link, SCR_CONTROL, 0x300);
 
         /* wait for phy to become ready, if necessary */
         do {
                 msleep(200);
-                sata_scr_read(ap, SCR_STATUS, &sstatus);
+                sata_scr_read(link, SCR_STATUS, &sstatus);
                 if ((sstatus & 0xf) != 1)
                         break;
         } while (time_before(jiffies, timeout));
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* TODO: phy layer with polling, timeouts, etc. */
-        if (!ata_port_offline(ap))
+        if (!ata_link_offline(link))
                 ata_port_probe(ap);
         else
                 ata_port_disable(ap);
@@ -2344,8 +2461,8 @@ void sata_phy_reset(struct ata_port *ap)
 
 struct ata_device *ata_dev_pair(struct ata_device *adev)
 {
-        struct ata_port *ap = adev->ap;
-        struct ata_device *pair = &ap->device[1 - adev->devno];
+        struct ata_link *link = adev->link;
+        struct ata_device *pair = &link->device[1 - adev->devno];
         if (!ata_dev_enabled(pair))
                 return NULL;
         return pair;
@@ -2366,16 +2483,16 @@ struct ata_device *ata_dev_pair(struct ata_device *adev)
 
 void ata_port_disable(struct ata_port *ap)
 {
-        ap->device[0].class = ATA_DEV_NONE;
-        ap->device[1].class = ATA_DEV_NONE;
+        ap->link.device[0].class = ATA_DEV_NONE;
+        ap->link.device[1].class = ATA_DEV_NONE;
         ap->flags |= ATA_FLAG_DISABLED;
 }
 
 /**
  *      sata_down_spd_limit - adjust SATA spd limit downward
- *      @ap: Port to adjust SATA spd limit for
+ *      @link: Link to adjust SATA spd limit for
  *
- *      Adjust SATA spd limit of @ap downward.  Note that this
+ *      Adjust SATA spd limit of @link downward.  Note that this
  *      function only adjusts the limit.  The change must be applied
  *      using sata_set_spd().
  *
@@ -2385,24 +2502,24 @@ void ata_port_disable(struct ata_port *ap)
  *      RETURNS:
  *      0 on success, negative errno on failure
  */
-int sata_down_spd_limit(struct ata_port *ap)
+int sata_down_spd_limit(struct ata_link *link)
 {
         u32 sstatus, spd, mask;
         int rc, highbit;
 
-        if (!sata_scr_valid(ap))
+        if (!sata_scr_valid(link))
                 return -EOPNOTSUPP;
 
         /* If SCR can be read, use it to determine the current SPD.
-         * If not, use cached value in ap->sata_spd.
+         * If not, use cached value in link->sata_spd.
          */
-        rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
+        rc = sata_scr_read(link, SCR_STATUS, &sstatus);
         if (rc == 0)
                 spd = (sstatus >> 4) & 0xf;
         else
-                spd = ap->sata_spd;
+                spd = link->sata_spd;
 
-        mask = ap->sata_spd_limit;
+        mask = link->sata_spd_limit;
         if (mask <= 1)
                 return -EINVAL;
 
@@ -2422,22 +2539,22 @@ int sata_down_spd_limit(struct ata_port *ap)
         if (!mask)
                 return -EINVAL;
 
-        ap->sata_spd_limit = mask;
+        link->sata_spd_limit = mask;
 
-        ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
+        ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
                         sata_spd_string(fls(mask)));
 
         return 0;
 }
 
-static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
+static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
 {
         u32 spd, limit;
 
-        if (ap->sata_spd_limit == UINT_MAX)
+        if (link->sata_spd_limit == UINT_MAX)
                 limit = 0;
         else
-                limit = fls(ap->sata_spd_limit);
+                limit = fls(link->sata_spd_limit);
 
         spd = (*scontrol >> 4) & 0xf;
         *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
@@ -2447,10 +2564,10 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
 
 /**
  *      sata_set_spd_needed - is SATA spd configuration needed
- *      @ap: Port in question
+ *      @link: Link in question
  *
  *      Test whether the spd limit in SControl matches
- *      @ap->sata_spd_limit.  This function is used to determine
+ *      @link->sata_spd_limit.  This function is used to determine
  *      whether hardreset is necessary to apply SATA spd
  *      configuration.
  *
@@ -2460,21 +2577,21 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
  *      RETURNS:
  *      1 if SATA spd configuration is needed, 0 otherwise.
  */
-int sata_set_spd_needed(struct ata_port *ap)
+int sata_set_spd_needed(struct ata_link *link)
 {
         u32 scontrol;
 
-        if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
+        if (sata_scr_read(link, SCR_CONTROL, &scontrol))
                 return 0;
 
-        return __sata_set_spd_needed(ap, &scontrol);
+        return __sata_set_spd_needed(link, &scontrol);
 }
 
 /**
  *      sata_set_spd - set SATA spd according to spd limit
- *      @ap: Port to set SATA spd for
+ *      @link: Link to set SATA spd for
  *
- *      Set SATA spd of @ap according to sata_spd_limit.
+ *      Set SATA spd of @link according to sata_spd_limit.
  *
  *      LOCKING:
  *      Inherited from caller.
@@ -2483,18 +2600,18 @@ int sata_set_spd_needed(struct ata_port *ap)
  *      0 if spd doesn't need to be changed, 1 if spd has been
  *      changed.  Negative errno if SCR registers are inaccessible.
  */
-int sata_set_spd(struct ata_port *ap)
+int sata_set_spd(struct ata_link *link)
 {
         u32 scontrol;
         int rc;
 
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 return rc;
 
-        if (!__sata_set_spd_needed(ap, &scontrol))
+        if (!__sata_set_spd_needed(link, &scontrol))
                 return 0;
 
-        if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                 return rc;
 
         return 1;
@@ -2749,7 +2866,7 @@ int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
 
 static int ata_dev_set_mode(struct ata_device *dev)
 {
-        struct ata_eh_context *ehc = &dev->ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
         unsigned int err_mask;
         int rc;
 
@@ -2761,7 +2878,11 @@ static int ata_dev_set_mode(struct ata_device *dev)
         /* Old CFA may refuse this command, which is just fine */
         if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
                 err_mask &= ~AC_ERR_DEV;
-
+        /* Some very old devices and some bad newer ones fail any kind of
+           SET_XFERMODE request but support PIO0-2 timings and no IORDY */
+        if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) &&
+                        dev->pio_mode <= XFER_PIO_2)
+                err_mask &= ~AC_ERR_DEV;
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
                                "(err_mask=0x%x)\n", err_mask);
@@ -2769,7 +2890,7 @@ static int ata_dev_set_mode(struct ata_device *dev)
         }
 
         ehc->i.flags |= ATA_EHI_POST_SETMODE;
-        rc = ata_dev_revalidate(dev, 0);
+        rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
         ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
         if (rc)
                 return rc;
@@ -2784,7 +2905,7 @@ static int ata_dev_set_mode(struct ata_device *dev)
 
 /**
  *      ata_do_set_mode - Program timings and issue SET FEATURES - XFER
- *      @ap: port on which timings will be programmed
+ *      @link: link on which timings will be programmed
  *      @r_failed_dev: out paramter for failed device
  *
  *      Standard implementation of the function used to tune and set
@@ -2799,25 +2920,36 @@ static int ata_dev_set_mode(struct ata_device *dev)
  *      0 on success, negative errno otherwise
  */
 
-int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
+        struct ata_port *ap = link->ap;
         struct ata_device *dev;
-        int i, rc = 0, used_dma = 0, found = 0;
-
+        int rc = 0, used_dma = 0, found = 0;
 
         /* step 1: calculate xfer_mask */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+        ata_link_for_each_dev(dev, link) {
                 unsigned int pio_mask, dma_mask;
-
-                dev = &ap->device[i];
+                unsigned int mode_mask;
 
                 if (!ata_dev_enabled(dev))
                         continue;
 
+                mode_mask = ATA_DMA_MASK_ATA;
+                if (dev->class == ATA_DEV_ATAPI)
+                        mode_mask = ATA_DMA_MASK_ATAPI;
+                else if (ata_id_is_cfa(dev->id))
+                        mode_mask = ATA_DMA_MASK_CFA;
+
                 ata_dev_xfermask(dev);
 
                 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
                 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+
+                if (libata_dma_mask & mode_mask)
+                        dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+                else
+                        dma_mask = 0;
+
                 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
                 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
 
@@ -2829,8 +2961,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
                 goto out;
 
         /* step 2: always set host PIO timings */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev))
                         continue;
 
@@ -2847,9 +2978,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
         }
 
         /* step 3: set host DMA timings */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev) || !dev->dma_mode)
                         continue;
 
@@ -2860,9 +2989,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
         }
 
         /* step 4: update devices' xfer mode */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 /* don't update suspended devices' xfer mode */
                 if (!ata_dev_enabled(dev))
                         continue;
@@ -2886,7 +3013,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
 
 /**
  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
- *      @ap: port on which timings will be programmed
+ *      @link: link on which timings will be programmed
  *      @r_failed_dev: out paramter for failed device
  *
  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
@@ -2899,12 +3026,14 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
  *      RETURNS:
  *      0 on success, negative errno otherwise
  */
-int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
+        struct ata_port *ap = link->ap;
+
         /* has private set_mode? */
         if (ap->ops->set_mode)
-                return ap->ops->set_mode(ap, r_failed_dev);
-        return ata_do_set_mode(ap, r_failed_dev);
+                return ap->ops->set_mode(link, r_failed_dev);
+        return ata_do_set_mode(link, r_failed_dev);
 }
 
 /**
@@ -3007,7 +3136,7 @@ int ata_wait_ready(struct ata_port *ap, unsigned long deadline)
 
                 if (!(status & ATA_BUSY))
                         return 0;
-                if (!ata_port_online(ap) && status == 0xff)
+                if (!ata_link_online(&ap->link) && status == 0xff)
                         return -ENODEV;
                 if (time_after(now, deadline))
                         return -EBUSY;
@@ -3088,6 +3217,8 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
                              unsigned long deadline)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
+        struct ata_device *dev;
+        int i = 0;
 
         DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
 
@@ -3098,6 +3229,25 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
         udelay(20);     /* FIXME: flush */
         iowrite8(ap->ctl, ioaddr->ctl_addr);
 
+        /* If we issued an SRST then an ATA drive (not ATAPI)
+         * may have changed configuration and be in PIO0 timing. If
+         * we did a hard reset (or are coming from power on) this is
+         * true for ATA or ATAPI. Until we've set a suitable controller
+         * mode we should not touch the bus as we may be talking too fast.
+         */
+
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->pio_mode = XFER_PIO_0;
+
+        /* If the controller has a pio mode setup function then use
+           it to set the chipset to rights. Don't touch the DMA setup
+           as that will be dealt with when revalidating */
+        if (ap->ops->set_piomode) {
+                ata_link_for_each_dev(dev, &ap->link)
+                        if (devmask & (1 << i++))
+                                ap->ops->set_piomode(ap, dev);
+        }
+
         /* spec mandates ">= 2ms" before checking status.
          * We wait 150ms, because that was the magic delay used for
          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
@@ -3142,6 +3292,7 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
 
 void ata_bus_reset(struct ata_port *ap)
 {
+        struct ata_device *device = ap->link.device;
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         u8 err;
@@ -3177,19 +3328,19 @@ void ata_bus_reset(struct ata_port *ap)
         /*
          * determine by signature whether we have ATA or ATAPI devices
          */
-        ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
+        device[0].class = ata_dev_try_classify(&device[0], dev0, &err);
         if ((slave_possible) && (err != 0x81))
-                ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
+                device[1].class = ata_dev_try_classify(&device[1], dev1, &err);
 
         /* is double-select really necessary? */
-        if (ap->device[1].class != ATA_DEV_NONE)
+        if (device[1].class != ATA_DEV_NONE)
                 ap->ops->dev_select(ap, 1);
-        if (ap->device[0].class != ATA_DEV_NONE)
+        if (device[0].class != ATA_DEV_NONE)
                 ap->ops->dev_select(ap, 0);
 
         /* if no devices were detected, disable this port */
-        if ((ap->device[0].class == ATA_DEV_NONE) &&
-            (ap->device[1].class == ATA_DEV_NONE))
+        if ((device[0].class == ATA_DEV_NONE) &&
+            (device[1].class == ATA_DEV_NONE))
                 goto err_out;
 
         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
@@ -3202,18 +3353,18 @@ void ata_bus_reset(struct ata_port *ap)
 
 err_out:
         ata_port_printk(ap, KERN_ERR, "disabling port\n");
-        ap->ops->port_disable(ap);
+        ata_port_disable(ap);
 
         DPRINTK("EXIT\n");
 }
 
 /**
- *      sata_phy_debounce - debounce SATA phy status
- *      @ap: ATA port to debounce SATA phy status for
+ *      sata_link_debounce - debounce SATA phy status
+ *      @link: ATA link to debounce SATA phy status for
  *      @params: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      Make sure SStatus of @ap reaches stable state, determined by
+*       Make sure SStatus of @link reaches stable state, determined by
  *      holding the same value where DET is not 1 for @duration polled
  *      every @interval, before @timeout.  Timeout constraints the
  *      beginning of the stable state.  Because DET gets stuck at 1 on
@@ -3229,8 +3380,8 @@ err_out:
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
-                      unsigned long deadline)
+int sata_link_debounce(struct ata_link *link, const unsigned long *params,
+                       unsigned long deadline)
 {
         unsigned long interval_msec = params[0];
         unsigned long duration = msecs_to_jiffies(params[1]);
@@ -3242,7 +3393,7 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
         if (time_before(t, deadline))
                 deadline = t;
 
-        if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+        if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                 return rc;
         cur &= 0xf;
 
@@ -3251,7 +3402,7 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
 
         while (1) {
                 msleep(interval_msec);
-                if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+                if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                         return rc;
                 cur &= 0xf;
 
@@ -3277,12 +3428,12 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
 }
 
 /**
- *      sata_phy_resume - resume SATA phy
- *      @ap: ATA port to resume SATA phy for
+ *      sata_link_resume - resume SATA link
+ *      @link: ATA link to resume SATA
  *      @params: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      Resume SATA phy of @ap and debounce it.
+ *      Resume SATA phy @link and debounce it.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -3290,18 +3441,18 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
-                    unsigned long deadline)
+int sata_link_resume(struct ata_link *link, const unsigned long *params,
+                     unsigned long deadline)
 {
         u32 scontrol;
         int rc;
 
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 return rc;
 
         scontrol = (scontrol & 0x0f0) | 0x300;
 
-        if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                 return rc;
 
         /* Some PHYs react badly if SStatus is pounded immediately
@@ -3309,15 +3460,15 @@ int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
          */
         msleep(200);
 
-        return sata_phy_debounce(ap, params, deadline);
+        return sata_link_debounce(link, params, deadline);
 }
 
 /**
  *      ata_std_prereset - prepare for reset
- *      @ap: ATA port to be reset
+ *      @link: ATA link to be reset
  *      @deadline: deadline jiffies for the operation
  *
- *      @ap is about to be reset.  Initialize it.  Failure from
+ *      @link is about to be reset.  Initialize it.  Failure from
  *      prereset makes libata abort whole reset sequence and give up
  *      that port, so prereset should be best-effort.  It does its
  *      best to prepare for reset sequence but if things go wrong, it
@@ -3329,37 +3480,44 @@ int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
+int ata_std_prereset(struct ata_link *link, unsigned long deadline)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         const unsigned long *timing = sata_ehc_deb_timing(ehc);
         int rc;
 
         /* handle link resume */
         if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
-            (ap->flags & ATA_FLAG_HRST_TO_RESUME))
+            (link->flags & ATA_LFLAG_HRST_TO_RESUME))
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* Some PMPs don't work with only SRST, force hardreset if PMP
+         * is supported.
+         */
+        if (ap->flags & ATA_FLAG_PMP)
                 ehc->i.action |= ATA_EH_HARDRESET;
 
         /* if we're about to do hardreset, nothing more to do */
         if (ehc->i.action & ATA_EH_HARDRESET)
                 return 0;
 
-        /* if SATA, resume phy */
+        /* if SATA, resume link */
         if (ap->flags & ATA_FLAG_SATA) {
-                rc = sata_phy_resume(ap, timing, deadline);
+                rc = sata_link_resume(link, timing, deadline);
                 /* whine about phy resume failure but proceed */
                 if (rc && rc != -EOPNOTSUPP)
-                        ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                        ata_link_printk(link, KERN_WARNING, "failed to resume "
                                         "link for reset (errno=%d)\n", rc);
         }
 
         /* Wait for !BSY if the controller can wait for the first D2H
          * Reg FIS and we don't know that no device is attached.
          */
-        if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap)) {
+        if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) {
                 rc = ata_wait_ready(ap, deadline);
                 if (rc && rc != -ENODEV) {
-                        ata_port_printk(ap, KERN_WARNING, "device not ready "
+                        ata_link_printk(link, KERN_WARNING, "device not ready "
                                         "(errno=%d), forcing hardreset\n", rc);
                         ehc->i.action |= ATA_EH_HARDRESET;
                 }
@@ -3370,7 +3528,7 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
 
 /**
  *      ata_std_softreset - reset host port via ATA SRST
- *      @ap: port to reset
+ *      @link: ATA link to reset
  *      @classes: resulting classes of attached devices
  *      @deadline: deadline jiffies for the operation
  *
@@ -3382,9 +3540,10 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
+int ata_std_softreset(struct ata_link *link, unsigned int *classes,
                       unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         unsigned int devmask = 0;
         int rc;
@@ -3392,7 +3551,7 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 classes[0] = ATA_DEV_NONE;
                 goto out;
         }
@@ -3410,15 +3569,17 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
         DPRINTK("about to softreset, devmask=%x\n", devmask);
         rc = ata_bus_softreset(ap, devmask, deadline);
         /* if link is occupied, -ENODEV too is an error */
-        if (rc && (rc != -ENODEV || sata_scr_valid(ap))) {
-                ata_port_printk(ap, KERN_ERR, "SRST failed (errno=%d)\n", rc);
+        if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
+                ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
                 return rc;
         }
 
         /* determine by signature whether we have ATA or ATAPI devices */
-        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        classes[0] = ata_dev_try_classify(&link->device[0],
+                                          devmask & (1 << 0), &err);
         if (slave_possible && err != 0x81)
-                classes[1] = ata_dev_try_classify(ap, 1, &err);
+                classes[1] = ata_dev_try_classify(&link->device[1],
+                                                  devmask & (1 << 1), &err);
 
  out:
         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
@@ -3426,12 +3587,12 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
 }
 
 /**
- *      sata_port_hardreset - reset port via SATA phy reset
- *      @ap: port to reset
+ *      sata_link_hardreset - reset link via SATA phy reset
+ *      @link: link to reset
  *      @timing: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      SATA phy-reset host port using DET bits of SControl register.
+ *      SATA phy-reset @link using DET bits of SControl register.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -3439,7 +3600,7 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
+int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
                         unsigned long deadline)
 {
         u32 scontrol;
@@ -3447,30 +3608,30 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
 
         DPRINTK("ENTER\n");
 
-        if (sata_set_spd_needed(ap)) {
+        if (sata_set_spd_needed(link)) {
                 /* SATA spec says nothing about how to reconfigure
                  * spd.  To be on the safe side, turn off phy during
                  * reconfiguration.  This works for at least ICH7 AHCI
                  * and Sil3124.
                  */
-                if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+                if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                         goto out;
 
                 scontrol = (scontrol & 0x0f0) | 0x304;
 
-                if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+                if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                         goto out;
 
-                sata_set_spd(ap);
+                sata_set_spd(link);
         }
 
         /* issue phy wake/reset */
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 goto out;
 
         scontrol = (scontrol & 0x0f0) | 0x301;
 
-        if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
                 goto out;
 
         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
@@ -3478,8 +3639,8 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
          */
         msleep(1);
 
-        /* bring phy back */
-        rc = sata_phy_resume(ap, timing, deadline);
+        /* bring link back */
+        rc = sata_link_resume(link, timing, deadline);
  out:
         DPRINTK("EXIT, rc=%d\n", rc);
         return rc;
@@ -3487,7 +3648,7 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
 
 /**
  *      sata_std_hardreset - reset host port via SATA phy reset
- *      @ap: port to reset
+ *      @link: link to reset
  *      @class: resulting class of attached device
  *      @deadline: deadline jiffies for the operation
  *
@@ -3500,24 +3661,25 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
+int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                        unsigned long deadline)
 {
-        const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
+        struct ata_port *ap = link->ap;
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
         int rc;
 
         DPRINTK("ENTER\n");
 
         /* do hardreset */
-        rc = sata_port_hardreset(ap, timing, deadline);
+        rc = sata_link_hardreset(link, timing, deadline);
         if (rc) {
-                ata_port_printk(ap, KERN_ERR,
+                ata_link_printk(link, KERN_ERR,
                                 "COMRESET failed (errno=%d)\n", rc);
                 return rc;
         }
 
         /* TODO: phy layer with polling, timeouts, etc. */
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 *class = ATA_DEV_NONE;
                 DPRINTK("EXIT, link offline\n");
                 return 0;
@@ -3526,17 +3688,27 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
         /* wait a while before checking status, see SRST for more info */
         msleep(150);
 
+        /* If PMP is supported, we have to do follow-up SRST.  Note
+         * that some PMPs don't send D2H Reg FIS after hardreset at
+         * all if the first port is empty.  Wait for it just for a
+         * second and request follow-up SRST.
+         */
+        if (ap->flags & ATA_FLAG_PMP) {
+                ata_wait_ready(ap, jiffies + HZ);
+                return -EAGAIN;
+        }
+
         rc = ata_wait_ready(ap, deadline);
         /* link occupied, -ENODEV too is an error */
         if (rc) {
-                ata_port_printk(ap, KERN_ERR,
+                ata_link_printk(link, KERN_ERR,
                                 "COMRESET failed (errno=%d)\n", rc);
                 return rc;
         }
 
         ap->ops->dev_select(ap, 0);     /* probably unnecessary */
 
-        *class = ata_dev_try_classify(ap, 0, NULL);
+        *class = ata_dev_try_classify(link->device, 1, NULL);
 
         DPRINTK("EXIT, class=%u\n", *class);
         return 0;
@@ -3544,7 +3716,7 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
 
 /**
  *      ata_std_postreset - standard postreset callback
- *      @ap: the target ata_port
+ *      @link: the target ata_link
  *      @classes: classes of attached devices
  *
  *      This function is invoked after a successful reset.  Note that
@@ -3554,18 +3726,19 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
  *      LOCKING:
  *      Kernel thread context (may sleep)
  */
-void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
+void ata_std_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
         u32 serror;
 
         DPRINTK("ENTER\n");
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* clear SError */
-        if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
-                sata_scr_write(ap, SCR_ERROR, serror);
+        if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
+                sata_scr_write(link, SCR_ERROR, serror);
 
         /* is double-select really necessary? */
         if (classes[0] != ATA_DEV_NONE)
@@ -3652,7 +3825,7 @@ static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
 int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
 {
         unsigned int class = dev->class;
-        u16 *id = (void *)dev->ap->sector_buf;
+        u16 *id = (void *)dev->link->ap->sector_buf;
         int rc;
 
         /* read ID data */
@@ -3671,6 +3844,7 @@ int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
 /**
  *      ata_dev_revalidate - Revalidate ATA device
  *      @dev: device to revalidate
+ *      @new_class: new class code
  *      @readid_flags: read ID flags
  *
  *      Re-read IDENTIFY page, make sure @dev is still attached to the
@@ -3682,7 +3856,8 @@ int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
  *      RETURNS:
  *      0 on success, negative errno otherwise
  */
-int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags)
+int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
+                       unsigned int readid_flags)
 {
         u64 n_sectors = dev->n_sectors;
         int rc;
@@ -3690,6 +3865,15 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags)
         if (!ata_dev_enabled(dev))
                 return -ENODEV;
 
+        /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
+        if (ata_class_enabled(new_class) &&
+            new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) {
+                ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n",
+                               dev->class, new_class);
+                rc = -ENODEV;
+                goto fail;
+        }
+
         /* re-read ID */
         rc = ata_dev_reread_id(dev, readid_flags);
         if (rc)
@@ -3763,6 +3947,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "IOMEGA  ZIP 250       ATAPI", NULL,  ATA_HORKAGE_NODMA }, /* temporary fix */
         { "IOMEGA  ZIP 250       ATAPI       Floppy",
                                 NULL,           ATA_HORKAGE_NODMA },
+        /* Odd clown on sil3726/4726 PMPs */
+        { "Config  Disk",       NULL,           ATA_HORKAGE_NODMA |
+                                                ATA_HORKAGE_SKIP_PM },
 
         /* Weird ATAPI devices */
         { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 },
@@ -3775,16 +3962,12 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         /* http://thread.gmane.org/gmane.linux.ide/14907 */
         { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
         /* NCQ is broken */
-        { "Maxtor 6L250S0",     "BANC1G10",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 6B200M0",     "BANC1BM0",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 6B200M0",     "BANC1B10",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 7B250S0",     "BANC1B70",     ATA_HORKAGE_NONCQ, },
-        { "Maxtor 7B300S0",     "BANC1B70",     ATA_HORKAGE_NONCQ },
+        { "Maxtor *",           "BANC*",        ATA_HORKAGE_NONCQ },
         { "Maxtor 7V300F0",     "VA111630",     ATA_HORKAGE_NONCQ },
-        { "HITACHI HDS7250SASUN500G 0621KTAWSD", "K2AOAJ0AHITACHI",
-         ATA_HORKAGE_NONCQ },
-        /* NCQ hard hangs device under heavier load, needs hard power cycle */
-        { "Maxtor 6B250S0",     "BANC1B70",     ATA_HORKAGE_NONCQ },
+        { "HITACHI HDS7250SASUN500G*", NULL,    ATA_HORKAGE_NONCQ },
+        { "HITACHI HDS7225SBSUN250G*", NULL,    ATA_HORKAGE_NONCQ },
+        { "ST380817AS",         "3.42",         ATA_HORKAGE_NONCQ },
+
         /* Blacklist entries taken from Silicon Image 3124/3132
            Windows driver .inf file - also several Linux problem reports */
         { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
@@ -3793,11 +3976,16 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         /* Drives which do spurious command completion */
         { "HTS541680J9SA00",    "SB2IC7EP",     ATA_HORKAGE_NONCQ, },
         { "HTS541612J9SA00",    "SBDIC7JP",     ATA_HORKAGE_NONCQ, },
+        { "HDT722516DLA380",    "V43OA96A",     ATA_HORKAGE_NONCQ, },
         { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, },
         { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
+        { "WDC WD3200AAJS-00RYA0", "12.01B01",  ATA_HORKAGE_NONCQ, },
         { "FUJITSU MHV2080BH",  "00840028",     ATA_HORKAGE_NONCQ, },
+        { "ST9120822AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
         { "ST9160821AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
-        { "ST3160812AS",        "3.AD",         ATA_HORKAGE_NONCQ, },
+        { "ST9160821AS",        "3.ALD",        ATA_HORKAGE_NONCQ, },
+        { "ST3160812AS",        "3.ADJ",        ATA_HORKAGE_NONCQ, },
+        { "ST980813AS",         "3.ADB",        ATA_HORKAGE_NONCQ, },
         { "SAMSUNG HD401LJ",    "ZZ100-15",     ATA_HORKAGE_NONCQ, },
 
         /* devices which puke on READ_NATIVE_MAX */
@@ -3806,10 +3994,31 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
         { "MAXTOR 6L080L4",     "A93.0500",     ATA_HORKAGE_BROKEN_HPA },
 
+        /* Devices which report 1 sector over size HPA */
+        { "ST340823A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
+        { "ST320413A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
+
         /* End Marker */
         { }
 };
 
+int strn_pattern_cmp(const char *patt, const char *name, int wildchar)
+{
+        const char *p;
+        int len;
+
+        /*
+         * check for trailing wildcard: *\0
+         */
+        p = strchr(patt, wildchar);
+        if (p && ((*(p + 1)) == 0))
+                len = p - patt;
+        else
+                len = strlen(name);
+
+        return strncmp(patt, name, len);
+}
+
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
 {
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
@@ -3820,10 +4029,10 @@ static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
         ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
 
         while (ad->model_num) {
-                if (!strcmp(ad->model_num, model_num)) {
+                if (!strn_pattern_cmp(ad->model_num, model_num, '*')) {
                         if (ad->model_rev == NULL)
                                 return ad->horkage;
-                        if (!strcmp(ad->model_rev, model_rev))
+                        if (!strn_pattern_cmp(ad->model_rev, model_rev, '*'))
                                 return ad->horkage;
                 }
                 ad++;
@@ -3837,7 +4046,7 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
          * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
          * if the LLDD handles only interrupts in the HSM_ST_LAST state.
          */
-        if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) &&
+        if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
             (dev->flags & ATA_DFLAG_CDB_INTR))
                 return 1;
         return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
@@ -3857,7 +4066,8 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
  */
 static void ata_dev_xfermask(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         struct ata_host *host = ap->host;
         unsigned long xfer_mask;
 
@@ -3955,7 +4165,43 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
         tf.protocol = ATA_PROT_NODATA;
         tf.nsect = dev->xfer_mode;
 
-        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+
+        DPRINTK("EXIT, err_mask=%x\n", err_mask);
+        return err_mask;
+}
+
+/**
+ *      ata_dev_set_AN - Issue SET FEATURES - SATA FEATURES
+ *      @dev: Device to which command will be sent
+ *      @enable: Whether to enable or disable the feature
+ *
+ *      Issue SET FEATURES - SATA FEATURES command to device @dev
+ *      on port @ap with sector count set to indicate Asynchronous
+ *      Notification feature
+ *
+ *      LOCKING:
+ *      PCI/etc. bus probe sem.
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask otherwise.
+ */
+static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable)
+{
+        struct ata_taskfile tf;
+        unsigned int err_mask;
+
+        /* set up set-features taskfile */
+        DPRINTK("set features - SATA features\n");
+
+        ata_tf_init(dev, &tf);
+        tf.command = ATA_CMD_SET_FEATURES;
+        tf.feature = enable;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.nsect = SATA_AN;
+
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 
         DPRINTK("EXIT, err_mask=%x\n", err_mask);
         return err_mask;
@@ -3993,7 +4239,7 @@ static unsigned int ata_dev_init_params(struct ata_device *dev,
         tf.nsect = sectors;
         tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
 
-        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
         /* A clean abort indicates an original or just out of spec drive
            and we should continue as we issue the setup based on the
            drive reported working geometry */
@@ -4207,6 +4453,36 @@ int ata_check_atapi_dma(struct ata_queued_cmd *qc)
 }
 
 /**
+ *      ata_std_qc_defer - Check whether a qc needs to be deferred
+ *      @qc: ATA command in question
+ *
+ *      Non-NCQ commands cannot run with any other command, NCQ or
+ *      not.  As upper layer only knows the queue depth, we are
+ *      responsible for maintaining exclusion.  This function checks
+ *      whether a new command @qc can be issued.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      ATA_DEFER_* if deferring is needed, 0 otherwise.
+ */
+int ata_std_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+
+        if (qc->tf.protocol == ATA_PROT_NCQ) {
+                if (!ata_tag_valid(link->active_tag))
+                        return 0;
+        } else {
+                if (!ata_tag_valid(link->active_tag) && !link->sactive)
+                        return 0;
+        }
+
+        return ATA_DEFER_LINK;
+}
+
+/**
  *      ata_qc_prep - Prepare taskfile for submission
  *      @qc: Metadata associated with taskfile to be prepared
  *
@@ -4482,7 +4758,7 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words)
 void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
                    unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         unsigned int words = buflen >> 1;
 
         /* Transfer multiple of 2 bytes */
@@ -4611,6 +4887,8 @@ static void ata_pio_sectors(struct ata_queued_cmd *qc)
                         ata_pio_sector(qc);
         } else
                 ata_pio_sector(qc);
+
+        ata_altstatus(qc->ap); /* flush */
 }
 
 /**
@@ -4785,6 +5063,7 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
         VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
 
         __atapi_pio_bytes(qc, bytes);
+        ata_altstatus(ap); /* flush */
 
         return;
 
@@ -4956,7 +5235,6 @@ fsm_start:
                          */
                         ap->hsm_task_state = HSM_ST;
                         ata_pio_sectors(qc);
-                        ata_altstatus(ap); /* flush */
                 } else
                         /* send CDB */
                         atapi_send_cdb(ap, qc);
@@ -5037,7 +5315,6 @@ fsm_start:
 
                                 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
                                         ata_pio_sectors(qc);
-                                        ata_altstatus(ap);
                                         status = ata_wait_idle(ap);
                                 }
 
@@ -5057,13 +5334,11 @@ fsm_start:
                         if (ap->hsm_task_state == HSM_ST_LAST &&
                             (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
                                 /* all data read */
-                                ata_altstatus(ap);
                                 status = ata_wait_idle(ap);
                                 goto fsm_start;
                         }
                 }
 
-                ata_altstatus(ap); /* flush */
                 poll_next = 1;
                 break;
 
@@ -5188,7 +5463,7 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
 
 struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_queued_cmd *qc;
 
         qc = ata_qc_new(ap);
@@ -5231,6 +5506,7 @@ void ata_qc_free(struct ata_queued_cmd *qc)
 void __ata_qc_complete(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        struct ata_link *link = qc->dev->link;
 
         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
@@ -5239,10 +5515,19 @@ void __ata_qc_complete(struct ata_queued_cmd *qc)
                 ata_sg_clean(qc);
 
         /* command should be marked inactive atomically with qc completion */
-        if (qc->tf.protocol == ATA_PROT_NCQ)
-                ap->sactive &= ~(1 << qc->tag);
-        else
-                ap->active_tag = ATA_TAG_POISON;
+        if (qc->tf.protocol == ATA_PROT_NCQ) {
+                link->sactive &= ~(1 << qc->tag);
+                if (!link->sactive)
+                        ap->nr_active_links--;
+        } else {
+                link->active_tag = ATA_TAG_POISON;
+                ap->nr_active_links--;
+        }
+
+        /* clear exclusive status */
+        if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
+                     ap->excl_link == link))
+                ap->excl_link = NULL;
 
         /* atapi: mark qc as inactive to prevent the interrupt handler
          * from completing the command twice later, before the error handler
@@ -5411,19 +5696,25 @@ static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
 void ata_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        struct ata_link *link = qc->dev->link;
 
         /* Make sure only one non-NCQ command is outstanding.  The
          * check is skipped for old EH because it reuses active qc to
          * request ATAPI sense.
          */
-        WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
+        WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));
 
         if (qc->tf.protocol == ATA_PROT_NCQ) {
-                WARN_ON(ap->sactive & (1 << qc->tag));
-                ap->sactive |= 1 << qc->tag;
+                WARN_ON(link->sactive & (1 << qc->tag));
+
+                if (!link->sactive)
+                        ap->nr_active_links++;
+                link->sactive |= 1 << qc->tag;
         } else {
-                WARN_ON(ap->sactive);
-                ap->active_tag = qc->tag;
+                WARN_ON(link->sactive);
+
+                ap->nr_active_links++;
+                link->active_tag = qc->tag;
         }
 
         qc->flags |= ATA_QCFLAG_ACTIVE;
@@ -5606,7 +5897,7 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
 inline unsigned int ata_host_intr (struct ata_port *ap,
                                    struct ata_queued_cmd *qc)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         u8 status, host_stat = 0;
 
         VPRINTK("ata%u: protocol %d task_state %d\n",
@@ -5680,7 +5971,8 @@ idle_irq:
 
 #ifdef ATA_IRQ_TRAP
         if ((ap->stats.idle_irq % 1000) == 0) {
-                ap->ops->irq_ack(ap, 0); /* debug trap */
+                ata_chk_status(ap);
+                ap->ops->irq_clear(ap);
                 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
                 return 1;
         }
@@ -5721,7 +6013,7 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
                             (qc->flags & ATA_QCFLAG_ACTIVE))
                                 handled |= ata_host_intr(ap, qc);
@@ -5735,9 +6027,9 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
 
 /**
  *      sata_scr_valid - test whether SCRs are accessible
- *      @ap: ATA port to test SCR accessibility for
+ *      @link: ATA link to test SCR accessibility for
  *
- *      Test whether SCRs are accessible for @ap.
+ *      Test whether SCRs are accessible for @link.
  *
  *      LOCKING:
  *      None.
@@ -5745,60 +6037,74 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
  *      RETURNS:
  *      1 if SCRs are accessible, 0 otherwise.
  */
-int sata_scr_valid(struct ata_port *ap)
+int sata_scr_valid(struct ata_link *link)
 {
+        struct ata_port *ap = link->ap;
+
         return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
 }
 
 /**
  *      sata_scr_read - read SCR register of the specified port
- *      @ap: ATA port to read SCR for
+ *      @link: ATA link to read SCR for
  *      @reg: SCR to read
  *      @val: Place to store read value
  *
- *      Read SCR register @reg of @ap into *@val.  This function is
- *      guaranteed to succeed if the cable type of the port is SATA
- *      and the port implements ->scr_read.
+ *      Read SCR register @reg of @link into *@val.  This function is
+ *      guaranteed to succeed if @link is ap->link, the cable type of
+ *      the port is SATA and the port implements ->scr_read.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
+int sata_scr_read(struct ata_link *link, int reg, u32 *val)
 {
-        if (sata_scr_valid(ap))
-                return ap->ops->scr_read(ap, reg, val);
-        return -EOPNOTSUPP;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+
+                if (sata_scr_valid(link))
+                        return ap->ops->scr_read(ap, reg, val);
+                return -EOPNOTSUPP;
+        }
+
+        return sata_pmp_scr_read(link, reg, val);
 }
 
 /**
  *      sata_scr_write - write SCR register of the specified port
- *      @ap: ATA port to write SCR for
+ *      @link: ATA link to write SCR for
  *      @reg: SCR to write
  *      @val: value to write
  *
- *      Write @val to SCR register @reg of @ap.  This function is
- *      guaranteed to succeed if the cable type of the port is SATA
- *      and the port implements ->scr_read.
+ *      Write @val to SCR register @reg of @link.  This function is
+ *      guaranteed to succeed if @link is ap->link, the cable type of
+ *      the port is SATA and the port implements ->scr_read.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_write(struct ata_port *ap, int reg, u32 val)
+int sata_scr_write(struct ata_link *link, int reg, u32 val)
 {
-        if (sata_scr_valid(ap))
-                return ap->ops->scr_write(ap, reg, val);
-        return -EOPNOTSUPP;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+
+                if (sata_scr_valid(link))
+                        return ap->ops->scr_write(ap, reg, val);
+                return -EOPNOTSUPP;
+        }
+
+        return sata_pmp_scr_write(link, reg, val);
 }
 
 /**
  *      sata_scr_write_flush - write SCR register of the specified port and flush
- *      @ap: ATA port to write SCR for
+ *      @link: ATA link to write SCR for
  *      @reg: SCR to write
  *      @val: value to write
  *
@@ -5806,31 +6112,36 @@ int sata_scr_write(struct ata_port *ap, int reg, u32 val)
  *      function performs flush after writing to the register.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
+int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
 {
-        int rc;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+                int rc;
 
-        if (sata_scr_valid(ap)) {
-                rc = ap->ops->scr_write(ap, reg, val);
-                if (rc == 0)
-                        rc = ap->ops->scr_read(ap, reg, &val);
-                return rc;
+                if (sata_scr_valid(link)) {
+                        rc = ap->ops->scr_write(ap, reg, val);
+                        if (rc == 0)
+                                rc = ap->ops->scr_read(ap, reg, &val);
+                        return rc;
+                }
+                return -EOPNOTSUPP;
         }
-        return -EOPNOTSUPP;
+
+        return sata_pmp_scr_write(link, reg, val);
 }
 
 /**
- *      ata_port_online - test whether the given port is online
- *      @ap: ATA port to test
+ *      ata_link_online - test whether the given link is online
+ *      @link: ATA link to test
  *
- *      Test whether @ap is online.  Note that this function returns 0
- *      if online status of @ap cannot be obtained, so
- *      ata_port_online(ap) != !ata_port_offline(ap).
+ *      Test whether @link is online.  Note that this function returns
+ *      0 if online status of @link cannot be obtained, so
+ *      ata_link_online(link) != !ata_link_offline(link).
  *
  *      LOCKING:
  *      None.
@@ -5838,22 +6149,23 @@ int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
  *      RETURNS:
  *      1 if the port online status is available and online.
  */
-int ata_port_online(struct ata_port *ap)
+int ata_link_online(struct ata_link *link)
 {
         u32 sstatus;
 
-        if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
+        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
+            (sstatus & 0xf) == 0x3)
                 return 1;
         return 0;
 }
 
 /**
- *      ata_port_offline - test whether the given port is offline
- *      @ap: ATA port to test
+ *      ata_link_offline - test whether the given link is offline
+ *      @link: ATA link to test
  *
- *      Test whether @ap is offline.  Note that this function returns
- *      0 if offline status of @ap cannot be obtained, so
- *      ata_port_online(ap) != !ata_port_offline(ap).
+ *      Test whether @link is offline.  Note that this function
+ *      returns 0 if offline status of @link cannot be obtained, so
+ *      ata_link_online(link) != !ata_link_offline(link).
  *
  *      LOCKING:
  *      None.
@@ -5861,11 +6173,12 @@ int ata_port_online(struct ata_port *ap)
  *      RETURNS:
  *      1 if the port offline status is available and offline.
  */
-int ata_port_offline(struct ata_port *ap)
+int ata_link_offline(struct ata_link *link)
 {
         u32 sstatus;
 
-        if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
+        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
+            (sstatus & 0xf) != 0x3)
                 return 1;
         return 0;
 }
@@ -5883,6 +6196,10 @@ int ata_flush_cache(struct ata_device *dev)
         else
                 cmd = ATA_CMD_FLUSH;
 
+        /* This is wrong. On a failed flush we get back the LBA of the lost
+           sector and we should (assuming it wasn't aborted as unknown) issue
+           a further flush command to continue the writeback until it 
+           does not error */
         err_mask = ata_do_simple_cmd(dev, cmd);
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
@@ -5902,6 +6219,7 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
 
         for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap = host->ports[i];
+                struct ata_link *link;
 
                 /* Previous resume operation might still be in
                  * progress.  Wait for PM_PENDING to clear.
@@ -5921,8 +6239,10 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
                 }
 
                 ap->pflags |= ATA_PFLAG_PM_PENDING;
-                ap->eh_info.action |= action;
-                ap->eh_info.flags |= ehi_flags;
+                __ata_port_for_each_link(link, ap) {
+                        link->eh_info.action |= action;
+                        link->eh_info.flags |= ehi_flags;
+                }
 
                 ata_port_schedule_eh(ap);
 
@@ -6026,12 +6346,13 @@ int ata_port_start(struct ata_port *ap)
  */
 void ata_dev_init(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         unsigned long flags;
 
         /* SATA spd limit is bound to the first device */
-        ap->sata_spd_limit = ap->hw_sata_spd_limit;
-        ap->sata_spd = 0;
+        link->sata_spd_limit = link->hw_sata_spd_limit;
+        link->sata_spd = 0;
 
         /* High bits of dev->flags are used to record warm plug
          * requests which occur asynchronously.  Synchronize using
@@ -6050,6 +6371,70 @@ void ata_dev_init(struct ata_device *dev)
 }
 
 /**
+ *      ata_link_init - Initialize an ata_link structure
+ *      @ap: ATA port link is attached to
+ *      @link: Link structure to initialize
+ *      @pmp: Port multiplier port number
+ *
+ *      Initialize @link.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ */
+void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
+{
+        int i;
+
+        /* clear everything except for devices */
+        memset(link, 0, offsetof(struct ata_link, device[0]));
+
+        link->ap = ap;
+        link->pmp = pmp;
+        link->active_tag = ATA_TAG_POISON;
+        link->hw_sata_spd_limit = UINT_MAX;
+
+        /* can't use iterator, ap isn't initialized yet */
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &link->device[i];
+
+                dev->link = link;
+                dev->devno = dev - link->device;
+                ata_dev_init(dev);
+        }
+}
+
+/**
+ *      sata_link_init_spd - Initialize link->sata_spd_limit
+ *      @link: Link to configure sata_spd_limit for
+ *
+ *      Initialize @link->[hw_]sata_spd_limit to the currently
+ *      configured value.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_link_init_spd(struct ata_link *link)
+{
+        u32 scontrol, spd;
+        int rc;
+
+        rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
+        if (rc)
+                return rc;
+
+        spd = (scontrol >> 4) & 0xf;
+        if (spd)
+                link->hw_sata_spd_limit &= (1 << spd) - 1;
+
+        link->sata_spd_limit = link->hw_sata_spd_limit;
+
+        return 0;
+}
+
+/**
  *      ata_port_alloc - allocate and initialize basic ATA port resources
  *      @host: ATA host this allocated port belongs to
  *
@@ -6064,7 +6449,6 @@ void ata_dev_init(struct ata_device *dev)
 struct ata_port *ata_port_alloc(struct ata_host *host)
 {
         struct ata_port *ap;
-        unsigned int i;
 
         DPRINTK("ENTER\n");
 
@@ -6079,9 +6463,6 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
         ap->ctl = ATA_DEVCTL_OBS;
         ap->host = host;
         ap->dev = host->dev;
-
-        ap->hw_sata_spd_limit = UINT_MAX;
-        ap->active_tag = ATA_TAG_POISON;
         ap->last_ctl = 0xFF;
 
 #if defined(ATA_VERBOSE_DEBUG)
@@ -6104,12 +6485,7 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
 
         ap->cbl = ATA_CBL_NONE;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                dev->ap = ap;
-                dev->devno = i;
-                ata_dev_init(dev);
-        }
+        ata_link_init(ap, &ap->link, 0);
 
 #ifdef ATA_IRQ_TRAP
         ap->stats.unhandled_irq = 1;
@@ -6145,6 +6521,7 @@ static void ata_host_release(struct device *gendev, void *res)
                 if (ap->scsi_host)
                         scsi_host_put(ap->scsi_host);
 
+                kfree(ap->pmp_link);
                 kfree(ap);
                 host->ports[i] = NULL;
         }
@@ -6255,6 +6632,7 @@ struct ata_host *ata_host_alloc_pinfo(struct device *dev,
                 ap->mwdma_mask = pi->mwdma_mask;
                 ap->udma_mask = pi->udma_mask;
                 ap->flags |= pi->flags;
+                ap->link.flags |= pi->link_flags;
                 ap->ops = pi->port_ops;
 
                 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
@@ -6390,8 +6768,6 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
         /* set cable, sata_spd_limit and report */
         for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap = host->ports[i];
-                int irq_line;
-                u32 scontrol;
                 unsigned long xfer_mask;
 
                 /* set SATA cable type if still unset */
@@ -6399,32 +6775,20 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                         ap->cbl = ATA_CBL_SATA;
 
                 /* init sata_spd_limit to the current value */
-                if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
-                        int spd = (scontrol >> 4) & 0xf;
-                        if (spd)
-                                ap->hw_sata_spd_limit &= (1 << spd) - 1;
-                }
-                ap->sata_spd_limit = ap->hw_sata_spd_limit;
-
-                /* report the secondary IRQ for second channel legacy */
-                irq_line = host->irq;
-                if (i == 1 && host->irq2)
-                        irq_line = host->irq2;
+                sata_link_init_spd(&ap->link);
 
+                /* print per-port info to dmesg */
                 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
                                               ap->udma_mask);
 
-                /* print per-port info to dmesg */
-                if (!ata_port_is_dummy(ap))
-                        ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%p "
-                                        "ctl 0x%p bmdma 0x%p irq %d\n",
+                if (!ata_port_is_dummy(ap)) {
+                        ata_port_printk(ap, KERN_INFO,
+                                        "%cATA max %s %s\n",
                                         (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
                                         ata_mode_string(xfer_mask),
-                                        ap->ioaddr.cmd_addr,
-                                        ap->ioaddr.ctl_addr,
-                                        ap->ioaddr.bmdma_addr,
-                                        irq_line);
-                else
+                                        ap->link.eh_info.desc);
+                        ata_ehi_clear_desc(&ap->link.eh_info);
+                } else
                         ata_port_printk(ap, KERN_INFO, "DUMMY\n");
         }
 
@@ -6436,7 +6800,7 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
 
                 /* probe */
                 if (ap->ops->error_handler) {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         unsigned long flags;
 
                         ata_port_probe(ap);
@@ -6444,7 +6808,8 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                         /* kick EH for boot probing */
                         spin_lock_irqsave(ap->lock, flags);
 
-                        ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1;
+                        ehi->probe_mask =
+                                (1 << ata_link_max_devices(&ap->link)) - 1;
                         ehi->action |= ATA_EH_SOFTRESET;
                         ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
 
@@ -6506,7 +6871,7 @@ int ata_host_activate(struct ata_host *host, int irq,
                       irq_handler_t irq_handler, unsigned long irq_flags,
                       struct scsi_host_template *sht)
 {
-        int rc;
+        int i, rc;
 
         rc = ata_host_start(host);
         if (rc)
@@ -6517,8 +6882,8 @@ int ata_host_activate(struct ata_host *host, int irq,
         if (rc)
                 return rc;
 
-        /* Used to print device info at probe */
-        host->irq = irq;
+        for (i = 0; i < host->n_ports; i++)
+                ata_port_desc(host->ports[i], "irq %d", irq);
 
         rc = ata_host_register(host, sht);
         /* if failed, just free the IRQ and leave ports alone */
@@ -6542,7 +6907,8 @@ int ata_host_activate(struct ata_host *host, int irq,
 void ata_port_detach(struct ata_port *ap)
 {
         unsigned long flags;
-        int i;
+        struct ata_link *link;
+        struct ata_device *dev;
 
         if (!ap->ops->error_handler)
                 goto skip_eh;
@@ -6559,8 +6925,10 @@ void ata_port_detach(struct ata_port *ap)
          */
         spin_lock_irqsave(ap->lock, flags);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ata_dev_disable(&ap->device[i]);
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link)
+                        ata_dev_disable(dev);
+        }
 
         spin_unlock_irqrestore(ap->lock, flags);
 
@@ -6639,7 +7007,7 @@ void ata_std_ports(struct ata_ioports *ioaddr)
  */
 void ata_pci_remove_one(struct pci_dev *pdev)
 {
-        struct device *dev = pci_dev_to_dev(pdev);
+        struct device *dev = &pdev->dev;
         struct ata_host *host = dev_get_drvdata(dev);
 
         ata_host_detach(host);
@@ -6847,7 +7215,6 @@ static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
 }
 
 const struct ata_port_operations ata_dummy_port_ops = {
-        .port_disable           = ata_port_disable,
         .check_status           = ata_dummy_check_status,
         .check_altstatus        = ata_dummy_check_status,
         .dev_select             = ata_noop_dev_select,
@@ -6909,6 +7276,7 @@ EXPORT_SYMBOL_GPL(ata_interrupt);
 EXPORT_SYMBOL_GPL(ata_do_set_mode);
 EXPORT_SYMBOL_GPL(ata_data_xfer);
 EXPORT_SYMBOL_GPL(ata_data_xfer_noirq);
+EXPORT_SYMBOL_GPL(ata_std_qc_defer);
 EXPORT_SYMBOL_GPL(ata_qc_prep);
 EXPORT_SYMBOL_GPL(ata_dumb_qc_prep);
 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
@@ -6925,14 +7293,14 @@ EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
 EXPORT_SYMBOL_GPL(ata_port_probe);
 EXPORT_SYMBOL_GPL(ata_dev_disable);
 EXPORT_SYMBOL_GPL(sata_set_spd);
-EXPORT_SYMBOL_GPL(sata_phy_debounce);
-EXPORT_SYMBOL_GPL(sata_phy_resume);
+EXPORT_SYMBOL_GPL(sata_link_debounce);
+EXPORT_SYMBOL_GPL(sata_link_resume);
 EXPORT_SYMBOL_GPL(sata_phy_reset);
 EXPORT_SYMBOL_GPL(__sata_phy_reset);
 EXPORT_SYMBOL_GPL(ata_bus_reset);
 EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(ata_std_softreset);
-EXPORT_SYMBOL_GPL(sata_port_hardreset);
+EXPORT_SYMBOL_GPL(sata_link_hardreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
 EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_dev_classify);
@@ -6953,8 +7321,8 @@ EXPORT_SYMBOL_GPL(sata_scr_valid);
 EXPORT_SYMBOL_GPL(sata_scr_read);
 EXPORT_SYMBOL_GPL(sata_scr_write);
 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
-EXPORT_SYMBOL_GPL(ata_port_online);
-EXPORT_SYMBOL_GPL(ata_port_offline);
+EXPORT_SYMBOL_GPL(ata_link_online);
+EXPORT_SYMBOL_GPL(ata_link_offline);
 #ifdef CONFIG_PM
 EXPORT_SYMBOL_GPL(ata_host_suspend);
 EXPORT_SYMBOL_GPL(ata_host_resume);
@@ -6985,22 +7353,31 @@ EXPORT_SYMBOL_GPL(ata_pci_default_filter);
 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
 #endif /* CONFIG_PCI */
 
+EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch);
+EXPORT_SYMBOL_GPL(sata_pmp_std_prereset);
+EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset);
+EXPORT_SYMBOL_GPL(sata_pmp_std_postreset);
+EXPORT_SYMBOL_GPL(sata_pmp_do_eh);
+
 EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
 EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
 EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
+EXPORT_SYMBOL_GPL(ata_port_desc);
+#ifdef CONFIG_PCI
+EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
+#endif /* CONFIG_PCI */
 EXPORT_SYMBOL_GPL(ata_eng_timeout);
 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
+EXPORT_SYMBOL_GPL(ata_link_abort);
 EXPORT_SYMBOL_GPL(ata_port_abort);
 EXPORT_SYMBOL_GPL(ata_port_freeze);
+EXPORT_SYMBOL_GPL(sata_async_notification);
 EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
 EXPORT_SYMBOL_GPL(ata_do_eh);
 EXPORT_SYMBOL_GPL(ata_irq_on);
-EXPORT_SYMBOL_GPL(ata_dummy_irq_on);
-EXPORT_SYMBOL_GPL(ata_irq_ack);
-EXPORT_SYMBOL_GPL(ata_dummy_irq_ack);
 EXPORT_SYMBOL_GPL(ata_dev_try_classify);
 
 EXPORT_SYMBOL_GPL(ata_cable_40wire);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index ac6ceed4bb..2eaa39fc65 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -33,6 +33,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/pci.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_eh.h>
@@ -74,7 +75,6 @@ static const unsigned long ata_eh_reset_timeouts[] = {
 };
 
 static void __ata_port_freeze(struct ata_port *ap);
-static void ata_eh_finish(struct ata_port *ap);
 #ifdef CONFIG_PM
 static void ata_eh_handle_port_suspend(struct ata_port *ap);
 static void ata_eh_handle_port_resume(struct ata_port *ap);
@@ -151,6 +151,73 @@ void ata_ehi_clear_desc(struct ata_eh_info *ehi)
         ehi->desc_len = 0;
 }
 
+/**
+ *      ata_port_desc - append port description
+ *      @ap: target ATA port
+ *      @fmt: printf format string
+ *
+ *      Format string according to @fmt and append it to port
+ *      description.  If port description is not empty, " " is added
+ *      in-between.  This function is to be used while initializing
+ *      ata_host.  The description is printed on host registration.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
+{
+        va_list args;
+
+        WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
+
+        if (ap->link.eh_info.desc_len)
+                __ata_ehi_push_desc(&ap->link.eh_info, " ");
+
+        va_start(args, fmt);
+        __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
+        va_end(args);
+}
+
+#ifdef CONFIG_PCI
+
+/**
+ *      ata_port_pbar_desc - append PCI BAR description
+ *      @ap: target ATA port
+ *      @bar: target PCI BAR
+ *      @offset: offset into PCI BAR
+ *      @name: name of the area
+ *
+ *      If @offset is negative, this function formats a string which
+ *      contains the name, address, size and type of the BAR and
+ *      appends it to the port description.  If @offset is zero or
+ *      positive, only name and offsetted address is appended.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
+                        const char *name)
+{
+        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+        char *type = "";
+        unsigned long long start, len;
+
+        if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
+                type = "m";
+        else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
+                type = "i";
+
+        start = (unsigned long long)pci_resource_start(pdev, bar);
+        len = (unsigned long long)pci_resource_len(pdev, bar);
+
+        if (offset < 0)
+                ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
+        else
+                ata_port_desc(ap, "%s 0x%llx", name, start + offset);
+}
+
+#endif /* CONFIG_PCI */
+
 static void ata_ering_record(struct ata_ering *ering, int is_io,
                              unsigned int err_mask)
 {
@@ -195,28 +262,29 @@ static int ata_ering_map(struct ata_ering *ering,
 
 static unsigned int ata_eh_dev_action(struct ata_device *dev)
 {
-        struct ata_eh_context *ehc = &dev->ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
 
         return ehc->i.action | ehc->i.dev_action[dev->devno];
 }
 
-static void ata_eh_clear_action(struct ata_device *dev,
+static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
                                 struct ata_eh_info *ehi, unsigned int action)
 {
-        int i;
+        struct ata_device *tdev;
 
         if (!dev) {
                 ehi->action &= ~action;
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ehi->dev_action[i] &= ~action;
+                ata_link_for_each_dev(tdev, link)
+                        ehi->dev_action[tdev->devno] &= ~action;
         } else {
                 /* doesn't make sense for port-wide EH actions */
                 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
 
                 /* break ehi->action into ehi->dev_action */
                 if (ehi->action & action) {
-                        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                                ehi->dev_action[i] |= ehi->action & action;
+                        ata_link_for_each_dev(tdev, link)
+                                ehi->dev_action[tdev->devno] |=
+                                        ehi->action & action;
                         ehi->action &= ~action;
                 }
 
@@ -261,7 +329,7 @@ enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
 
         ret = EH_HANDLED;
         spin_lock_irqsave(ap->lock, flags);
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc) {
                 WARN_ON(qc->scsicmd != cmd);
                 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
@@ -290,7 +358,7 @@ enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
 void ata_scsi_error(struct Scsi_Host *host)
 {
         struct ata_port *ap = ata_shost_to_port(host);
-        int i, repeat_cnt = ATA_EH_MAX_REPEAT;
+        int i;
         unsigned long flags;
 
         DPRINTK("ENTER\n");
@@ -356,12 +424,17 @@ void ata_scsi_error(struct Scsi_Host *host)
                         __ata_port_freeze(ap);
 
                 spin_unlock_irqrestore(ap->lock, flags);
+
+                /* initialize eh_tries */
+                ap->eh_tries = ATA_EH_MAX_TRIES;
         } else
                 spin_unlock_wait(ap->lock);
 
  repeat:
         /* invoke error handler */
         if (ap->ops->error_handler) {
+                struct ata_link *link;
+
                 /* kill fast drain timer */
                 del_timer_sync(&ap->fastdrain_timer);
 
@@ -371,12 +444,15 @@ void ata_scsi_error(struct Scsi_Host *host)
                 /* fetch & clear EH info */
                 spin_lock_irqsave(ap->lock, flags);
 
-                memset(&ap->eh_context, 0, sizeof(ap->eh_context));
-                ap->eh_context.i = ap->eh_info;
-                memset(&ap->eh_info, 0, sizeof(ap->eh_info));
+                __ata_port_for_each_link(link, ap) {
+                        memset(&link->eh_context, 0, sizeof(link->eh_context));
+                        link->eh_context.i = link->eh_info;
+                        memset(&link->eh_info, 0, sizeof(link->eh_info));
+                }
 
                 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
                 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
+                ap->excl_link = NULL;   /* don't maintain exclusion over EH */
 
                 spin_unlock_irqrestore(ap->lock, flags);
 
@@ -396,20 +472,18 @@ void ata_scsi_error(struct Scsi_Host *host)
                 spin_lock_irqsave(ap->lock, flags);
 
                 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
-                        if (--repeat_cnt) {
-                                ata_port_printk(ap, KERN_INFO,
-                                        "EH pending after completion, "
-                                        "repeating EH (cnt=%d)\n", repeat_cnt);
+                        if (--ap->eh_tries) {
                                 spin_unlock_irqrestore(ap->lock, flags);
                                 goto repeat;
                         }
                         ata_port_printk(ap, KERN_ERR, "EH pending after %d "
-                                        "tries, giving up\n", ATA_EH_MAX_REPEAT);
+                                        "tries, giving up\n", ATA_EH_MAX_TRIES);
                         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
                 }
 
                 /* this run is complete, make sure EH info is clear */
-                memset(&ap->eh_info, 0, sizeof(ap->eh_info));
+                __ata_port_for_each_link(link, ap)
+                        memset(&link->eh_info, 0, sizeof(link->eh_info));
 
                 /* Clear host_eh_scheduled while holding ap->lock such
                  * that if exception occurs after this point but
@@ -420,7 +494,7 @@ void ata_scsi_error(struct Scsi_Host *host)
 
                 spin_unlock_irqrestore(ap->lock, flags);
         } else {
-                WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
+                WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
                 ap->ops->eng_timeout(ap);
         }
 
@@ -575,7 +649,7 @@ void ata_eng_timeout(struct ata_port *ap)
 {
         DPRINTK("ENTER\n");
 
-        ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
+        ata_qc_timeout(ata_qc_from_tag(ap, ap->link.active_tag));
 
         DPRINTK("EXIT\n");
 }
@@ -718,19 +792,7 @@ void ata_port_schedule_eh(struct ata_port *ap)
         DPRINTK("port EH scheduled\n");
 }
 
-/**
- *      ata_port_abort - abort all qc's on the port
- *      @ap: ATA port to abort qc's for
- *
- *      Abort all active qc's of @ap and schedule EH.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- *      RETURNS:
- *      Number of aborted qc's.
- */
-int ata_port_abort(struct ata_port *ap)
+static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
 {
         int tag, nr_aborted = 0;
 
@@ -742,7 +804,7 @@ int ata_port_abort(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
 
-                if (qc) {
+                if (qc && (!link || qc->dev->link == link)) {
                         qc->flags |= ATA_QCFLAG_FAILED;
                         ata_qc_complete(qc);
                         nr_aborted++;
@@ -756,6 +818,40 @@ int ata_port_abort(struct ata_port *ap)
 }
 
 /**
+ *      ata_link_abort - abort all qc's on the link
+ *      @link: ATA link to abort qc's for
+ *
+ *      Abort all active qc's active on @link and schedule EH.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      Number of aborted qc's.
+ */
+int ata_link_abort(struct ata_link *link)
+{
+        return ata_do_link_abort(link->ap, link);
+}
+
+/**
+ *      ata_port_abort - abort all qc's on the port
+ *      @ap: ATA port to abort qc's for
+ *
+ *      Abort all active qc's of @ap and schedule EH.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ *
+ *      RETURNS:
+ *      Number of aborted qc's.
+ */
+int ata_port_abort(struct ata_port *ap)
+{
+        return ata_do_link_abort(ap, NULL);
+}
+
+/**
  *      __ata_port_freeze - freeze port
  *      @ap: ATA port to freeze
  *
@@ -810,6 +906,79 @@ int ata_port_freeze(struct ata_port *ap)
 }
 
 /**
+ *      sata_async_notification - SATA async notification handler
+ *      @ap: ATA port where async notification is received
+ *
+ *      Handler to be called when async notification via SDB FIS is
+ *      received.  This function schedules EH if necessary.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      1 if EH is scheduled, 0 otherwise.
+ */
+int sata_async_notification(struct ata_port *ap)
+{
+        u32 sntf;
+        int rc;
+
+        if (!(ap->flags & ATA_FLAG_AN))
+                return 0;
+
+        rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
+        if (rc == 0)
+                sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
+
+        if (!ap->nr_pmp_links || rc) {
+                /* PMP is not attached or SNTF is not available */
+                if (!ap->nr_pmp_links) {
+                        /* PMP is not attached.  Check whether ATAPI
+                         * AN is configured.  If so, notify media
+                         * change.
+                         */
+                        struct ata_device *dev = ap->link.device;
+
+                        if ((dev->class == ATA_DEV_ATAPI) &&
+                            (dev->flags & ATA_DFLAG_AN))
+                                ata_scsi_media_change_notify(dev);
+                        return 0;
+                } else {
+                        /* PMP is attached but SNTF is not available.
+                         * ATAPI async media change notification is
+                         * not used.  The PMP must be reporting PHY
+                         * status change, schedule EH.
+                         */
+                        ata_port_schedule_eh(ap);
+                        return 1;
+                }
+        } else {
+                /* PMP is attached and SNTF is available */
+                struct ata_link *link;
+
+                /* check and notify ATAPI AN */
+                ata_port_for_each_link(link, ap) {
+                        if (!(sntf & (1 << link->pmp)))
+                                continue;
+
+                        if ((link->device->class == ATA_DEV_ATAPI) &&
+                            (link->device->flags & ATA_DFLAG_AN))
+                                ata_scsi_media_change_notify(link->device);
+                }
+
+                /* If PMP is reporting that PHY status of some
+                 * downstream ports has changed, schedule EH.
+                 */
+                if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
+                        ata_port_schedule_eh(ap);
+                        return 1;
+                }
+
+                return 0;
+        }
+}
+
+/**
  *      ata_eh_freeze_port - EH helper to freeze port
  *      @ap: ATA port to freeze
  *
@@ -920,9 +1089,10 @@ void ata_eh_qc_retry(struct ata_queued_cmd *qc)
  *      LOCKING:
  *      None.
  */
-static void ata_eh_detach_dev(struct ata_device *dev)
+void ata_eh_detach_dev(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         unsigned long flags;
 
         ata_dev_disable(dev);
@@ -937,31 +1107,32 @@ static void ata_eh_detach_dev(struct ata_device *dev)
         }
 
         /* clear per-dev EH actions */
-        ata_eh_clear_action(dev, &ap->eh_info, ATA_EH_PERDEV_MASK);
-        ata_eh_clear_action(dev, &ap->eh_context.i, ATA_EH_PERDEV_MASK);
+        ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
+        ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
 
         spin_unlock_irqrestore(ap->lock, flags);
 }
 
 /**
  *      ata_eh_about_to_do - about to perform eh_action
- *      @ap: target ATA port
+ *      @link: target ATA link
  *      @dev: target ATA dev for per-dev action (can be NULL)
  *      @action: action about to be performed
  *
  *      Called just before performing EH actions to clear related bits
- *      in @ap->eh_info such that eh actions are not unnecessarily
+ *      in @link->eh_info such that eh actions are not unnecessarily
  *      repeated.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
-                               unsigned int action)
+void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
+                        unsigned int action)
 {
+        struct ata_port *ap = link->ap;
+        struct ata_eh_info *ehi = &link->eh_info;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned long flags;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        struct ata_eh_context *ehc = &ap->eh_context;
 
         spin_lock_irqsave(ap->lock, flags);
 
@@ -978,7 +1149,7 @@ static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
                 ehi->flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
         }
 
-        ata_eh_clear_action(dev, ehi, action);
+        ata_eh_clear_action(link, dev, ehi, action);
 
         if (!(ehc->i.flags & ATA_EHI_QUIET))
                 ap->pflags |= ATA_PFLAG_RECOVERED;
@@ -988,26 +1159,28 @@ static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
 
 /**
  *      ata_eh_done - EH action complete
- *      @ap: target ATA port
+*       @ap: target ATA port
  *      @dev: target ATA dev for per-dev action (can be NULL)
  *      @action: action just completed
  *
  *      Called right after performing EH actions to clear related bits
- *      in @ap->eh_context.
+ *      in @link->eh_context.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_done(struct ata_port *ap, struct ata_device *dev,
-                        unsigned int action)
+void ata_eh_done(struct ata_link *link, struct ata_device *dev,
+                 unsigned int action)
 {
+        struct ata_eh_context *ehc = &link->eh_context;
+
         /* if reset is complete, clear all reset actions & reset modifier */
         if (action & ATA_EH_RESET_MASK) {
                 action |= ATA_EH_RESET_MASK;
-                ap->eh_context.i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
+                ehc->i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
         }
 
-        ata_eh_clear_action(dev, &ap->eh_context.i, action);
+        ata_eh_clear_action(link, dev, &ehc->i, action);
 }
 
 /**
@@ -1077,7 +1250,7 @@ static unsigned int ata_read_log_page(struct ata_device *dev,
         tf.protocol = ATA_PROT_PIO;
 
         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
-                                     buf, sectors * ATA_SECT_SIZE);
+                                     buf, sectors * ATA_SECT_SIZE, 0);
 
         DPRINTK("EXIT, err_mask=%x\n", err_mask);
         return err_mask;
@@ -1101,7 +1274,7 @@ static unsigned int ata_read_log_page(struct ata_device *dev,
 static int ata_eh_read_log_10h(struct ata_device *dev,
                                int *tag, struct ata_taskfile *tf)
 {
-        u8 *buf = dev->ap->sector_buf;
+        u8 *buf = dev->link->ap->sector_buf;
         unsigned int err_mask;
         u8 csum;
         int i;
@@ -1155,7 +1328,7 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
 {
         struct ata_device *dev = qc->dev;
         unsigned char *sense_buf = qc->scsicmd->sense_buffer;
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf;
         u8 cdb[ATAPI_CDB_LEN];
 
@@ -1191,12 +1364,12 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
         }
 
         return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
-                                 sense_buf, SCSI_SENSE_BUFFERSIZE);
+                                 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
 }
 
 /**
  *      ata_eh_analyze_serror - analyze SError for a failed port
- *      @ap: ATA port to analyze SError for
+ *      @link: ATA link to analyze SError for
  *
  *      Analyze SError if available and further determine cause of
  *      failure.
@@ -1204,11 +1377,12 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
  *      LOCKING:
  *      None.
  */
-static void ata_eh_analyze_serror(struct ata_port *ap)
+static void ata_eh_analyze_serror(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &link->eh_context;
         u32 serror = ehc->i.serror;
         unsigned int err_mask = 0, action = 0;
+        u32 hotplug_mask;
 
         if (serror & SERR_PERSISTENT) {
                 err_mask |= AC_ERR_ATA_BUS;
@@ -1227,7 +1401,20 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
                 err_mask |= AC_ERR_SYSTEM;
                 action |= ATA_EH_HARDRESET;
         }
-        if (serror & (SERR_PHYRDY_CHG | SERR_DEV_XCHG))
+
+        /* Determine whether a hotplug event has occurred.  Both
+         * SError.N/X are considered hotplug events for enabled or
+         * host links.  For disabled PMP links, only N bit is
+         * considered as X bit is left at 1 for link plugging.
+         */
+        hotplug_mask = 0;
+
+        if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
+                hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
+        else
+                hotplug_mask = SERR_PHYRDY_CHG;
+
+        if (serror & hotplug_mask)
                 ata_ehi_hotplugged(&ehc->i);
 
         ehc->i.err_mask |= err_mask;
@@ -1236,7 +1423,7 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
 
 /**
  *      ata_eh_analyze_ncq_error - analyze NCQ error
- *      @ap: ATA port to analyze NCQ error for
+ *      @link: ATA link to analyze NCQ error for
  *
  *      Read log page 10h, determine the offending qc and acquire
  *      error status TF.  For NCQ device errors, all LLDDs have to do
@@ -1246,10 +1433,11 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
  *      LOCKING:
  *      Kernel thread context (may sleep).
  */
-static void ata_eh_analyze_ncq_error(struct ata_port *ap)
+static void ata_eh_analyze_ncq_error(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
-        struct ata_device *dev = ap->device;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev = link->device;
         struct ata_queued_cmd *qc;
         struct ata_taskfile tf;
         int tag, rc;
@@ -1259,7 +1447,7 @@ static void ata_eh_analyze_ncq_error(struct ata_port *ap)
                 return;
 
         /* is it NCQ device error? */
-        if (!ap->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
+        if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
                 return;
 
         /* has LLDD analyzed already? */
@@ -1276,13 +1464,13 @@ static void ata_eh_analyze_ncq_error(struct ata_port *ap)
         /* okay, this error is ours */
         rc = ata_eh_read_log_10h(dev, &tag, &tf);
         if (rc) {
-                ata_port_printk(ap, KERN_ERR, "failed to read log page 10h "
+                ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
                                 "(errno=%d)\n", rc);
                 return;
         }
 
-        if (!(ap->sactive & (1 << tag))) {
-                ata_port_printk(ap, KERN_ERR, "log page 10h reported "
+        if (!(link->sactive & (1 << tag))) {
+                ata_link_printk(link, KERN_ERR, "log page 10h reported "
                                 "inactive tag %d\n", tag);
                 return;
         }
@@ -1497,7 +1685,7 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
         /* speed down? */
         if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
                 /* speed down SATA link speed if possible */
-                if (sata_down_spd_limit(dev->ap) == 0) {
+                if (sata_down_spd_limit(dev->link) == 0) {
                         action |= ATA_EH_HARDRESET;
                         goto done;
                 }
@@ -1528,7 +1716,7 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
          * SATA.  Consider it only for PATA.
          */
         if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
-            (dev->ap->cbl != ATA_CBL_SATA) &&
+            (dev->link->ap->cbl != ATA_CBL_SATA) &&
             (dev->xfer_shift != ATA_SHIFT_PIO)) {
                 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
                         dev->spdn_cnt = 0;
@@ -1545,19 +1733,20 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
 }
 
 /**
- *      ata_eh_autopsy - analyze error and determine recovery action
- *      @ap: ATA port to perform autopsy on
+ *      ata_eh_link_autopsy - analyze error and determine recovery action
+ *      @link: host link to perform autopsy on
  *
- *      Analyze why @ap failed and determine which recovery action is
- *      needed.  This function also sets more detailed AC_ERR_* values
- *      and fills sense data for ATAPI CHECK SENSE.
+ *      Analyze why @link failed and determine which recovery actions
+ *      are needed.  This function also sets more detailed AC_ERR_*
+ *      values and fills sense data for ATAPI CHECK SENSE.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep).
  */
-static void ata_eh_autopsy(struct ata_port *ap)
+static void ata_eh_link_autopsy(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned int all_err_mask = 0;
         int tag, is_io = 0;
         u32 serror;
@@ -1569,10 +1758,10 @@ static void ata_eh_autopsy(struct ata_port *ap)
                 return;
 
         /* obtain and analyze SError */
-        rc = sata_scr_read(ap, SCR_ERROR, &serror);
+        rc = sata_scr_read(link, SCR_ERROR, &serror);
         if (rc == 0) {
                 ehc->i.serror |= serror;
-                ata_eh_analyze_serror(ap);
+                ata_eh_analyze_serror(link);
         } else if (rc != -EOPNOTSUPP) {
                 /* SError read failed, force hardreset and probing */
                 ata_ehi_schedule_probe(&ehc->i);
@@ -1581,7 +1770,7 @@ static void ata_eh_autopsy(struct ata_port *ap)
         }
 
         /* analyze NCQ failure */
-        ata_eh_analyze_ncq_error(ap);
+        ata_eh_analyze_ncq_error(link);
 
         /* any real error trumps AC_ERR_OTHER */
         if (ehc->i.err_mask & ~AC_ERR_OTHER)
@@ -1592,7 +1781,7 @@ static void ata_eh_autopsy(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED))
+                if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
                         continue;
 
                 /* inherit upper level err_mask */
@@ -1646,20 +1835,43 @@ static void ata_eh_autopsy(struct ata_port *ap)
 }
 
 /**
- *      ata_eh_report - report error handling to user
- *      @ap: ATA port EH is going on
+ *      ata_eh_autopsy - analyze error and determine recovery action
+ *      @ap: host port to perform autopsy on
+ *
+ *      Analyze all links of @ap and determine why they failed and
+ *      which recovery actions are needed.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+void ata_eh_autopsy(struct ata_port *ap)
+{
+        struct ata_link *link;
+
+        __ata_port_for_each_link(link, ap)
+                ata_eh_link_autopsy(link);
+}
+
+/**
+ *      ata_eh_link_report - report error handling to user
+ *      @link: ATA link EH is going on
  *
  *      Report EH to user.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_report(struct ata_port *ap)
+static void ata_eh_link_report(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         const char *frozen, *desc;
+        char tries_buf[6];
         int tag, nr_failed = 0;
 
+        if (ehc->i.flags & ATA_EHI_QUIET)
+                return;
+
         desc = NULL;
         if (ehc->i.desc[0] != '\0')
                 desc = ehc->i.desc;
@@ -1667,7 +1879,7 @@ static void ata_eh_report(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED))
+                if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
                         continue;
                 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
                         continue;
@@ -1682,22 +1894,48 @@ static void ata_eh_report(struct ata_port *ap)
         if (ap->pflags & ATA_PFLAG_FROZEN)
                 frozen = " frozen";
 
+        memset(tries_buf, 0, sizeof(tries_buf));
+        if (ap->eh_tries < ATA_EH_MAX_TRIES)
+                snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
+                         ap->eh_tries);
+
         if (ehc->i.dev) {
                 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
-                               "SAct 0x%x SErr 0x%x action 0x%x%s\n",
-                               ehc->i.err_mask, ap->sactive, ehc->i.serror,
-                               ehc->i.action, frozen);
+                               "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
+                               ehc->i.err_mask, link->sactive, ehc->i.serror,
+                               ehc->i.action, frozen, tries_buf);
                 if (desc)
                         ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
         } else {
-                ata_port_printk(ap, KERN_ERR, "exception Emask 0x%x "
-                                "SAct 0x%x SErr 0x%x action 0x%x%s\n",
-                                ehc->i.err_mask, ap->sactive, ehc->i.serror,
-                                ehc->i.action, frozen);
+                ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
+                                "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
+                                ehc->i.err_mask, link->sactive, ehc->i.serror,
+                                ehc->i.action, frozen, tries_buf);
                 if (desc)
-                        ata_port_printk(ap, KERN_ERR, "%s\n", desc);
+                        ata_link_printk(link, KERN_ERR, "%s\n", desc);
         }
 
+        if (ehc->i.serror)
+                ata_port_printk(ap, KERN_ERR,
+                  "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
+                  ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
+                  ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
+                  ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
+                  ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
+                  ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
+                  ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
+                  ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
+                  ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
+                  ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
+                  ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
+                  ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
+                  ehc->i.serror & SERR_CRC ? "BadCRC " : "",
+                  ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
+                  ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
+                  ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
+                  ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
+                  ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "" );
+
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 static const char *dma_str[] = {
                         [DMA_BIDIRECTIONAL]     = "bidi",
@@ -1708,7 +1946,8 @@ static void ata_eh_report(struct ata_port *ap)
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
                 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED) || !qc->err_mask)
+                if (!(qc->flags & ATA_QCFLAG_FAILED) ||
+                    qc->dev->link != link || !qc->err_mask)
                         continue;
 
                 ata_dev_printk(qc->dev, KERN_ERR,
@@ -1728,18 +1967,60 @@ static void ata_eh_report(struct ata_port *ap)
                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
+
+                if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
+                                    ATA_ERR) ) {
+                        if (res->command & ATA_BUSY)
+                                ata_dev_printk(qc->dev, KERN_ERR,
+                                  "status: { Busy }\n" );
+                        else
+                                ata_dev_printk(qc->dev, KERN_ERR,
+                                  "status: { %s%s%s%s}\n",
+                                  res->command & ATA_DRDY ? "DRDY " : "",
+                                  res->command & ATA_DF ? "DF " : "",
+                                  res->command & ATA_DRQ ? "DRQ " : "",
+                                  res->command & ATA_ERR ? "ERR " : "" );
+                }
+
+                if (cmd->command != ATA_CMD_PACKET &&
+                    (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
+                                     ATA_ABORTED)))
+                        ata_dev_printk(qc->dev, KERN_ERR,
+                          "error: { %s%s%s%s}\n",
+                          res->feature & ATA_ICRC ? "ICRC " : "",
+                          res->feature & ATA_UNC ? "UNC " : "",
+                          res->feature & ATA_IDNF ? "IDNF " : "",
+                          res->feature & ATA_ABORTED ? "ABRT " : "" );
         }
 }
 
-static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
+/**
+ *      ata_eh_report - report error handling to user
+ *      @ap: ATA port to report EH about
+ *
+ *      Report EH to user.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_eh_report(struct ata_port *ap)
+{
+        struct ata_link *link;
+
+        __ata_port_for_each_link(link, ap)
+                ata_eh_link_report(link);
+}
+
+static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
                         unsigned int *classes, unsigned long deadline)
 {
-        int i, rc;
+        struct ata_device *dev;
+        int rc;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                classes[i] = ATA_DEV_UNKNOWN;
+        ata_link_for_each_dev(dev, link)
+                classes[dev->devno] = ATA_DEV_UNKNOWN;
 
-        rc = reset(ap, classes, deadline);
+        rc = reset(link, classes, deadline);
         if (rc)
                 return rc;
 
@@ -1747,71 +2028,87 @@ static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
          * is complete and convert all ATA_DEV_UNKNOWN to
          * ATA_DEV_NONE.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (classes[i] != ATA_DEV_UNKNOWN)
+        ata_link_for_each_dev(dev, link)
+                if (classes[dev->devno] != ATA_DEV_UNKNOWN)
                         break;
 
-        if (i < ATA_MAX_DEVICES)
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        if (classes[i] == ATA_DEV_UNKNOWN)
-                                classes[i] = ATA_DEV_NONE;
+        if (dev) {
+                ata_link_for_each_dev(dev, link) {
+                        if (classes[dev->devno] == ATA_DEV_UNKNOWN)
+                                classes[dev->devno] = ATA_DEV_NONE;
+                }
+        }
 
         return 0;
 }
 
-static int ata_eh_followup_srst_needed(int rc, int classify,
+static int ata_eh_followup_srst_needed(struct ata_link *link,
+                                       int rc, int classify,
                                        const unsigned int *classes)
 {
+        if (link->flags & ATA_LFLAG_NO_SRST)
+                return 0;
         if (rc == -EAGAIN)
                 return 1;
         if (rc != 0)
                 return 0;
-        if (classify && classes[0] == ATA_DEV_UNKNOWN)
+        if ((link->ap->flags & ATA_FLAG_PMP) && ata_is_host_link(link))
+                return 1;
+        if (classify && !(link->flags & ATA_LFLAG_ASSUME_CLASS) &&
+            classes[0] == ATA_DEV_UNKNOWN)
                 return 1;
         return 0;
 }
 
-static int ata_eh_reset(struct ata_port *ap, int classify,
-                        ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
-                        ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
+int ata_eh_reset(struct ata_link *link, int classify,
+                 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned int *classes = ehc->classes;
         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
         int try = 0;
+        struct ata_device *dev;
         unsigned long deadline;
         unsigned int action;
         ata_reset_fn_t reset;
-        int i, rc;
+        unsigned long flags;
+        int rc;
 
         /* about to reset */
-        ata_eh_about_to_do(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
+        spin_lock_irqsave(ap->lock, flags);
+        ap->pflags |= ATA_PFLAG_RESETTING;
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        ata_eh_about_to_do(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
 
         /* Determine which reset to use and record in ehc->i.action.
          * prereset() may examine and modify it.
          */
         action = ehc->i.action;
         ehc->i.action &= ~ATA_EH_RESET_MASK;
-        if (softreset && (!hardreset || (!sata_set_spd_needed(ap) &&
+        if (softreset && (!hardreset || (!(link->flags & ATA_LFLAG_NO_SRST) &&
+                                         !sata_set_spd_needed(link) &&
                                          !(action & ATA_EH_HARDRESET))))
                 ehc->i.action |= ATA_EH_SOFTRESET;
         else
                 ehc->i.action |= ATA_EH_HARDRESET;
 
         if (prereset) {
-                rc = prereset(ap, jiffies + ATA_EH_PRERESET_TIMEOUT);
+                rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
                 if (rc) {
                         if (rc == -ENOENT) {
-                                ata_port_printk(ap, KERN_DEBUG,
+                                ata_link_printk(link, KERN_DEBUG,
                                                 "port disabled. ignoring.\n");
-                                ap->eh_context.i.action &= ~ATA_EH_RESET_MASK;
+                                ehc->i.action &= ~ATA_EH_RESET_MASK;
 
-                                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                                        classes[i] = ATA_DEV_NONE;
+                                ata_link_for_each_dev(dev, link)
+                                        classes[dev->devno] = ATA_DEV_NONE;
 
                                 rc = 0;
                         } else
-                                ata_port_printk(ap, KERN_ERR,
+                                ata_link_printk(link, KERN_ERR,
                                         "prereset failed (errno=%d)\n", rc);
                         goto out;
                 }
@@ -1824,8 +2121,8 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                 reset = softreset;
         else {
                 /* prereset told us not to reset, bang classes and return */
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        classes[i] = ATA_DEV_NONE;
+                ata_link_for_each_dev(dev, link)
+                        classes[dev->devno] = ATA_DEV_NONE;
                 rc = 0;
                 goto out;
         }
@@ -1843,7 +2140,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
         /* shut up during boot probing */
         if (verbose)
-                ata_port_printk(ap, KERN_INFO, "%s resetting port\n",
+                ata_link_printk(link, KERN_INFO, "%s resetting link\n",
                                 reset == softreset ? "soft" : "hard");
 
         /* mark that this EH session started with reset */
@@ -1852,49 +2149,54 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         else
                 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
 
-        rc = ata_do_reset(ap, reset, classes, deadline);
+        rc = ata_do_reset(link, reset, classes, deadline);
 
         if (reset == hardreset &&
-            ata_eh_followup_srst_needed(rc, classify, classes)) {
+            ata_eh_followup_srst_needed(link, rc, classify, classes)) {
                 /* okay, let's do follow-up softreset */
                 reset = softreset;
 
                 if (!reset) {
-                        ata_port_printk(ap, KERN_ERR,
+                        ata_link_printk(link, KERN_ERR,
                                         "follow-up softreset required "
                                         "but no softreset avaliable\n");
                         rc = -EINVAL;
                         goto out;
                 }
 
-                ata_eh_about_to_do(ap, NULL, ATA_EH_RESET_MASK);
-                rc = ata_do_reset(ap, reset, classes, deadline);
+                ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
+                rc = ata_do_reset(link, reset, classes, deadline);
 
-                if (rc == 0 && classify &&
-                    classes[0] == ATA_DEV_UNKNOWN) {
-                        ata_port_printk(ap, KERN_ERR,
+                if (rc == 0 && classify && classes[0] == ATA_DEV_UNKNOWN &&
+                    !(link->flags & ATA_LFLAG_ASSUME_CLASS)) {
+                        ata_link_printk(link, KERN_ERR,
                                         "classification failed\n");
                         rc = -EINVAL;
                         goto out;
                 }
         }
 
-        if (rc && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
+        /* if we skipped follow-up srst, clear rc */
+        if (rc == -EAGAIN)
+                rc = 0;
+
+        if (rc && rc != -ERESTART && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
                 unsigned long now = jiffies;
 
                 if (time_before(now, deadline)) {
                         unsigned long delta = deadline - jiffies;
 
-                        ata_port_printk(ap, KERN_WARNING, "reset failed "
+                        ata_link_printk(link, KERN_WARNING, "reset failed "
                                 "(errno=%d), retrying in %u secs\n",
                                 rc, (jiffies_to_msecs(delta) + 999) / 1000);
 
-                        schedule_timeout_uninterruptible(delta);
+                        while (delta)
+                                delta = schedule_timeout_uninterruptible(delta);
                 }
 
                 if (rc == -EPIPE ||
                     try == ARRAY_SIZE(ata_eh_reset_timeouts) - 1)
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(link);
                 if (hardreset)
                         reset = hardreset;
                 goto retry;
@@ -1903,37 +2205,56 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         if (rc == 0) {
                 u32 sstatus;
 
-                /* After the reset, the device state is PIO 0 and the
-                 * controller state is undefined.  Record the mode.
-                 */
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ap->device[i].pio_mode = XFER_PIO_0;
+                ata_link_for_each_dev(dev, link) {
+                        /* After the reset, the device state is PIO 0
+                         * and the controller state is undefined.
+                         * Record the mode.
+                         */
+                        dev->pio_mode = XFER_PIO_0;
+
+                        if (ata_link_offline(link))
+                                continue;
+
+                        /* apply class override and convert UNKNOWN to NONE */
+                        if (link->flags & ATA_LFLAG_ASSUME_ATA)
+                                classes[dev->devno] = ATA_DEV_ATA;
+                        else if (link->flags & ATA_LFLAG_ASSUME_SEMB)
+                                classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
+                        else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
+                                classes[dev->devno] = ATA_DEV_NONE;
+                }
 
                 /* record current link speed */
-                if (sata_scr_read(ap, SCR_STATUS, &sstatus) == 0)
-                        ap->sata_spd = (sstatus >> 4) & 0xf;
+                if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
+                        link->sata_spd = (sstatus >> 4) & 0xf;
 
                 if (postreset)
-                        postreset(ap, classes);
+                        postreset(link, classes);
 
                 /* reset successful, schedule revalidation */
-                ata_eh_done(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
+                ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
                 ehc->i.action |= ATA_EH_REVALIDATE;
         }
  out:
         /* clear hotplug flag */
         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
+
+        spin_lock_irqsave(ap->lock, flags);
+        ap->pflags &= ~ATA_PFLAG_RESETTING;
+        spin_unlock_irqrestore(ap->lock, flags);
+
         return rc;
 }
 
-static int ata_eh_revalidate_and_attach(struct ata_port *ap,
+static int ata_eh_revalidate_and_attach(struct ata_link *link,
                                         struct ata_device **r_failed_dev)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         struct ata_device *dev;
         unsigned int new_mask = 0;
         unsigned long flags;
-        int i, rc = 0;
+        int rc = 0;
 
         DPRINTK("ENTER\n");
 
@@ -1941,27 +2262,28 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
          * be done backwards such that PDIAG- is released by the slave
          * device before the master device is identified.
          */
-        for (i = ATA_MAX_DEVICES - 1; i >= 0; i--) {
-                unsigned int action, readid_flags = 0;
-
-                dev = &ap->device[i];
-                action = ata_eh_dev_action(dev);
+        ata_link_for_each_dev_reverse(dev, link) {
+                unsigned int action = ata_eh_dev_action(dev);
+                unsigned int readid_flags = 0;
 
                 if (ehc->i.flags & ATA_EHI_DID_RESET)
                         readid_flags |= ATA_READID_POSTRESET;
 
                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
-                        if (ata_port_offline(ap)) {
+                        WARN_ON(dev->class == ATA_DEV_PMP);
+
+                        if (ata_link_offline(link)) {
                                 rc = -EIO;
                                 goto err;
                         }
 
-                        ata_eh_about_to_do(ap, dev, ATA_EH_REVALIDATE);
-                        rc = ata_dev_revalidate(dev, readid_flags);
+                        ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
+                        rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
+                                                readid_flags);
                         if (rc)
                                 goto err;
 
-                        ata_eh_done(ap, dev, ATA_EH_REVALIDATE);
+                        ata_eh_done(link, dev, ATA_EH_REVALIDATE);
 
                         /* Configuration may have changed, reconfigure
                          * transfer mode.
@@ -1975,11 +2297,14 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
                            ata_class_enabled(ehc->classes[dev->devno])) {
                         dev->class = ehc->classes[dev->devno];
 
-                        rc = ata_dev_read_id(dev, &dev->class, readid_flags,
-                                             dev->id);
+                        if (dev->class == ATA_DEV_PMP)
+                                rc = sata_pmp_attach(dev);
+                        else
+                                rc = ata_dev_read_id(dev, &dev->class,
+                                                     readid_flags, dev->id);
                         switch (rc) {
                         case 0:
-                                new_mask |= 1 << i;
+                                new_mask |= 1 << dev->devno;
                                 break;
                         case -ENOENT:
                                 /* IDENTIFY was issued to non-existent
@@ -1997,16 +2322,16 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
         }
 
         /* PDIAG- should have been released, ask cable type if post-reset */
-        if ((ehc->i.flags & ATA_EHI_DID_RESET) && ap->ops->cable_detect)
+        if (ata_is_host_link(link) && ap->ops->cable_detect &&
+            (ehc->i.flags & ATA_EHI_DID_RESET))
                 ap->cbl = ap->ops->cable_detect(ap);
 
         /* Configure new devices forward such that user doesn't see
          * device detection messages backwards.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
-                if (!(new_mask & (1 << i)))
+        ata_link_for_each_dev(dev, link) {
+                if (!(new_mask & (1 << dev->devno)) ||
+                    dev->class == ATA_DEV_PMP)
                         continue;
 
                 ehc->i.flags |= ATA_EHI_PRINTINFO;
@@ -2031,40 +2356,44 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
         return rc;
 }
 
-static int ata_port_nr_enabled(struct ata_port *ap)
+static int ata_link_nr_enabled(struct ata_link *link)
 {
-        int i, cnt = 0;
+        struct ata_device *dev;
+        int cnt = 0;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ata_dev_enabled(&ap->device[i]))
+        ata_link_for_each_dev(dev, link)
+                if (ata_dev_enabled(dev))
                         cnt++;
         return cnt;
 }
 
-static int ata_port_nr_vacant(struct ata_port *ap)
+static int ata_link_nr_vacant(struct ata_link *link)
 {
-        int i, cnt = 0;
+        struct ata_device *dev;
+        int cnt = 0;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ap->device[i].class == ATA_DEV_UNKNOWN)
+        ata_link_for_each_dev(dev, link)
+                if (dev->class == ATA_DEV_UNKNOWN)
                         cnt++;
         return cnt;
 }
 
-static int ata_eh_skip_recovery(struct ata_port *ap)
+static int ata_eh_skip_recovery(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
-        int i;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev;
+
+        /* skip disabled links */
+        if (link->flags & ATA_LFLAG_DISABLED)
+                return 1;
 
         /* thaw frozen port, resume link and recover failed devices */
-        if ((ap->pflags & ATA_PFLAG_FROZEN) ||
-            (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_port_nr_enabled(ap))
+        if ((link->ap->pflags & ATA_PFLAG_FROZEN) ||
+            (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_link_nr_enabled(link))
                 return 0;
 
         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 if (dev->class == ATA_DEV_UNKNOWN &&
                     ehc->classes[dev->devno] != ATA_DEV_NONE)
                         return 0;
@@ -2073,10 +2402,9 @@ static int ata_eh_skip_recovery(struct ata_port *ap)
         return 1;
 }
 
-static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
+static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
 
         ehc->tries[dev->devno]--;
 
@@ -2092,7 +2420,7 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                         /* This is the last chance, better to slow
                          * down than lose it.
                          */
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(dev->link);
                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
                 }
         }
@@ -2102,7 +2430,7 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                 ata_dev_disable(dev);
 
                 /* detach if offline */
-                if (ata_port_offline(ap))
+                if (ata_link_offline(dev->link))
                         ata_eh_detach_dev(dev);
 
                 /* probe if requested */
@@ -2115,12 +2443,16 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                         ehc->did_probe_mask |= (1 << dev->devno);
                         ehc->i.action |= ATA_EH_SOFTRESET;
                 }
+
+                return 1;
         } else {
                 /* soft didn't work?  be haaaaard */
                 if (ehc->i.flags & ATA_EHI_DID_RESET)
                         ehc->i.action |= ATA_EH_HARDRESET;
                 else
                         ehc->i.action |= ATA_EH_SOFTRESET;
+
+                return 0;
         }
 }
 
@@ -2131,12 +2463,13 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
  *      @softreset: softreset method (can be NULL)
  *      @hardreset: hardreset method (can be NULL)
  *      @postreset: postreset method (can be NULL)
+ *      @r_failed_link: out parameter for failed link
  *
  *      This is the alpha and omega, eum and yang, heart and soul of
  *      libata exception handling.  On entry, actions required to
- *      recover the port and hotplug requests are recorded in
- *      eh_context.  This function executes all the operations with
- *      appropriate retrials and fallbacks to resurrect failed
+ *      recover each link and hotplug requests are recorded in the
+ *      link's eh_context.  This function executes all the operations
+ *      with appropriate retrials and fallbacks to resurrect failed
  *      devices, detach goners and greet newcomers.
  *
  *      LOCKING:
@@ -2145,104 +2478,171 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
-                          ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
-                          ata_postreset_fn_t postreset)
+int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
+                   ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
+                   ata_postreset_fn_t postreset,
+                   struct ata_link **r_failed_link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_link *link;
         struct ata_device *dev;
-        int i, rc;
+        int nr_failed_devs, nr_disabled_devs;
+        int reset, rc;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
         /* prep for recovery */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
-                ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
-
-                /* collect port action mask recorded in dev actions */
-                ehc->i.action |= ehc->i.dev_action[i] & ~ATA_EH_PERDEV_MASK;
-                ehc->i.dev_action[i] &= ATA_EH_PERDEV_MASK;
-
-                /* process hotplug request */
-                if (dev->flags & ATA_DFLAG_DETACH)
-                        ata_eh_detach_dev(dev);
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
+
+                /* re-enable link? */
+                if (ehc->i.action & ATA_EH_ENABLE_LINK) {
+                        ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
+                        spin_lock_irqsave(ap->lock, flags);
+                        link->flags &= ~ATA_LFLAG_DISABLED;
+                        spin_unlock_irqrestore(ap->lock, flags);
+                        ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
+                }
 
-                if (!ata_dev_enabled(dev) &&
-                    ((ehc->i.probe_mask & (1 << dev->devno)) &&
-                     !(ehc->did_probe_mask & (1 << dev->devno)))) {
-                        ata_eh_detach_dev(dev);
-                        ata_dev_init(dev);
-                        ehc->did_probe_mask |= (1 << dev->devno);
-                        ehc->i.action |= ATA_EH_SOFTRESET;
+                ata_link_for_each_dev(dev, link) {
+                        if (link->flags & ATA_LFLAG_NO_RETRY)
+                                ehc->tries[dev->devno] = 1;
+                        else
+                                ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
+
+                        /* collect port action mask recorded in dev actions */
+                        ehc->i.action |= ehc->i.dev_action[dev->devno] &
+                                         ~ATA_EH_PERDEV_MASK;
+                        ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
+
+                        /* process hotplug request */
+                        if (dev->flags & ATA_DFLAG_DETACH)
+                                ata_eh_detach_dev(dev);
+
+                        if (!ata_dev_enabled(dev) &&
+                            ((ehc->i.probe_mask & (1 << dev->devno)) &&
+                             !(ehc->did_probe_mask & (1 << dev->devno)))) {
+                                ata_eh_detach_dev(dev);
+                                ata_dev_init(dev);
+                                ehc->did_probe_mask |= (1 << dev->devno);
+                                ehc->i.action |= ATA_EH_SOFTRESET;
+                        }
                 }
         }
 
  retry:
         rc = 0;
+        nr_failed_devs = 0;
+        nr_disabled_devs = 0;
+        reset = 0;
 
         /* if UNLOADING, finish immediately */
         if (ap->pflags & ATA_PFLAG_UNLOADING)
                 goto out;
 
-        /* skip EH if possible. */
-        if (ata_eh_skip_recovery(ap))
-                ehc->i.action = 0;
+        /* prep for EH */
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ehc->classes[i] = ATA_DEV_UNKNOWN;
+                /* skip EH if possible. */
+                if (ata_eh_skip_recovery(link))
+                        ehc->i.action = 0;
 
-        /* reset */
-        if (ehc->i.action & ATA_EH_RESET_MASK) {
-                ata_eh_freeze_port(ap);
+                /* do we need to reset? */
+                if (ehc->i.action & ATA_EH_RESET_MASK)
+                        reset = 1;
 
-                rc = ata_eh_reset(ap, ata_port_nr_vacant(ap), prereset,
-                                  softreset, hardreset, postreset);
-                if (rc) {
-                        ata_port_printk(ap, KERN_ERR,
-                                        "reset failed, giving up\n");
-                        goto out;
+                ata_link_for_each_dev(dev, link)
+                        ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
+        }
+
+        /* reset */
+        if (reset) {
+                /* if PMP is attached, this function only deals with
+                 * downstream links, port should stay thawed.
+                 */
+                if (!ap->nr_pmp_links)
+                        ata_eh_freeze_port(ap);
+
+                ata_port_for_each_link(link, ap) {
+                        struct ata_eh_context *ehc = &link->eh_context;
+
+                        if (!(ehc->i.action & ATA_EH_RESET_MASK))
+                                continue;
+
+                        rc = ata_eh_reset(link, ata_link_nr_vacant(link),
+                                          prereset, softreset, hardreset,
+                                          postreset);
+                        if (rc) {
+                                ata_link_printk(link, KERN_ERR,
+                                                "reset failed, giving up\n");
+                                goto out;
+                        }
                 }
 
-                ata_eh_thaw_port(ap);
+                if (!ap->nr_pmp_links)
+                        ata_eh_thaw_port(ap);
         }
 
-        /* revalidate existing devices and attach new ones */
-        rc = ata_eh_revalidate_and_attach(ap, &dev);
-        if (rc)
-                goto dev_fail;
+        /* the rest */
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
 
-        /* configure transfer mode if necessary */
-        if (ehc->i.flags & ATA_EHI_SETMODE) {
-                rc = ata_set_mode(ap, &dev);
+                /* revalidate existing devices and attach new ones */
+                rc = ata_eh_revalidate_and_attach(link, &dev);
                 if (rc)
                         goto dev_fail;
-                ehc->i.flags &= ~ATA_EHI_SETMODE;
-        }
 
-        goto out;
+                /* if PMP got attached, return, pmp EH will take care of it */
+                if (link->device->class == ATA_DEV_PMP) {
+                        ehc->i.action = 0;
+                        return 0;
+                }
 
- dev_fail:
-        ata_eh_handle_dev_fail(dev, rc);
+                /* configure transfer mode if necessary */
+                if (ehc->i.flags & ATA_EHI_SETMODE) {
+                        rc = ata_set_mode(link, &dev);
+                        if (rc)
+                                goto dev_fail;
+                        ehc->i.flags &= ~ATA_EHI_SETMODE;
+                }
 
-        if (ata_port_nr_enabled(ap)) {
-                ata_port_printk(ap, KERN_WARNING, "failed to recover some "
-                                "devices, retrying in 5 secs\n");
-                ssleep(5);
-        } else {
-                /* no device left, repeat fast */
-                msleep(500);
+                /* this link is okay now */
+                ehc->i.flags = 0;
+                continue;
+
+        dev_fail:
+                nr_failed_devs++;
+                if (ata_eh_handle_dev_fail(dev, rc))
+                        nr_disabled_devs++;
+
+                if (ap->pflags & ATA_PFLAG_FROZEN) {
+                        /* PMP reset requires working host port.
+                         * Can't retry if it's frozen.
+                         */
+                        if (ap->nr_pmp_links)
+                                goto out;
+                        break;
+                }
         }
 
-        goto retry;
+        if (nr_failed_devs) {
+                if (nr_failed_devs != nr_disabled_devs) {
+                        ata_port_printk(ap, KERN_WARNING, "failed to recover "
+                                        "some devices, retrying in 5 secs\n");
+                        ssleep(5);
+                } else {
+                        /* no device left to recover, repeat fast */
+                        msleep(500);
+                }
 
- out:
-        if (rc) {
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ata_dev_disable(&ap->device[i]);
+                goto retry;
         }
 
+ out:
+        if (rc && r_failed_link)
+                *r_failed_link = link;
+
         DPRINTK("EXIT, rc=%d\n", rc);
         return rc;
 }
@@ -2257,7 +2657,7 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
  *      LOCKING:
  *      None.
  */
-static void ata_eh_finish(struct ata_port *ap)
+void ata_eh_finish(struct ata_port *ap)
 {
         int tag;
 
@@ -2287,6 +2687,10 @@ static void ata_eh_finish(struct ata_port *ap)
                         }
                 }
         }
+
+        /* make sure nr_active_links is zero after EH */
+        WARN_ON(ap->nr_active_links);
+        ap->nr_active_links = 0;
 }
 
 /**
@@ -2306,9 +2710,19 @@ void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
                ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
                ata_postreset_fn_t postreset)
 {
+        struct ata_device *dev;
+        int rc;
+
         ata_eh_autopsy(ap);
         ata_eh_report(ap);
-        ata_eh_recover(ap, prereset, softreset, hardreset, postreset);
+
+        rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
+                            NULL);
+        if (rc) {
+                ata_link_for_each_dev(dev, &ap->link)
+                        ata_dev_disable(dev);
+        }
+
         ata_eh_finish(ap);
 }
 
diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
new file mode 100644
index 0000000000..c0c4dbcde0
--- /dev/null
+++ b/drivers/ata/libata-pmp.c
@@ -0,0 +1,1191 @@
+/*
+ * libata-pmp.c - libata port multiplier support
+ *
+ * Copyright (c) 2007  SUSE Linux Products GmbH
+ * Copyright (c) 2007  Tejun Heo <teheo@suse.de>
+ *
+ * This file is released under the GPLv2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/libata.h>
+#include "libata.h"
+
+/**
+ *      sata_pmp_read - read PMP register
+ *      @link: link to read PMP register for
+ *      @reg: register to read
+ *      @r_val: resulting value
+ *
+ *      Read PMP register.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask on failure.
+ */
+static unsigned int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *pmp_dev = ap->link.device;
+        struct ata_taskfile tf;
+        unsigned int err_mask;
+
+        ata_tf_init(pmp_dev, &tf);
+        tf.command = ATA_CMD_PMP_READ;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.feature = reg;
+        tf.device = link->pmp;
+
+        err_mask = ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
+                                     SATA_PMP_SCR_TIMEOUT);
+        if (err_mask)
+                return err_mask;
+
+        *r_val = tf.nsect | tf.lbal << 8 | tf.lbam << 16 | tf.lbah << 24;
+        return 0;
+}
+
+/**
+ *      sata_pmp_write - write PMP register
+ *      @link: link to write PMP register for
+ *      @reg: register to write
+ *      @r_val: value to write
+ *
+ *      Write PMP register.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask on failure.
+ */
+static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *pmp_dev = ap->link.device;
+        struct ata_taskfile tf;
+
+        ata_tf_init(pmp_dev, &tf);
+        tf.command = ATA_CMD_PMP_WRITE;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.feature = reg;
+        tf.device = link->pmp;
+        tf.nsect = val & 0xff;
+        tf.lbal = (val >> 8) & 0xff;
+        tf.lbam = (val >> 16) & 0xff;
+        tf.lbah = (val >> 24) & 0xff;
+
+        return ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
+                                 SATA_PMP_SCR_TIMEOUT);
+}
+
+/**
+ *      sata_pmp_qc_defer_cmd_switch - qc_defer for command switching PMP
+ *      @qc: ATA command in question
+ *
+ *      A host which has command switching PMP support cannot issue
+ *      commands to multiple links simultaneously.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      ATA_DEFER_* if deferring is needed, 0 otherwise.
+ */
+int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+        struct ata_port *ap = link->ap;
+
+        if (ap->excl_link == NULL || ap->excl_link == link) {
+                if (ap->nr_active_links == 0 || ata_link_active(link)) {
+                        qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+                        return ata_std_qc_defer(qc);
+                }
+
+                ap->excl_link = link;
+        }
+
+        return ATA_DEFER_PORT;
+}
+
+/**
+ *      sata_pmp_scr_read - read PSCR
+ *      @link: ATA link to read PSCR for
+ *      @reg: PSCR to read
+ *      @r_val: resulting value
+ *
+ *      Read PSCR @reg into @r_val for @link, to be called from
+ *      ata_scr_read().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
+{
+        unsigned int err_mask;
+
+        if (reg > SATA_PMP_PSCR_CONTROL)
+                return -EINVAL;
+
+        err_mask = sata_pmp_read(link, reg, r_val);
+        if (err_mask) {
+                ata_link_printk(link, KERN_WARNING, "failed to read SCR %d "
+                                "(Emask=0x%x)\n", reg, err_mask);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
+ *      sata_pmp_scr_write - write PSCR
+ *      @link: ATA link to write PSCR for
+ *      @reg: PSCR to write
+ *      @val: value to be written
+ *
+ *      Write @val to PSCR @reg for @link, to be called from
+ *      ata_scr_write() and ata_scr_write_flush().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
+{
+        unsigned int err_mask;
+
+        if (reg > SATA_PMP_PSCR_CONTROL)
+                return -EINVAL;
+
+        err_mask = sata_pmp_write(link, reg, val);
+        if (err_mask) {
+                ata_link_printk(link, KERN_WARNING, "failed to write SCR %d "
+                                "(Emask=0x%x)\n", reg, err_mask);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
+ *      sata_pmp_std_prereset - prepare PMP link for reset
+ *      @link: link to be reset
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      @link is about to be reset.  Initialize it.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline)
+{
+        struct ata_eh_context *ehc = &link->eh_context;
+        const unsigned long *timing = sata_ehc_deb_timing(ehc);
+        int rc;
+
+        /* force HRST? */
+        if (link->flags & ATA_LFLAG_NO_SRST)
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* handle link resume */
+        if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
+            (link->flags & ATA_LFLAG_HRST_TO_RESUME))
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* if we're about to do hardreset, nothing more to do */
+        if (ehc->i.action & ATA_EH_HARDRESET)
+                return 0;
+
+        /* resume link */
+        rc = sata_link_resume(link, timing, deadline);
+        if (rc) {
+                /* phy resume failed */
+                ata_link_printk(link, KERN_WARNING, "failed to resume link "
+                                "for reset (errno=%d)\n", rc);
+                return rc;
+        }
+
+        /* clear SError bits including .X which blocks the port when set */
+        rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "failed to clear SError (errno=%d)\n", rc);
+                return rc;
+        }
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_std_hardreset - standard hardreset method for PMP link
+ *      @link: link to be reset
+ *      @class: resulting class of attached device
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      Hardreset PMP port @link.  Note that this function doesn't
+ *      wait for BSY clearance.  There simply isn't a generic way to
+ *      wait the event.  Instead, this function return -EAGAIN thus
+ *      telling libata-EH to followup with softreset.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
+                           unsigned long deadline)
+{
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
+        u32 tmp;
+        int rc;
+
+        DPRINTK("ENTER\n");
+
+        /* do hardreset */
+        rc = sata_link_hardreset(link, timing, deadline);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "COMRESET failed (errno=%d)\n", rc);
+                goto out;
+        }
+
+        /* clear SError bits including .X which blocks the port when set */
+        rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR, "failed to clear SError "
+                                "during hardreset (errno=%d)\n", rc);
+                goto out;
+        }
+
+        /* if device is present, follow up with srst to wait for !BSY */
+        if (ata_link_online(link))
+                rc = -EAGAIN;
+ out:
+        /* if SCR isn't accessible, we need to reset the PMP */
+        if (rc && rc != -EAGAIN && sata_scr_read(link, SCR_STATUS, &tmp))
+                rc = -ERESTART;
+
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+/**
+ *      ata_std_postreset - standard postreset method for PMP link
+ *      @link: the target ata_link
+ *      @classes: classes of attached devices
+ *
+ *      This function is invoked after a successful reset.  Note that
+ *      the device might have been reset more than once using
+ *      different reset methods before postreset is invoked.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ */
+void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
+{
+        u32 serror;
+
+        DPRINTK("ENTER\n");
+
+        /* clear SError */
+        if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
+                sata_scr_write(link, SCR_ERROR, serror);
+
+        /* print link status */
+        sata_print_link_status(link);
+
+        DPRINTK("EXIT\n");
+}
+
+/**
+ *      sata_pmp_read_gscr - read GSCR block of SATA PMP
+ *      @dev: PMP device
+ *      @gscr: buffer to read GSCR block into
+ *
+ *      Read selected PMP GSCRs from the PMP at @dev.  This will serve
+ *      as configuration and identification info for the PMP.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
+{
+        static const int gscr_to_read[] = { 0, 1, 2, 32, 33, 64, 96 };
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(gscr_to_read); i++) {
+                int reg = gscr_to_read[i];
+                unsigned int err_mask;
+
+                err_mask = sata_pmp_read(dev->link, reg, &gscr[reg]);
+                if (err_mask) {
+                        ata_dev_printk(dev, KERN_ERR, "failed to read PMP "
+                                "GSCR[%d] (Emask=0x%x)\n", reg, err_mask);
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+static const char *sata_pmp_spec_rev_str(const u32 *gscr)
+{
+        u32 rev = gscr[SATA_PMP_GSCR_REV];
+
+        if (rev & (1 << 2))
+                return "1.1";
+        if (rev & (1 << 1))
+                return "1.0";
+        return "<unknown>";
+}
+
+static int sata_pmp_configure(struct ata_device *dev, int print_info)
+{
+        struct ata_port *ap = dev->link->ap;
+        u32 *gscr = dev->gscr;
+        unsigned int err_mask = 0;
+        const char *reason;
+        int nr_ports, rc;
+
+        nr_ports = sata_pmp_gscr_ports(gscr);
+
+        if (nr_ports <= 0 || nr_ports > SATA_PMP_MAX_PORTS) {
+                rc = -EINVAL;
+                reason = "invalid nr_ports";
+                goto fail;
+        }
+
+        if ((ap->flags & ATA_FLAG_AN) &&
+            (gscr[SATA_PMP_GSCR_FEAT] & SATA_PMP_FEAT_NOTIFY))
+                dev->flags |= ATA_DFLAG_AN;
+
+        /* monitor SERR_PHYRDY_CHG on fan-out ports */
+        err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_ERROR_EN,
+                                  SERR_PHYRDY_CHG);
+        if (err_mask) {
+                rc = -EIO;
+                reason = "failed to write GSCR_ERROR_EN";
+                goto fail;
+        }
+
+        /* turn off notification till fan-out ports are reset and configured */
+        if (gscr[SATA_PMP_GSCR_FEAT_EN] & SATA_PMP_FEAT_NOTIFY) {
+                gscr[SATA_PMP_GSCR_FEAT_EN] &= ~SATA_PMP_FEAT_NOTIFY;
+
+                err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_FEAT_EN,
+                                          gscr[SATA_PMP_GSCR_FEAT_EN]);
+                if (err_mask) {
+                        rc = -EIO;
+                        reason = "failed to write GSCR_FEAT_EN";
+                        goto fail;
+                }
+        }
+
+        if (print_info) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier %s, "
+                               "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
+                               sata_pmp_spec_rev_str(gscr),
+                               sata_pmp_gscr_vendor(gscr),
+                               sata_pmp_gscr_devid(gscr),
+                               sata_pmp_gscr_rev(gscr),
+                               nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
+                               gscr[SATA_PMP_GSCR_FEAT]);
+
+                if (!(dev->flags & ATA_DFLAG_AN))
+                        ata_dev_printk(dev, KERN_INFO,
+                                "Asynchronous notification not supported, "
+                                "hotplug won't\n         work on fan-out "
+                                "ports. Use warm-plug instead.\n");
+        }
+
+        return 0;
+
+ fail:
+        ata_dev_printk(dev, KERN_ERR,
+                       "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
+                       reason, err_mask);
+        return rc;
+}
+
+static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
+{
+        struct ata_link *pmp_link = ap->pmp_link;
+        int i;
+
+        if (!pmp_link) {
+                pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS,
+                                   GFP_NOIO);
+                if (!pmp_link)
+                        return -ENOMEM;
+
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                        ata_link_init(ap, &pmp_link[i], i);
+
+                ap->pmp_link = pmp_link;
+        }
+
+        for (i = 0; i < nr_ports; i++) {
+                struct ata_link *link = &pmp_link[i];
+                struct ata_eh_context *ehc = &link->eh_context;
+
+                link->flags = 0;
+                ehc->i.probe_mask |= 1;
+                ehc->i.action |= ATA_EH_SOFTRESET;
+                ehc->i.flags |= ATA_EHI_RESUME_LINK;
+        }
+
+        return 0;
+}
+
+static void sata_pmp_quirks(struct ata_port *ap)
+{
+        u32 *gscr = ap->link.device->gscr;
+        u16 vendor = sata_pmp_gscr_vendor(gscr);
+        u16 devid = sata_pmp_gscr_devid(gscr);
+        struct ata_link *link;
+
+        if (vendor == 0x1095 && devid == 0x3726) {
+                /* sil3726 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 5)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* port 5 is for SEMB device and it doesn't like SRST */
+                        if (link->pmp == 5)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_SEMB;
+                }
+        } else if (vendor == 0x1095 && devid == 0x4723) {
+                /* sil4723 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 2)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* the config device at port 2 locks up on SRST */
+                        if (link->pmp == 2)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_ATA;
+                }
+        } else if (vendor == 0x1095 && devid == 0x4726) {
+                /* sil4726 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 5)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* The config device, which can be either at
+                         * port 0 or 5, locks up on SRST.
+                         */
+                        if (link->pmp == 0 || link->pmp == 5)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_ATA;
+
+                        /* Port 6 is for SEMB device which doesn't
+                         * like SRST either.
+                         */
+                        if (link->pmp == 6)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_SEMB;
+                }
+        } else if (vendor == 0x1095 && (devid == 0x5723 || devid == 0x5733 ||
+                                        devid == 0x5734 || devid == 0x5744)) {
+                /* sil5723/5744 quirks */
+
+                /* sil5723/5744 has either two or three downstream
+                 * ports depending on operation mode.  The last port
+                 * is empty if any actual IO device is available or
+                 * occupied by a pseudo configuration device
+                 * otherwise.  Don't try hard to recover it.
+                 */
+                ap->pmp_link[ap->nr_pmp_links - 1].flags |= ATA_LFLAG_NO_RETRY;
+        } else if (vendor == 0x11ab && devid == 0x4140) {
+                /* Marvell 88SM4140 quirks.  Fan-out ports require PHY
+                 * reset to work; other than that, it behaves very
+                 * nicely.
+                 */
+                ata_port_for_each_link(link, ap)
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+        }
+}
+
+/**
+ *      sata_pmp_attach - attach a SATA PMP device
+ *      @dev: SATA PMP device to attach
+ *
+ *      Configure and attach SATA PMP device @dev.  This function is
+ *      also responsible for allocating and initializing PMP links.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_attach(struct ata_device *dev)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        unsigned long flags;
+        struct ata_link *tlink;
+        int rc;
+
+        /* is it hanging off the right place? */
+        if (!(ap->flags & ATA_FLAG_PMP)) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "host does not support Port Multiplier\n");
+                return -EINVAL;
+        }
+
+        if (!ata_is_host_link(link)) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "Port Multipliers cannot be nested\n");
+                return -EINVAL;
+        }
+
+        if (dev->devno) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "Port Multiplier must be the first device\n");
+                return -EINVAL;
+        }
+
+        WARN_ON(link->pmp != 0);
+        link->pmp = SATA_PMP_CTRL_PORT;
+
+        /* read GSCR block */
+        rc = sata_pmp_read_gscr(dev, dev->gscr);
+        if (rc)
+                goto fail;
+
+        /* config PMP */
+        rc = sata_pmp_configure(dev, 1);
+        if (rc)
+                goto fail;
+
+        rc = sata_pmp_init_links(ap, sata_pmp_gscr_ports(dev->gscr));
+        if (rc) {
+                ata_dev_printk(dev, KERN_INFO,
+                               "failed to initialize PMP links\n");
+                goto fail;
+        }
+
+        /* attach it */
+        spin_lock_irqsave(ap->lock, flags);
+        WARN_ON(ap->nr_pmp_links);
+        ap->nr_pmp_links = sata_pmp_gscr_ports(dev->gscr);
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        sata_pmp_quirks(ap);
+
+        if (ap->ops->pmp_attach)
+                ap->ops->pmp_attach(ap);
+
+        ata_port_for_each_link(tlink, ap)
+                sata_link_init_spd(tlink);
+
+        ata_acpi_associate_sata_port(ap);
+
+        return 0;
+
+ fail:
+        link->pmp = 0;
+        return rc;
+}
+
+/**
+ *      sata_pmp_detach - detach a SATA PMP device
+ *      @dev: SATA PMP device to detach
+ *
+ *      Detach SATA PMP device @dev.  This function is also
+ *      responsible for deconfiguring PMP links.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+static void sata_pmp_detach(struct ata_device *dev)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        struct ata_link *tlink;
+        unsigned long flags;
+
+        ata_dev_printk(dev, KERN_INFO, "Port Multiplier detaching\n");
+
+        WARN_ON(!ata_is_host_link(link) || dev->devno ||
+                link->pmp != SATA_PMP_CTRL_PORT);
+
+        if (ap->ops->pmp_detach)
+                ap->ops->pmp_detach(ap);
+
+        ata_port_for_each_link(tlink, ap)
+                ata_eh_detach_dev(tlink->device);
+
+        spin_lock_irqsave(ap->lock, flags);
+        ap->nr_pmp_links = 0;
+        link->pmp = 0;
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        ata_acpi_associate_sata_port(ap);
+}
+
+/**
+ *      sata_pmp_same_pmp - does new GSCR matches the configured PMP?
+ *      @dev: PMP device to compare against
+ *      @new_gscr: GSCR block of the new device
+ *
+ *      Compare @new_gscr against @dev and determine whether @dev is
+ *      the PMP described by @new_gscr.
+ *
+ *      LOCKING:
+ *      None.
+ *
+ *      RETURNS:
+ *      1 if @dev matches @new_gscr, 0 otherwise.
+ */
+static int sata_pmp_same_pmp(struct ata_device *dev, const u32 *new_gscr)
+{
+        const u32 *old_gscr = dev->gscr;
+        u16 old_vendor, new_vendor, old_devid, new_devid;
+        int old_nr_ports, new_nr_ports;
+
+        old_vendor = sata_pmp_gscr_vendor(old_gscr);
+        new_vendor = sata_pmp_gscr_vendor(new_gscr);
+        old_devid = sata_pmp_gscr_devid(old_gscr);
+        new_devid = sata_pmp_gscr_devid(new_gscr);
+        old_nr_ports = sata_pmp_gscr_ports(old_gscr);
+        new_nr_ports = sata_pmp_gscr_ports(new_gscr);
+
+        if (old_vendor != new_vendor) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "vendor mismatch '0x%x' != '0x%x'\n",
+                               old_vendor, new_vendor);
+                return 0;
+        }
+
+        if (old_devid != new_devid) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "device ID mismatch '0x%x' != '0x%x'\n",
+                               old_devid, new_devid);
+                return 0;
+        }
+
+        if (old_nr_ports != new_nr_ports) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "nr_ports mismatch '0x%x' != '0x%x'\n",
+                               old_nr_ports, new_nr_ports);
+                return 0;
+        }
+
+        return 1;
+}
+
+/**
+ *      sata_pmp_revalidate - revalidate SATA PMP
+ *      @dev: PMP device to revalidate
+ *      @new_class: new class code
+ *
+ *      Re-read GSCR block and make sure @dev is still attached to the
+ *      port and properly configured.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        u32 *gscr = (void *)ap->sector_buf;
+        int rc;
+
+        DPRINTK("ENTER\n");
+
+        ata_eh_about_to_do(link, NULL, ATA_EH_REVALIDATE);
+
+        if (!ata_dev_enabled(dev)) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        /* wrong class? */
+        if (ata_class_enabled(new_class) && new_class != ATA_DEV_PMP) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        /* read GSCR */
+        rc = sata_pmp_read_gscr(dev, gscr);
+        if (rc)
+                goto fail;
+
+        /* is the pmp still there? */
+        if (!sata_pmp_same_pmp(dev, gscr)) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        memcpy(dev->gscr, gscr, sizeof(gscr[0]) * SATA_PMP_GSCR_DWORDS);
+
+        rc = sata_pmp_configure(dev, 0);
+        if (rc)
+                goto fail;
+
+        ata_eh_done(link, NULL, ATA_EH_REVALIDATE);
+
+        DPRINTK("EXIT, rc=0\n");
+        return 0;
+
+ fail:
+        ata_dev_printk(dev, KERN_ERR,
+                       "PMP revalidation failed (errno=%d)\n", rc);
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+/**
+ *      sata_pmp_revalidate_quick - revalidate SATA PMP quickly
+ *      @dev: PMP device to revalidate
+ *
+ *      Make sure the attached PMP is accessible.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+static int sata_pmp_revalidate_quick(struct ata_device *dev)
+{
+        unsigned int err_mask;
+        u32 prod_id;
+
+        err_mask = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID "
+                               "(Emask=0x%x)\n", err_mask);
+                return -EIO;
+        }
+
+        if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
+                ata_dev_printk(dev, KERN_ERR, "PMP product ID mismatch\n");
+                /* something weird is going on, request full PMP recovery */
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_eh_recover_pmp - recover PMP
+ *      @ap: ATA port PMP is attached to
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *
+ *      Recover PMP attached to @ap.  Recovery procedure is somewhat
+ *      similar to that of ata_eh_recover() except that reset should
+ *      always be performed in hard->soft sequence and recovery
+ *      failure results in PMP detachment.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
+                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
+{
+        struct ata_link *link = &ap->link;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev = link->device;
+        int tries = ATA_EH_PMP_TRIES;
+        int detach = 0, rc = 0;
+        int reval_failed = 0;
+
+        DPRINTK("ENTER\n");
+
+        if (dev->flags & ATA_DFLAG_DETACH) {
+                detach = 1;
+                goto fail;
+        }
+
+ retry:
+        ehc->classes[0] = ATA_DEV_UNKNOWN;
+
+        if (ehc->i.action & ATA_EH_RESET_MASK) {
+                struct ata_link *tlink;
+
+                ata_eh_freeze_port(ap);
+
+                /* reset */
+                ehc->i.action = ATA_EH_HARDRESET;
+                rc = ata_eh_reset(link, 0, prereset, softreset, hardreset,
+                                  postreset);
+                if (rc) {
+                        ata_link_printk(link, KERN_ERR,
+                                        "failed to reset PMP, giving up\n");
+                        goto fail;
+                }
+
+                ata_eh_thaw_port(ap);
+
+                /* PMP is reset, SErrors cannot be trusted, scan all */
+                ata_port_for_each_link(tlink, ap)
+                        ata_ehi_schedule_probe(&tlink->eh_context.i);
+        }
+
+        /* If revalidation is requested, revalidate and reconfigure;
+         * otherwise, do quick revalidation.
+         */
+        if (ehc->i.action & ATA_EH_REVALIDATE)
+                rc = sata_pmp_revalidate(dev, ehc->classes[0]);
+        else
+                rc = sata_pmp_revalidate_quick(dev);
+
+        if (rc) {
+                tries--;
+
+                if (rc == -ENODEV) {
+                        ehc->i.probe_mask |= 1;
+                        detach = 1;
+                        /* give it just two more chances */
+                        tries = min(tries, 2);
+                }
+
+                if (tries) {
+                        int sleep = ehc->i.flags & ATA_EHI_DID_RESET;
+
+                        /* consecutive revalidation failures? speed down */
+                        if (reval_failed)
+                                sata_down_spd_limit(link);
+                        else
+                                reval_failed = 1;
+
+                        ata_dev_printk(dev, KERN_WARNING,
+                                       "retrying hardreset%s\n",
+                                       sleep ? " in 5 secs" : "");
+                        if (sleep)
+                                ssleep(5);
+                        ehc->i.action |= ATA_EH_HARDRESET;
+                        goto retry;
+                } else {
+                        ata_dev_printk(dev, KERN_ERR, "failed to recover PMP "
+                                       "after %d tries, giving up\n",
+                                       ATA_EH_PMP_TRIES);
+                        goto fail;
+                }
+        }
+
+        /* okay, PMP resurrected */
+        ehc->i.flags = 0;
+
+        DPRINTK("EXIT, rc=0\n");
+        return 0;
+
+ fail:
+        sata_pmp_detach(dev);
+        if (detach)
+                ata_eh_detach_dev(dev);
+        else
+                ata_dev_disable(dev);
+
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
+{
+        struct ata_link *link;
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(ap->lock, flags);
+
+        ata_port_for_each_link(link, ap) {
+                if (!(link->flags & ATA_LFLAG_DISABLED))
+                        continue;
+
+                spin_unlock_irqrestore(ap->lock, flags);
+
+                /* Some PMPs require hardreset sequence to get
+                 * SError.N working.
+                 */
+                if ((link->flags & ATA_LFLAG_HRST_TO_RESUME) &&
+                    (link->eh_context.i.flags & ATA_EHI_RESUME_LINK))
+                        sata_link_hardreset(link, sata_deb_timing_normal,
+                                            jiffies + ATA_TMOUT_INTERNAL_QUICK);
+
+                /* unconditionally clear SError.N */
+                rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
+                if (rc) {
+                        ata_link_printk(link, KERN_ERR, "failed to clear "
+                                        "SError.N (errno=%d)\n", rc);
+                        return rc;
+                }
+
+                spin_lock_irqsave(ap->lock, flags);
+        }
+
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        return 0;
+}
+
+static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
+{
+        struct ata_port *ap = link->ap;
+        unsigned long flags;
+
+        if (link_tries[link->pmp] && --link_tries[link->pmp])
+                return 1;
+
+        /* disable this link */
+        if (!(link->flags & ATA_LFLAG_DISABLED)) {
+                ata_link_printk(link, KERN_WARNING,
+                        "failed to recover link after %d tries, disabling\n",
+                        ATA_EH_PMP_LINK_TRIES);
+
+                spin_lock_irqsave(ap->lock, flags);
+                link->flags |= ATA_LFLAG_DISABLED;
+                spin_unlock_irqrestore(ap->lock, flags);
+        }
+
+        ata_dev_disable(link->device);
+        link->eh_context.i.action = 0;
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_eh_recover - recover PMP-enabled port
+ *      @ap: ATA port to recover
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *      @pmp_prereset: PMP prereset method (can be NULL)
+ *      @pmp_softreset: PMP softreset method (can be NULL)
+ *      @pmp_hardreset: PMP hardreset method (can be NULL)
+ *      @pmp_postreset: PMP postreset method (can be NULL)
+ *
+ *      Drive EH recovery operation for PMP enabled port @ap.  This
+ *      function recovers host and PMP ports with proper retrials and
+ *      fallbacks.  Actual recovery operations are performed using
+ *      ata_eh_recover() and sata_pmp_eh_recover_pmp().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_eh_recover(struct ata_port *ap,
+                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
+                ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
+                ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)
+{
+        int pmp_tries, link_tries[SATA_PMP_MAX_PORTS];
+        struct ata_link *pmp_link = &ap->link;
+        struct ata_device *pmp_dev = pmp_link->device;
+        struct ata_eh_context *pmp_ehc = &pmp_link->eh_context;
+        struct ata_link *link;
+        struct ata_device *dev;
+        unsigned int err_mask;
+        u32 gscr_error, sntf;
+        int cnt, rc;
+
+        pmp_tries = ATA_EH_PMP_TRIES;
+        ata_port_for_each_link(link, ap)
+                link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
+
+ retry:
+        /* PMP attached? */
+        if (!ap->nr_pmp_links) {
+                rc = ata_eh_recover(ap, prereset, softreset, hardreset,
+                                    postreset, NULL);
+                if (rc) {
+                        ata_link_for_each_dev(dev, &ap->link)
+                                ata_dev_disable(dev);
+                        return rc;
+                }
+
+                if (pmp_dev->class != ATA_DEV_PMP)
+                        return 0;
+
+                /* new PMP online */
+                ata_port_for_each_link(link, ap)
+                        link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
+
+                /* fall through */
+        }
+
+        /* recover pmp */
+        rc = sata_pmp_eh_recover_pmp(ap, prereset, softreset, hardreset,
+                                     postreset);
+        if (rc)
+                goto pmp_fail;
+
+        /* handle disabled links */
+        rc = sata_pmp_eh_handle_disabled_links(ap);
+        if (rc)
+                goto pmp_fail;
+
+        /* recover links */
+        rc = ata_eh_recover(ap, pmp_prereset, pmp_softreset, pmp_hardreset,
+                            pmp_postreset, &link);
+        if (rc)
+                goto link_fail;
+
+        /* Connection status might have changed while resetting other
+         * links, check SATA_PMP_GSCR_ERROR before returning.
+         */
+
+        /* clear SNotification */
+        rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
+        if (rc == 0)
+                sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
+
+        /* enable notification */
+        if (pmp_dev->flags & ATA_DFLAG_AN) {
+                pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
+
+                err_mask = sata_pmp_write(pmp_dev->link, SATA_PMP_GSCR_FEAT_EN,
+                                          pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN]);
+                if (err_mask) {
+                        ata_dev_printk(pmp_dev, KERN_ERR, "failed to write "
+                                       "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
+                        rc = -EIO;
+                        goto pmp_fail;
+                }
+        }
+
+        /* check GSCR_ERROR */
+        err_mask = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
+        if (err_mask) {
+                ata_dev_printk(pmp_dev, KERN_ERR, "failed to read "
+                               "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask);
+                rc = -EIO;
+                goto pmp_fail;
+        }
+
+        cnt = 0;
+        ata_port_for_each_link(link, ap) {
+                if (!(gscr_error & (1 << link->pmp)))
+                        continue;
+
+                if (sata_pmp_handle_link_fail(link, link_tries)) {
+                        ata_ehi_hotplugged(&link->eh_context.i);
+                        cnt++;
+                } else {
+                        ata_link_printk(link, KERN_WARNING,
+                                "PHY status changed but maxed out on retries, "
+                                "giving up\n");
+                        ata_link_printk(link, KERN_WARNING,
+                                "Manully issue scan to resume this link\n");
+                }
+        }
+
+        if (cnt) {
+                ata_port_printk(ap, KERN_INFO, "PMP SError.N set for some "
+                                "ports, repeating recovery\n");
+                goto retry;
+        }
+
+        return 0;
+
+ link_fail:
+        if (sata_pmp_handle_link_fail(link, link_tries)) {
+                pmp_ehc->i.action |= ATA_EH_HARDRESET;
+                goto retry;
+        }
+
+        /* fall through */
+ pmp_fail:
+        /* Control always ends up here after detaching PMP.  Shut up
+         * and return if we're unloading.
+         */
+        if (ap->pflags & ATA_PFLAG_UNLOADING)
+                return rc;
+
+        if (!ap->nr_pmp_links)
+                goto retry;
+
+        if (--pmp_tries) {
+                ata_port_printk(ap, KERN_WARNING,
+                                "failed to recover PMP, retrying in 5 secs\n");
+                pmp_ehc->i.action |= ATA_EH_HARDRESET;
+                ssleep(5);
+                goto retry;
+        }
+
+        ata_port_printk(ap, KERN_ERR,
+                        "failed to recover PMP after %d tries, giving up\n",
+                        ATA_EH_PMP_TRIES);
+        sata_pmp_detach(pmp_dev);
+        ata_dev_disable(pmp_dev);
+
+        return rc;
+}
+
+/**
+ *      sata_pmp_do_eh - do standard error handling for PMP-enabled host
+ *      @ap: host port to handle error for
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *      @pmp_prereset: PMP prereset method (can be NULL)
+ *      @pmp_softreset: PMP softreset method (can be NULL)
+ *      @pmp_hardreset: PMP hardreset method (can be NULL)
+ *      @pmp_postreset: PMP postreset method (can be NULL)
+ *
+ *      Perform standard error handling sequence for PMP-enabled host
+ *      @ap.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+void sata_pmp_do_eh(struct ata_port *ap,
+                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
+                ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
+                ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)
+{
+        ata_eh_autopsy(ap);
+        ata_eh_report(ap);
+        sata_pmp_eh_recover(ap, prereset, softreset, hardreset, postreset,
+                            pmp_prereset, pmp_softreset, pmp_hardreset,
+                            pmp_postreset);
+        ata_eh_finish(ap);
+}
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index e83647651b..ea53e6a570 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -71,11 +71,10 @@ static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
 #define ALL_SUB_MPAGES 0xff
 
 
-static const u8 def_rw_recovery_mpage[] = {
+static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
         RW_RECOVERY_MPAGE,
         RW_RECOVERY_MPAGE_LEN - 2,
-        (1 << 7) |      /* AWRE, sat-r06 say it shall be 0 */
-            (1 << 6),   /* ARRE (auto read reallocation) */
+        (1 << 7),       /* AWRE */
         0,              /* read retry count */
         0, 0, 0, 0,
         0,              /* write retry count */
@@ -450,13 +449,8 @@ static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
                 qc->scsicmd = cmd;
                 qc->scsidone = done;
 
-                if (cmd->use_sg) {
-                        qc->__sg = (struct scatterlist *) cmd->request_buffer;
-                        qc->n_elem = cmd->use_sg;
-                } else if (cmd->request_bufflen) {
-                        qc->__sg = &qc->sgent;
-                        qc->n_elem = 1;
-                }
+                qc->__sg = scsi_sglist(cmd);
+                qc->n_elem = scsi_sg_count(cmd);
         } else {
                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
                 done(cmd);
@@ -755,6 +749,13 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
 {
         sdev->use_10_for_rw = 1;
         sdev->use_10_for_ms = 1;
+
+        /* Schedule policy is determined by ->qc_defer() callback and
+         * it needs to see every deferred qc.  Set dev_blocked to 1 to
+         * prevent SCSI midlayer from automatically deferring
+         * requests.
+         */
+        sdev->max_device_blocked = 1;
 }
 
 static void ata_scsi_dev_config(struct scsi_device *sdev,
@@ -943,6 +944,13 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
                 goto invalid_fld;       /* LOEJ bit set not supported */
         if (((cdb[4] >> 4) & 0xf) != 0)
                 goto invalid_fld;       /* power conditions not supported */
+
+        if (qc->dev->horkage & ATA_HORKAGE_SKIP_PM) {
+                /* the device lacks PM support, finish without doing anything */
+                scmd->result = SAM_STAT_GOOD;
+                return 1;
+        }
+
         if (cdb[4] & 0x1) {
                 tf->nsect = 1;  /* 1 sector, lba=0 */
 
@@ -1368,14 +1376,14 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
                 case ATA_CMD_SET_FEATURES:
                         if ((qc->tf.feature == SETFEATURES_WC_ON) ||
                             (qc->tf.feature == SETFEATURES_WC_OFF)) {
-                                ap->eh_info.action |= ATA_EH_REVALIDATE;
+                                ap->link.eh_info.action |= ATA_EH_REVALIDATE;
                                 ata_port_schedule_eh(ap);
                         }
                         break;
 
                 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
                 case ATA_CMD_SET_MULTI: /* multi_count changed */
-                        ap->eh_info.action |= ATA_EH_REVALIDATE;
+                        ap->link.eh_info.action |= ATA_EH_REVALIDATE;
                         ata_port_schedule_eh(ap);
                         break;
                 }
@@ -1422,37 +1430,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
 }
 
 /**
- *      ata_scmd_need_defer - Check whether we need to defer scmd
- *      @dev: ATA device to which the command is addressed
- *      @is_io: Is the command IO (and thus possibly NCQ)?
- *
- *      NCQ and non-NCQ commands cannot run together.  As upper layer
- *      only knows the queue depth, we are responsible for maintaining
- *      exclusion.  This function checks whether a new command can be
- *      issued to @dev.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- *      RETURNS:
- *      1 if deferring is needed, 0 otherwise.
- */
-static int ata_scmd_need_defer(struct ata_device *dev, int is_io)
-{
-        struct ata_port *ap = dev->ap;
-        int is_ncq = is_io && ata_ncq_enabled(dev);
-
-        if (is_ncq) {
-                if (!ata_tag_valid(ap->active_tag))
-                        return 0;
-        } else {
-                if (!ata_tag_valid(ap->active_tag) && !ap->sactive)
-                        return 0;
-        }
-        return 1;
-}
-
-/**
  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
  *      @dev: ATA device to which the command is addressed
  *      @cmd: SCSI command to execute
@@ -1483,14 +1460,12 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
                               void (*done)(struct scsi_cmnd *),
                               ata_xlat_func_t xlat_func)
 {
+        struct ata_port *ap = dev->link->ap;
         struct ata_queued_cmd *qc;
-        int is_io = xlat_func == ata_scsi_rw_xlat;
+        int rc;
 
         VPRINTK("ENTER\n");
 
-        if (unlikely(ata_scmd_need_defer(dev, is_io)))
-                goto defer;
-
         qc = ata_scsi_qc_new(dev, cmd, done);
         if (!qc)
                 goto err_mem;
@@ -1498,17 +1473,13 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
         /* data is present; dma-map it */
         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
             cmd->sc_data_direction == DMA_TO_DEVICE) {
-                if (unlikely(cmd->request_bufflen < 1)) {
+                if (unlikely(scsi_bufflen(cmd) < 1)) {
                         ata_dev_printk(dev, KERN_WARNING,
                                        "WARNING: zero len r/w req\n");
                         goto err_did;
                 }
 
-                if (cmd->use_sg)
-                        ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
-                else
-                        ata_sg_init_one(qc, cmd->request_buffer,
-                                        cmd->request_bufflen);
+                ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
 
                 qc->dma_dir = cmd->sc_data_direction;
         }
@@ -1518,6 +1489,11 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
         if (xlat_func(qc))
                 goto early_finish;
 
+        if (ap->ops->qc_defer) {
+                if ((rc = ap->ops->qc_defer(qc)))
+                        goto defer;
+        }
+
         /* select device, send command to hardware */
         ata_qc_issue(qc);
 
@@ -1539,8 +1515,12 @@ err_mem:
         return 0;
 
 defer:
+        ata_qc_free(qc);
         DPRINTK("EXIT - defer\n");
-        return SCSI_MLQUEUE_DEVICE_BUSY;
+        if (rc == ATA_DEFER_LINK)
+                return SCSI_MLQUEUE_DEVICE_BUSY;
+        else
+                return SCSI_MLQUEUE_HOST_BUSY;
 }
 
 /**
@@ -1562,15 +1542,14 @@ static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
         u8 *buf;
         unsigned int buflen;
 
-        if (cmd->use_sg) {
-                struct scatterlist *sg;
+        struct scatterlist *sg = scsi_sglist(cmd);
 
-                sg = (struct scatterlist *) cmd->request_buffer;
+        if (sg) {
                 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
                 buflen = sg->length;
         } else {
-                buf = cmd->request_buffer;
-                buflen = cmd->request_bufflen;
+                buf = NULL;
+                buflen = 0;
         }
 
         *buf_out = buf;
@@ -1590,12 +1569,9 @@ static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
 
 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
 {
-        if (cmd->use_sg) {
-                struct scatterlist *sg;
-
-                sg = (struct scatterlist *) cmd->request_buffer;
+        struct scatterlist *sg = scsi_sglist(cmd);
+        if (sg)
                 kunmap_atomic(buf - sg->offset, KM_IRQ0);
-        }
 }
 
 /**
@@ -1817,6 +1793,62 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 }
 
 /**
+ *      ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
+ *      @args: device IDENTIFY data / SCSI command of interest.
+ *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
+ *      @buflen: Response buffer length.
+ *
+ *      Yields SAT-specified ATA VPD page.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+
+unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
+                              unsigned int buflen)
+{
+        u8 pbuf[60];
+        struct ata_taskfile tf;
+        unsigned int i;
+
+        if (!buflen)
+                return 0;
+
+        memset(&pbuf, 0, sizeof(pbuf));
+        memset(&tf, 0, sizeof(tf));
+
+        pbuf[1] = 0x89;                 /* our page code */
+        pbuf[2] = (0x238 >> 8);         /* page size fixed at 238h */
+        pbuf[3] = (0x238 & 0xff);
+
+        memcpy(&pbuf[8], "linux   ", 8);
+        memcpy(&pbuf[16], "libata          ", 16);
+        memcpy(&pbuf[32], DRV_VERSION, 4);
+        ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
+
+        /* we don't store the ATA device signature, so we fake it */
+
+        tf.command = ATA_DRDY;          /* really, this is Status reg */
+        tf.lbal = 0x1;
+        tf.nsect = 0x1;
+
+        ata_tf_to_fis(&tf, 0, 1, &pbuf[36]);    /* TODO: PMP? */
+        pbuf[36] = 0x34;                /* force D2H Reg FIS (34h) */
+
+        pbuf[56] = ATA_CMD_ID_ATA;
+
+        i = min(buflen, 60U);
+        memcpy(rbuf, &pbuf[0], i);
+        buflen -= i;
+
+        if (!buflen)
+                return 0;
+
+        memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
+        return 0;
+}
+
+/**
  *      ata_scsiop_noop - Command handler that simply returns success.
  *      @args: device IDENTIFY data / SCSI command of interest.
  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
@@ -2273,8 +2305,8 @@ static void atapi_request_sense(struct ata_queued_cmd *qc)
                 qc->tf.feature |= ATAPI_PKT_DMA;
         } else {
                 qc->tf.protocol = ATA_PROT_ATAPI;
-                qc->tf.lbam = (8 * 1024) & 0xff;
-                qc->tf.lbah = (8 * 1024) >> 8;
+                qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
+                qc->tf.lbah = 0;
         }
         qc->nbytes = SCSI_SENSE_BUFFERSIZE;
 
@@ -2383,6 +2415,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         struct ata_device *dev = qc->dev;
         int using_pio = (dev->flags & ATA_DFLAG_PIO);
         int nodata = (scmd->sc_data_direction == DMA_NONE);
+        unsigned int nbytes;
 
         memset(qc->cdb, 0, dev->cdb_len);
         memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
@@ -2396,20 +2429,26 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         }
 
         qc->tf.command = ATA_CMD_PACKET;
-        qc->nbytes = scmd->request_bufflen;
+        qc->nbytes = scsi_bufflen(scmd);
 
         /* check whether ATAPI DMA is safe */
         if (!using_pio && ata_check_atapi_dma(qc))
                 using_pio = 1;
 
+        /* Some controller variants snoop this value for Packet transfers
+           to do state machine and FIFO management. Thus we want to set it
+           properly, and for DMA where it is effectively meaningless */
+        nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
+
+        qc->tf.lbam = (nbytes & 0xFF);
+        qc->tf.lbah = (nbytes >> 8);
+
         if (using_pio || nodata) {
                 /* no data, or PIO data xfer */
                 if (nodata)
                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
                 else
                         qc->tf.protocol = ATA_PROT_ATAPI;
-                qc->tf.lbam = (8 * 1024) & 0xff;
-                qc->tf.lbah = (8 * 1024) >> 8;
         } else {
                 /* DMA data xfer */
                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
@@ -2420,24 +2459,42 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
                         qc->tf.feature |= ATAPI_DMADIR;
         }
 
+
+        /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
+           as ATAPI tape drives don't get this right otherwise */
         return 0;
 }
 
-static struct ata_device * ata_find_dev(struct ata_port *ap, int id)
+static struct ata_device * ata_find_dev(struct ata_port *ap, int devno)
 {
-        if (likely(id < ATA_MAX_DEVICES))
-                return &ap->device[id];
+        if (ap->nr_pmp_links == 0) {
+                if (likely(devno < ata_link_max_devices(&ap->link)))
+                        return &ap->link.device[devno];
+        } else {
+                if (likely(devno < ap->nr_pmp_links))
+                        return &ap->pmp_link[devno].device[0];
+        }
+
         return NULL;
 }
 
 static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
                                         const struct scsi_device *scsidev)
 {
+        int devno;
+
         /* skip commands not addressed to targets we simulate */
-        if (unlikely(scsidev->channel || scsidev->lun))
-                return NULL;
+        if (ap->nr_pmp_links == 0) {
+                if (unlikely(scsidev->channel || scsidev->lun))
+                        return NULL;
+                devno = scsidev->id;
+        } else {
+                if (unlikely(scsidev->id || scsidev->lun))
+                        return NULL;
+                devno = scsidev->channel;
+        }
 
-        return ata_find_dev(ap, scsidev->id);
+        return ata_find_dev(ap, devno);
 }
 
 /**
@@ -2458,7 +2515,7 @@ static int ata_scsi_dev_enabled(struct ata_device *dev)
         if (unlikely(!ata_dev_enabled(dev)))
                 return 0;
 
-        if (!atapi_enabled || (dev->ap->flags & ATA_FLAG_NO_ATAPI)) {
+        if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
                 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
                         ata_dev_printk(dev, KERN_WARNING,
                                        "WARNING: ATAPI is %s, device ignored.\n",
@@ -2631,7 +2688,7 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
         case ATA_CMD_WRITE_LONG_ONCE:
                 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
                         goto invalid_fld;
-                qc->sect_size = scmd->request_bufflen;
+                qc->sect_size = scsi_bufflen(scmd);
         }
 
         /*
@@ -2661,7 +2718,7 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
          * TODO: find out if we need to do more here to
          *       cover scatter/gather case.
          */
-        qc->nbytes = scmd->request_bufflen;
+        qc->nbytes = scsi_bufflen(scmd);
 
         /* request result TF */
         qc->flags |= ATA_QCFLAG_RESULT_TF;
@@ -2746,28 +2803,48 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
                                       void (*done)(struct scsi_cmnd *),
                                       struct ata_device *dev)
 {
+        u8 scsi_op = scmd->cmnd[0];
+        ata_xlat_func_t xlat_func;
         int rc = 0;
 
-        if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len)) {
-                DPRINTK("bad CDB len=%u, max=%u\n",
-                        scmd->cmd_len, dev->cdb_len);
-                scmd->result = DID_ERROR << 16;
-                done(scmd);
-                return 0;
-        }
-
         if (dev->class == ATA_DEV_ATA) {
-                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
-                                                              scmd->cmnd[0]);
+                if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
+                        goto bad_cdb_len;
 
-                if (xlat_func)
-                        rc = ata_scsi_translate(dev, scmd, done, xlat_func);
-                else
-                        ata_scsi_simulate(dev, scmd, done);
-        } else
-                rc = ata_scsi_translate(dev, scmd, done, atapi_xlat);
+                xlat_func = ata_get_xlat_func(dev, scsi_op);
+        } else {
+                if (unlikely(!scmd->cmd_len))
+                        goto bad_cdb_len;
+
+                xlat_func = NULL;
+                if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
+                        /* relay SCSI command to ATAPI device */
+                        if (unlikely(scmd->cmd_len > dev->cdb_len))
+                                goto bad_cdb_len;
+
+                        xlat_func = atapi_xlat;
+                } else {
+                        /* ATA_16 passthru, treat as an ATA command */
+                        if (unlikely(scmd->cmd_len > 16))
+                                goto bad_cdb_len;
+
+                        xlat_func = ata_get_xlat_func(dev, scsi_op);
+                }
+        }
+
+        if (xlat_func)
+                rc = ata_scsi_translate(dev, scmd, done, xlat_func);
+        else
+                ata_scsi_simulate(dev, scmd, done);
 
         return rc;
+
+ bad_cdb_len:
+        DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
+                scmd->cmd_len, scsi_op, dev->cdb_len);
+        scmd->result = DID_ERROR << 16;
+        done(scmd);
+        return 0;
 }
 
 /**
@@ -2835,6 +2912,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
 {
         struct ata_scsi_args args;
         const u8 *scsicmd = cmd->cmnd;
+        u8 tmp8;
 
         args.dev = dev;
         args.id = dev->id;
@@ -2842,15 +2920,9 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
         args.done = done;
 
         switch(scsicmd[0]) {
-                /* no-op's, complete with success */
-                case SYNCHRONIZE_CACHE:
-                case REZERO_UNIT:
-                case SEEK_6:
-                case SEEK_10:
-                case TEST_UNIT_READY:
-                case FORMAT_UNIT:               /* FIXME: correct? */
-                case SEND_DIAGNOSTIC:           /* FIXME: correct? */
-                        ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                /* TODO: worth improving? */
+                case FORMAT_UNIT:
+                        ata_scsi_invalid_field(cmd, done);
                         break;
 
                 case INQUIRY:
@@ -2858,14 +2930,23 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                                 ata_scsi_invalid_field(cmd, done);
                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
-                        else if (scsicmd[2] == 0x00)
+                        else switch (scsicmd[2]) {
+                        case 0x00:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
-                        else if (scsicmd[2] == 0x80)
+                                break;
+                        case 0x80:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
-                        else if (scsicmd[2] == 0x83)
+                                break;
+                        case 0x83:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
-                        else
+                                break;
+                        case 0x89:
+                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
+                                break;
+                        default:
                                 ata_scsi_invalid_field(cmd, done);
+                                break;
+                        }
                         break;
 
                 case MODE_SENSE:
@@ -2893,8 +2974,33 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
                         break;
 
-                /* mandatory commands we haven't implemented yet */
                 case REQUEST_SENSE:
+                        ata_scsi_set_sense(cmd, 0, 0, 0);
+                        cmd->result = (DRIVER_SENSE << 24);
+                        done(cmd);
+                        break;
+
+                /* if we reach this, then writeback caching is disabled,
+                 * turning this into a no-op.
+                 */
+                case SYNCHRONIZE_CACHE:
+                        /* fall through */
+
+                /* no-op's, complete with success */
+                case REZERO_UNIT:
+                case SEEK_6:
+                case SEEK_10:
+                case TEST_UNIT_READY:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                        break;
+
+                case SEND_DIAGNOSTIC:
+                        tmp8 = scsicmd[1] & ~(1 << 3);
+                        if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
+                                ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                        else
+                                ata_scsi_invalid_field(cmd, done);
+                        break;
 
                 /* all other commands */
                 default:
@@ -2928,6 +3034,13 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
                 shost->max_channel = 1;
                 shost->max_cmd_len = 16;
 
+                /* Schedule policy is determined by ->qc_defer()
+                 * callback and it needs to see every deferred qc.
+                 * Set host_blocked to 1 to prevent SCSI midlayer from
+                 * automatically deferring requests.
+                 */
+                shost->max_host_blocked = 1;
+
                 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
                 if (rc)
                         goto err_add;
@@ -2951,25 +3064,32 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
 {
         int tries = 5;
         struct ata_device *last_failed_dev = NULL;
+        struct ata_link *link;
         struct ata_device *dev;
-        unsigned int i;
 
         if (ap->flags & ATA_FLAG_DISABLED)
                 return;
 
  repeat:
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct scsi_device *sdev;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        struct scsi_device *sdev;
+                        int channel = 0, id = 0;
 
-                dev = &ap->device[i];
+                        if (!ata_dev_enabled(dev) || dev->sdev)
+                                continue;
 
-                if (!ata_dev_enabled(dev) || dev->sdev)
-                        continue;
+                        if (ata_is_host_link(link))
+                                id = dev->devno;
+                        else
+                                channel = link->pmp;
 
-                sdev = __scsi_add_device(ap->scsi_host, 0, i, 0, NULL);
-                if (!IS_ERR(sdev)) {
-                        dev->sdev = sdev;
-                        scsi_device_put(sdev);
+                        sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
+                                                 NULL);
+                        if (!IS_ERR(sdev)) {
+                                dev->sdev = sdev;
+                                scsi_device_put(sdev);
+                        }
                 }
         }
 
@@ -2977,12 +3097,14 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
          * failure occurred, scan would have failed silently.  Check
          * whether all devices are attached.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-                if (ata_dev_enabled(dev) && !dev->sdev)
-                        break;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        if (ata_dev_enabled(dev) && !dev->sdev)
+                                goto exit_loop;
+                }
         }
-        if (i == ATA_MAX_DEVICES)
+ exit_loop:
+        if (!link)
                 return;
 
         /* we're missing some SCSI devices */
@@ -3049,7 +3171,7 @@ int ata_scsi_offline_dev(struct ata_device *dev)
  */
 static void ata_scsi_remove_dev(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct scsi_device *sdev;
         unsigned long flags;
 
@@ -3096,6 +3218,43 @@ static void ata_scsi_remove_dev(struct ata_device *dev)
         }
 }
 
+static void ata_scsi_handle_link_detach(struct ata_link *link)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *dev;
+
+        ata_link_for_each_dev(dev, link) {
+                unsigned long flags;
+
+                if (!(dev->flags & ATA_DFLAG_DETACHED))
+                        continue;
+
+                spin_lock_irqsave(ap->lock, flags);
+                dev->flags &= ~ATA_DFLAG_DETACHED;
+                spin_unlock_irqrestore(ap->lock, flags);
+
+                ata_scsi_remove_dev(dev);
+        }
+}
+
+/**
+ *      ata_scsi_media_change_notify - send media change event
+ *      @atadev: Pointer to the disk device with media change event
+ *
+ *      Tell the block layer to send a media change notification
+ *      event.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_scsi_media_change_notify(struct ata_device *dev)
+{
+#ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
+        if (dev->sdev)
+                scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
+#endif
+}
+
 /**
  *      ata_scsi_hotplug - SCSI part of hotplug
  *      @work: Pointer to ATA port to perform SCSI hotplug on
@@ -3121,20 +3280,14 @@ void ata_scsi_hotplug(struct work_struct *work)
 
         DPRINTK("ENTER\n");
 
-        /* unplug detached devices */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                unsigned long flags;
-
-                if (!(dev->flags & ATA_DFLAG_DETACHED))
-                        continue;
-
-                spin_lock_irqsave(ap->lock, flags);
-                dev->flags &= ~ATA_DFLAG_DETACHED;
-                spin_unlock_irqrestore(ap->lock, flags);
-
-                ata_scsi_remove_dev(dev);
-        }
+        /* Unplug detached devices.  We cannot use link iterator here
+         * because PMP links have to be scanned even if PMP is
+         * currently not attached.  Iterate manually.
+         */
+        ata_scsi_handle_link_detach(&ap->link);
+        if (ap->pmp_link)
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                        ata_scsi_handle_link_detach(&ap->pmp_link[i]);
 
         /* scan for new ones */
         ata_scsi_scan_host(ap, 0);
@@ -3163,27 +3316,42 @@ static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
 {
         struct ata_port *ap = ata_shost_to_port(shost);
         unsigned long flags;
-        int rc = 0;
+        int devno, rc = 0;
 
         if (!ap->ops->error_handler)
                 return -EOPNOTSUPP;
 
-        if ((channel != SCAN_WILD_CARD && channel != 0) ||
-            (lun != SCAN_WILD_CARD && lun != 0))
+        if (lun != SCAN_WILD_CARD && lun)
                 return -EINVAL;
 
+        if (ap->nr_pmp_links == 0) {
+                if (channel != SCAN_WILD_CARD && channel)
+                        return -EINVAL;
+                devno = id;
+        } else {
+                if (id != SCAN_WILD_CARD && id)
+                        return -EINVAL;
+                devno = channel;
+        }
+
         spin_lock_irqsave(ap->lock, flags);
 
-        if (id == SCAN_WILD_CARD) {
-                ap->eh_info.probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
-                ap->eh_info.action |= ATA_EH_SOFTRESET;
+        if (devno == SCAN_WILD_CARD) {
+                struct ata_link *link;
+
+                ata_port_for_each_link(link, ap) {
+                        struct ata_eh_info *ehi = &link->eh_info;
+                        ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
+                        ehi->action |= ATA_EH_SOFTRESET;
+                }
         } else {
-                struct ata_device *dev = ata_find_dev(ap, id);
+                struct ata_device *dev = ata_find_dev(ap, devno);
 
                 if (dev) {
-                        ap->eh_info.probe_mask |= 1 << dev->devno;
-                        ap->eh_info.action |= ATA_EH_SOFTRESET;
-                        ap->eh_info.flags |= ATA_EHI_RESUME_LINK;
+                        struct ata_eh_info *ehi = &dev->link->eh_info;
+                        ehi->probe_mask |= 1 << dev->devno;
+                        ehi->action |= ATA_EH_SOFTRESET;
+                        ehi->flags |= ATA_EHI_RESUME_LINK;
                 } else
                         rc = -EINVAL;
         }
@@ -3214,24 +3382,26 @@ void ata_scsi_dev_rescan(struct work_struct *work)
 {
         struct ata_port *ap =
                 container_of(work, struct ata_port, scsi_rescan_task);
+        struct ata_link *link;
+        struct ata_device *dev;
         unsigned long flags;
-        unsigned int i;
 
         spin_lock_irqsave(ap->lock, flags);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                struct scsi_device *sdev = dev->sdev;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        struct scsi_device *sdev = dev->sdev;
 
-                if (!ata_dev_enabled(dev) || !sdev)
-                        continue;
-                if (scsi_device_get(sdev))
-                        continue;
+                        if (!ata_dev_enabled(dev) || !sdev)
+                                continue;
+                        if (scsi_device_get(sdev))
+                                continue;
 
-                spin_unlock_irqrestore(ap->lock, flags);
-                scsi_rescan_device(&(sdev->sdev_gendev));
-                scsi_device_put(sdev);
-                spin_lock_irqsave(ap->lock, flags);
+                        spin_unlock_irqrestore(ap->lock, flags);
+                        scsi_rescan_device(&(sdev->sdev_gendev));
+                        scsi_device_put(sdev);
+                        spin_lock_irqsave(ap->lock, flags);
+                }
         }
 
         spin_unlock_irqrestore(ap->lock, flags);
@@ -3359,7 +3529,7 @@ EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
 {
         ata_scsi_sdev_config(sdev);
-        ata_scsi_dev_config(sdev, ap->device);
+        ata_scsi_dev_config(sdev, ap->link.device);
         return 0;
 }
 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
@@ -3382,8 +3552,8 @@ int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
 
         ata_scsi_dump_cdb(ap, cmd);
 
-        if (likely(ata_scsi_dev_enabled(ap->device)))
-                rc = __ata_scsi_queuecmd(cmd, done, ap->device);
+        if (likely(ata_scsi_dev_enabled(ap->link.device)))
+                rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
         else {
                 cmd->result = (DID_BAD_TARGET << 16);
                 done(cmd);
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 8023167bbb..026439e05a 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -64,46 +64,6 @@ u8 ata_irq_on(struct ata_port *ap)
         return tmp;
 }
 
-u8 ata_dummy_irq_on (struct ata_port *ap)       { return 0; }
-
-/**
- *      ata_irq_ack - Acknowledge a device interrupt.
- *      @ap: Port on which interrupts are enabled.
- *
- *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
- *      or BUSY+DRQ clear).  Obtain dma status and port status from
- *      device.  Clear the interrupt.  Return port status.
- *
- *      LOCKING:
- */
-
-u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 host_stat = 0, post_stat = 0, status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        if (ap->ioaddr.bmdma_addr) {
-                /* get controller status; clear intr, err bits */
-                host_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-                iowrite8(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
-                         ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-
-                post_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-        }
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
-                        __FUNCTION__,
-                        host_stat, post_stat, status);
-        return status;
-}
-
-u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq) { return 0; }
-
 /**
  *      ata_tf_load - send taskfile registers to host controller
  *      @ap: Port to which output is sent
@@ -445,7 +405,7 @@ void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
         unsigned long flags;
         int thaw = 0;
 
-        qc = __ata_qc_from_tag(ap, ap->active_tag);
+        qc = __ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc && !(qc->flags & ATA_QCFLAG_FAILED))
                 qc = NULL;
 
@@ -500,7 +460,7 @@ void ata_bmdma_error_handler(struct ata_port *ap)
         ata_reset_fn_t hardreset;
 
         hardreset = NULL;
-        if (sata_scr_valid(ap))
+        if (sata_scr_valid(&ap->link))
                 hardreset = sata_std_hardreset;
 
         ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset, hardreset,
@@ -607,6 +567,9 @@ int ata_pci_init_bmdma(struct ata_host *host)
                 if ((!(ap->flags & ATA_FLAG_IGN_SIMPLEX)) &&
                     (ioread8(bmdma + 2) & 0x80))
                         host->flags |= ATA_HOST_SIMPLEX;
+
+                ata_port_desc(ap, "bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 4) + 8 * i);
         }
 
         return 0;
@@ -674,6 +637,10 @@ int ata_pci_init_sff_host(struct ata_host *host)
                         ((unsigned long)iomap[base + 1] | ATA_PCI_CTL_OFS);
                 ata_std_ports(&ap->ioaddr);
 
+                ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, base),
+                        (unsigned long long)pci_resource_start(pdev, base + 1));
+
                 mask |= 1 << i;
         }
 
@@ -844,24 +811,30 @@ int ata_pci_init_one(struct pci_dev *pdev,
                                       IRQF_SHARED, DRV_NAME, host);
                 if (rc)
                         goto err_out;
-                host->irq = pdev->irq;
+
+                ata_port_desc(host->ports[0], "irq %d", pdev->irq);
+                ata_port_desc(host->ports[1], "irq %d", pdev->irq);
         } else {
                 if (!ata_port_is_dummy(host->ports[0])) {
-                        host->irq = ATA_PRIMARY_IRQ(pdev);
-                        rc = devm_request_irq(dev, host->irq,
+                        rc = devm_request_irq(dev, ATA_PRIMARY_IRQ(pdev),
                                               pi->port_ops->irq_handler,
                                               IRQF_SHARED, DRV_NAME, host);
                         if (rc)
                                 goto err_out;
+
+                        ata_port_desc(host->ports[0], "irq %d",
+                                      ATA_PRIMARY_IRQ(pdev));
                 }
 
                 if (!ata_port_is_dummy(host->ports[1])) {
-                        host->irq2 = ATA_SECONDARY_IRQ(pdev);
-                        rc = devm_request_irq(dev, host->irq2,
+                        rc = devm_request_irq(dev, ATA_SECONDARY_IRQ(pdev),
                                               pi->port_ops->irq_handler,
                                               IRQF_SHARED, DRV_NAME, host);
                         if (rc)
                                 goto err_out;
+
+                        ata_port_desc(host->ports[1], "irq %d",
+                                      ATA_SECONDARY_IRQ(pdev));
                 }
         }
 
@@ -909,7 +882,7 @@ unsigned long ata_pci_default_filter(struct ata_device *adev, unsigned long xfer
         /* Filter out DMA modes if the device has been configured by
            the BIOS as PIO only */
 
-        if (adev->ap->ioaddr.bmdma_addr == 0)
+        if (adev->link->ap->ioaddr.bmdma_addr == 0)
                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
         return xfer_mask;
 }
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 564cd234c8..90df58a3ed 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -29,6 +29,7 @@
 #define __LIBATA_H__
 
 #define DRV_NAME        "libata"
+#define DRV_VERSION     "3.00"  /* must be exactly four chars */
 
 struct ata_scsi_args {
         struct ata_device       *dev;
@@ -56,6 +57,7 @@ extern unsigned int ata_print_id;
 extern struct workqueue_struct *ata_aux_wq;
 extern int atapi_enabled;
 extern int atapi_dmadir;
+extern int atapi_passthru16;
 extern int libata_fua;
 extern int libata_noacpi;
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev);
@@ -67,21 +69,23 @@ extern void ata_dev_disable(struct ata_device *dev);
 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,
-                                  int dma_dir, void *buf, unsigned int buflen);
+                                  int dma_dir, void *buf, unsigned int buflen,
+                                  unsigned long timeout);
 extern unsigned ata_exec_internal_sg(struct ata_device *dev,
                                      struct ata_taskfile *tf, const u8 *cdb,
                                      int dma_dir, struct scatterlist *sg,
-                                     unsigned int n_elem);
+                                     unsigned int n_elem, unsigned long timeout);
 extern unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd);
 extern int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                            unsigned int flags, u16 *id);
 extern int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags);
-extern int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags);
+extern int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
+                              unsigned int readid_flags);
 extern int ata_dev_configure(struct ata_device *dev);
-extern int sata_down_spd_limit(struct ata_port *ap);
-extern int sata_set_spd_needed(struct ata_port *ap);
+extern int sata_down_spd_limit(struct ata_link *link);
+extern int sata_set_spd_needed(struct ata_link *link);
 extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
-extern int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
+extern int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
 extern void ata_sg_clean(struct ata_queued_cmd *qc);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
 extern void ata_qc_issue(struct ata_queued_cmd *qc);
@@ -92,17 +96,21 @@ extern void ata_dev_select(struct ata_port *ap, unsigned int device,
 extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
 extern int ata_flush_cache(struct ata_device *dev);
 extern void ata_dev_init(struct ata_device *dev);
+extern void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp);
+extern int sata_link_init_spd(struct ata_link *link);
 extern int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg);
 extern int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg);
 extern struct ata_port *ata_port_alloc(struct ata_host *host);
 
 /* libata-acpi.c */
 #ifdef CONFIG_ATA_ACPI
+extern void ata_acpi_associate_sata_port(struct ata_port *ap);
 extern void ata_acpi_associate(struct ata_host *host);
 extern int ata_acpi_on_suspend(struct ata_port *ap);
 extern void ata_acpi_on_resume(struct ata_port *ap);
 extern int ata_acpi_on_devcfg(struct ata_device *adev);
 #else
+static inline void ata_acpi_associate_sata_port(struct ata_port *ap) { }
 static inline void ata_acpi_associate(struct ata_host *host) { }
 static inline int ata_acpi_on_suspend(struct ata_port *ap) { return 0; }
 static inline void ata_acpi_on_resume(struct ata_port *ap) { }
@@ -114,6 +122,7 @@ extern int ata_scsi_add_hosts(struct ata_host *host,
                               struct scsi_host_template *sht);
 extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
 extern int ata_scsi_offline_dev(struct ata_device *dev);
+extern void ata_scsi_media_change_notify(struct ata_device *dev);
 extern void ata_scsi_hotplug(struct work_struct *work);
 extern unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
                                unsigned int buflen);
@@ -147,12 +156,32 @@ extern void ata_schedule_scsi_eh(struct Scsi_Host *shost);
 extern void ata_scsi_dev_rescan(struct work_struct *work);
 extern int ata_bus_probe(struct ata_port *ap);
 
+/* libata-pmp.c */
+extern int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *val);
+extern int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val);
+extern int sata_pmp_attach(struct ata_device *dev);
+
 /* libata-eh.c */
 extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern void ata_scsi_error(struct Scsi_Host *host);
 extern void ata_port_wait_eh(struct ata_port *ap);
 extern void ata_eh_fastdrain_timerfn(unsigned long arg);
 extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
+extern void ata_eh_detach_dev(struct ata_device *dev);
+extern void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
+                               unsigned int action);
+extern void ata_eh_done(struct ata_link *link, struct ata_device *dev,
+                        unsigned int action);
+extern void ata_eh_autopsy(struct ata_port *ap);
+extern void ata_eh_report(struct ata_port *ap);
+extern int ata_eh_reset(struct ata_link *link, int classify,
+                        ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                        ata_reset_fn_t hardreset, ata_postreset_fn_t postreset);
+extern int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
+                          ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
+                          ata_postreset_fn_t postreset,
+                          struct ata_link **r_failed_disk);
+extern void ata_eh_finish(struct ata_port *ap);
 
 /* libata-sff.c */
 extern u8 ata_irq_on(struct ata_port *ap);
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
new file mode 100644
index 0000000000..5d3920f6fd
--- /dev/null
+++ b/drivers/ata/pata_acpi.c
@@ -0,0 +1,395 @@
+/*
+ *      ACPI PATA driver
+ *
+ *      (c) 2007 Red Hat  <alan@redhat.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acnames.h>
+#include <acpi/acnamesp.h>
+#include <acpi/acparser.h>
+#include <acpi/acexcep.h>
+#include <acpi/acmacros.h>
+#include <acpi/actypes.h>
+
+#include <linux/libata.h>
+#include <linux/ata.h>
+
+#define DRV_NAME        "pata_acpi"
+#define DRV_VERSION     "0.2.3"
+
+struct pata_acpi {
+        struct ata_acpi_gtm gtm;
+        void *last;
+        unsigned long mask[2];
+};
+
+/**
+ *      pacpi_pre_reset -       check for 40/80 pin
+ *      @ap: Port
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      Perform the PATA port setup we need.
+ */
+
+static int pacpi_pre_reset(struct ata_link *link, unsigned long deadline)
+{
+        struct ata_port *ap = link->ap;
+        struct pata_acpi *acpi = ap->private_data;
+        if (ap->acpi_handle == NULL || ata_acpi_gtm(ap, &acpi->gtm) < 0)
+                return -ENODEV;
+
+        return ata_std_prereset(link, deadline);
+}
+
+/**
+ *      pacpi_cable_detect      -       cable type detection
+ *      @ap: port to detect
+ *
+ *      Perform device specific cable detection
+ */
+
+static int pacpi_cable_detect(struct ata_port *ap)
+{
+        struct pata_acpi *acpi = ap->private_data;
+
+        if ((acpi->mask[0] | acpi->mask[1]) & (0xF8 << ATA_SHIFT_UDMA))
+                return ATA_CBL_PATA80;
+        else
+                return ATA_CBL_PATA40;
+}
+
+/**
+ *      pacpi_error_handler - Setup and error handler
+ *      @ap: Port to handle
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void pacpi_error_handler(struct ata_port *ap)
+{
+        return ata_bmdma_drive_eh(ap, pacpi_pre_reset, ata_std_softreset,
+                                  NULL, ata_std_postreset);
+}
+
+/* Welcome to ACPI, bring a bucket */
+static const unsigned int pio_cycle[7] = {
+        600, 383, 240, 180, 120, 100, 80
+};
+static const unsigned int mwdma_cycle[5] = {
+        480, 150, 120, 100, 80
+};
+static const unsigned int udma_cycle[7] = {
+        120, 80, 60, 45, 30, 20, 15
+};
+
+/**
+ *      pacpi_discover_modes    -       filter non ACPI modes
+ *      @adev: ATA device
+ *      @mask: proposed modes
+ *
+ *      Try the modes available and see which ones the ACPI method will
+ *      set up sensibly. From this we get a mask of ACPI modes we can use
+ */
+
+static unsigned long pacpi_discover_modes(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+        int i;
+        u32 t;
+        unsigned long mask = (0x7f << ATA_SHIFT_UDMA) | (0x7 << ATA_SHIFT_MWDMA) | (0x1F << ATA_SHIFT_PIO);
+
+        struct ata_acpi_gtm probe;
+
+        probe = acpi->gtm;
+
+        /* We always use the 0 slot for crap hardware */
+        if (!(probe.flags & 0x10))
+                unit = 0;
+
+        ata_acpi_gtm(ap, &probe);
+
+        /* Start by scanning for PIO modes */
+        for (i = 0; i < 7; i++) {
+                t = probe.drive[unit].pio;
+                if (t <= pio_cycle[i]) {
+                        mask |= (2 << (ATA_SHIFT_PIO + i)) - 1;
+                        break;
+                }
+        }
+
+        /* See if we have MWDMA or UDMA data. We don't bother with MWDMA
+           if UDMA is availabe as this means the BIOS set UDMA and our
+           error changedown if it works is UDMA to PIO anyway */
+        if (probe.flags & (1 << (2 * unit))) {
+                /* MWDMA */
+                for (i = 0; i < 5; i++) {
+                        t = probe.drive[unit].dma;
+                        if (t <= mwdma_cycle[i]) {
+                                mask |= (2 << (ATA_SHIFT_MWDMA + i)) - 1;
+                                break;
+                        }
+                }
+        } else {
+                /* UDMA */
+                for (i = 0; i < 7; i++) {
+                        t = probe.drive[unit].dma;
+                        if (t <= udma_cycle[i]) {
+                                mask |= (2 << (ATA_SHIFT_UDMA + i)) - 1;
+                                break;
+                        }
+                }
+        }
+        if (mask & (0xF8 << ATA_SHIFT_UDMA))
+                ap->cbl = ATA_CBL_PATA80;
+        return mask;
+}
+
+/**
+ *      pacpi_mode_filter       -       mode filter for ACPI
+ *      @adev: device
+ *      @mask: mask of valid modes
+ *
+ *      Filter the valid mode list according to our own specific rules, in
+ *      this case the list of discovered valid modes obtained by ACPI probing
+ */
+
+static unsigned long pacpi_mode_filter(struct ata_device *adev, unsigned long mask)
+{
+        struct pata_acpi *acpi = adev->link->ap->private_data;
+        return ata_pci_default_filter(adev, mask & acpi->mask[adev->devno]);
+}
+
+/**
+ *      pacpi_set_piomode       -       set initial PIO mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ */
+
+static void pacpi_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if(!(acpi->gtm.flags & 0x10))
+                unit = 0;
+
+        /* Now stuff the nS values into the structure */
+        acpi->gtm.drive[unit].pio = pio_cycle[adev->pio_mode - XFER_PIO_0];
+        ata_acpi_stm(ap, &acpi->gtm);
+        /* See what mode we actually got */
+        ata_acpi_gtm(ap, &acpi->gtm);
+}
+
+/**
+ *      pacpi_set_dmamode       -       set initial DMA mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ */
+
+static void pacpi_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if(!(acpi->gtm.flags & 0x10))
+                unit = 0;
+
+        /* Now stuff the nS values into the structure */
+        if (adev->dma_mode >= XFER_UDMA_0) {
+                acpi->gtm.drive[unit].dma = udma_cycle[adev->dma_mode - XFER_UDMA_0];
+                acpi->gtm.flags |= (1 << (2 * unit));
+        } else {
+                acpi->gtm.drive[unit].dma = mwdma_cycle[adev->dma_mode - XFER_MW_DMA_0];
+                acpi->gtm.flags &= ~(1 << (2 * unit));
+        }
+        ata_acpi_stm(ap, &acpi->gtm);
+        /* See what mode we actually got */
+        ata_acpi_gtm(ap, &acpi->gtm);
+}
+
+/**
+ *      pacpi_qc_issue_prot     -       command issue
+ *      @qc: command pending
+ *
+ *      Called when the libata layer is about to issue a command. We wrap
+ *      this interface so that we can load the correct ATA timings if
+ *      neccessary.
+ */
+
+static unsigned int pacpi_qc_issue_prot(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct ata_device *adev = qc->dev;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if (acpi->gtm.flags & 0x10)
+                return ata_qc_issue_prot(qc);
+
+        if (adev != acpi->last) {
+                pacpi_set_piomode(ap, adev);
+                if (adev->dma_mode)
+                        pacpi_set_dmamode(ap, adev);
+                acpi->last = adev;
+        }
+        return ata_qc_issue_prot(qc);
+}
+
+/**
+ *      pacpi_port_start        -       port setup
+ *      @ap: ATA port being set up
+ *
+ *      Use the port_start hook to maintain private control structures
+ */
+
+static int pacpi_port_start(struct ata_port *ap)
+{
+        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+        struct pata_acpi *acpi;
+
+        int ret;
+
+        if (ap->acpi_handle == NULL)
+                return -ENODEV;
+
+        acpi = ap->private_data = devm_kzalloc(&pdev->dev, sizeof(struct pata_acpi), GFP_KERNEL);
+        if (ap->private_data == NULL)
+                return -ENOMEM;
+        acpi->mask[0] = pacpi_discover_modes(ap, &ap->link.device[0]);
+        acpi->mask[1] = pacpi_discover_modes(ap, &ap->link.device[1]);
+        ret = ata_sff_port_start(ap);
+        if (ret < 0)
+                return ret;
+
+        return ret;
+}
+
+static struct scsi_host_template pacpi_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        /* Use standard CHS mapping rules */
+        .bios_param             = ata_std_bios_param,
+};
+
+static const struct ata_port_operations pacpi_ops = {
+        .set_piomode            = pacpi_set_piomode,
+        .set_dmamode            = pacpi_set_dmamode,
+        .mode_filter            = pacpi_mode_filter,
+
+        /* Task file is PCI ATA format, use helpers */
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = pacpi_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = pacpi_cable_detect,
+
+        /* BMDMA handling is PCI ATA format, use helpers */
+        .bmdma_setup            = ata_bmdma_setup,
+        .bmdma_start            = ata_bmdma_start,
+        .bmdma_stop             = ata_bmdma_stop,
+        .bmdma_status           = ata_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = pacpi_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        /* Timeout handling */
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ata_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        /* Generic PATA PCI ATA helpers */
+        .port_start             = pacpi_port_start,
+};
+
+
+/**
+ *      pacpi_init_one - Register ACPI ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in pacpi_pci_tbl matching with @pdev
+ *
+ *      Called from kernel PCI layer.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        static const struct ata_port_info info = {
+                .sht            = &pacpi_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
+
+                .pio_mask       = 0x1f,
+                .mwdma_mask     = 0x07,
+                .udma_mask      = 0x7f,
+
+                .port_ops       = &pacpi_ops,
+        };
+        const struct ata_port_info *ppi[] = { &info, NULL };
+        return ata_pci_init_one(pdev, ppi);
+}
+
+static const struct pci_device_id pacpi_pci_tbl[] = {
+        { PCI_ANY_ID,           PCI_ANY_ID,                        PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL, 1},
+        { }     /* terminate list */
+};
+
+static struct pci_driver pacpi_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = pacpi_pci_tbl,
+        .probe                  = pacpi_init_one,
+        .remove                 = ata_pci_remove_one,
+        .suspend                = ata_pci_device_suspend,
+        .resume                 = ata_pci_device_resume,
+};
+
+static int __init pacpi_init(void)
+{
+        return pci_register_driver(&pacpi_pci_driver);
+}
+
+static void __exit pacpi_exit(void)
+{
+        pci_unregister_driver(&pacpi_pci_driver);
+}
+
+module_init(pacpi_init);
+module_exit(pacpi_exit);
+
+MODULE_AUTHOR("Alan Cox");
+MODULE_DESCRIPTION("SCSI low-level driver for ATA in ACPI mode");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, pacpi_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index 32a10c99c0..364534e7af 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -305,7 +305,6 @@ static struct scsi_host_template ali_sht = {
  */
 
 static struct ata_port_operations ali_early_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
@@ -327,9 +326,8 @@ static struct ata_port_operations ali_early_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -337,8 +335,6 @@ static struct ata_port_operations ali_early_port_ops = {
  *      detect
  */
 static struct ata_port_operations ali_20_port_ops = {
-        .port_disable   = ata_port_disable,
-
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ali_20_filter,
@@ -369,16 +365,14 @@ static struct ata_port_operations ali_20_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
  *      Port operations for DMA capable ALi with cable detect
  */
 static struct ata_port_operations ali_c2_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -408,16 +402,14 @@ static struct ata_port_operations ali_c2_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
  *      Port operations for DMA capable ALi with cable detect and LBA48
  */
 static struct ata_port_operations ali_c5_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -446,9 +438,8 @@ static struct ata_port_operations ali_c5_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 04048fcf63..c5779ad4ab 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -119,27 +119,28 @@ static void timing_setup(struct ata_port *ap, struct ata_device *adev, int offse
 }
 
 /**
- *      amd_probe_init          -       perform reset handling
- *      @ap: ATA port
+ *      amd_pre_reset           -       perform reset handling
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Reset sequence checking enable bits to see which ports are
  *      active.
  */
 
-static int amd_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int amd_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits amd_enable_bits[] = {
                 { 0x40, 1, 0x02, 0x02 },
                 { 0x40, 1, 0x01, 0x01 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &amd_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void amd_error_handler(struct ata_port *ap)
@@ -221,25 +222,26 @@ static void amd133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 
 /**
  *      nv_probe_init   -       cable detection
- *      @ap: ATA port
+ *      @lin: ATA link
  *
  *      Perform cable detection. The BIOS stores this in PCI config
  *      space for us.
  */
 
-static int nv_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int nv_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits nv_enable_bits[] = {
                 { 0x50, 1, 0x02, 0x02 },
                 { 0x50, 1, 0x01, 0x01 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &nv_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)
@@ -268,6 +270,9 @@ static int nv_cable_detect(struct ata_port *ap)
         pci_read_config_word(pdev, 0x62 - 2 * ap->port_no, &udma);
         if ((udma & 0xC4) == 0xC4 || (udma & 0xC400) == 0xC400)
                 cbl = ATA_CBL_PATA80;
+        /* And a triple check across suspend/resume with ACPI around */
+        if (ata_acpi_cbl_80wire(ap))
+                cbl = ATA_CBL_PATA80;
         return cbl;
 }
 
@@ -327,7 +332,6 @@ static struct scsi_host_template amd_sht = {
 };
 
 static struct ata_port_operations amd33_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd33_set_piomode,
         .set_dmamode    = amd33_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -356,13 +360,11 @@ static struct ata_port_operations amd33_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd66_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd66_set_piomode,
         .set_dmamode    = amd66_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -391,13 +393,11 @@ static struct ata_port_operations amd66_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd100_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd100_set_piomode,
         .set_dmamode    = amd100_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -426,13 +426,11 @@ static struct ata_port_operations amd100_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd133_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd133_set_piomode,
         .set_dmamode    = amd133_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -461,13 +459,11 @@ static struct ata_port_operations amd133_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations nv100_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = nv100_set_piomode,
         .set_dmamode    = nv100_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -496,13 +492,11 @@ static struct ata_port_operations nv100_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations nv133_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = nv133_set_piomode,
         .set_dmamode    = nv133_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -531,9 +525,8 @@ static struct ata_port_operations nv133_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index b5352ebece..d421831032 100644
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -40,8 +40,9 @@
 
 static int clock = 0;
 
-static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6210_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         const struct pci_bits artop_enable_bits[] = {
                 { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
@@ -51,7 +52,7 @@ static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -71,27 +72,28 @@ static void artop6210_error_handler(struct ata_port *ap)
 
 /**
  *      artop6260_pre_reset     -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      The ARTOP hardware reports the cable detect bits in register 0x49.
  *      Nothing complicated needed here.
  */
 
-static int artop6260_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6260_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits artop_enable_bits[] = {
                 { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                 { 0x4AU, 1U, 0x04UL, 0x04UL },  /* port 1 */
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         /* Odd numbered device ids are the units with enable bits (the -R cards) */
         if (pdev->device % 1 && !pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -330,7 +332,6 @@ static struct scsi_host_template artop_sht = {
 };
 
 static const struct ata_port_operations artop6210_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = artop6210_set_piomode,
         .set_dmamode            = artop6210_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -359,13 +360,11 @@ static const struct ata_port_operations artop6210_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations artop6260_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = artop6260_set_piomode,
         .set_dmamode            = artop6260_set_dmamode,
 
@@ -392,9 +391,8 @@ static const struct ata_port_operations artop6260_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_at32.c b/drivers/ata/pata_at32.c
new file mode 100644
index 0000000000..bb250a48e2
--- /dev/null
+++ b/drivers/ata/pata_at32.c
@@ -0,0 +1,441 @@
+/*
+ * AVR32 SMC/CFC PATA Driver
+ *
+ * Copyright (C) 2007 Atmel Norway
+ *
+ * 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.
+ */
+
+#define DEBUG
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <scsi/scsi_host.h>
+#include <linux/ata.h>
+#include <linux/libata.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <asm/arch/board.h>
+#include <asm/arch/smc.h>
+
+#define DRV_NAME "pata_at32"
+#define DRV_VERSION "0.0.2"
+
+/*
+ * CompactFlash controller memory layout relative to the base address:
+ *
+ *      Attribute memory:  0000 0000 -> 003f ffff
+ *      Common memory:     0040 0000 -> 007f ffff
+ *      I/O memory:        0080 0000 -> 00bf ffff
+ *      True IDE Mode:     00c0 0000 -> 00df ffff
+ *      Alt IDE Mode:      00e0 0000 -> 00ff ffff
+ *
+ * Only True IDE and Alt True IDE mode are needed for this driver.
+ *
+ *      True IDE mode     => CS0 = 0, CS1 = 1 (cmd, error, stat, etc)
+ *      Alt True IDE mode => CS0 = 1, CS1 = 0 (ctl, alt_stat)
+ */
+#define CF_IDE_OFFSET     0x00c00000
+#define CF_ALT_IDE_OFFSET 0x00e00000
+#define CF_RES_SIZE       2048
+
+/*
+ * Define DEBUG_BUS if you are doing debugging of your own EBI -> PATA
+ * adaptor with a logic analyzer or similar.
+ */
+#undef DEBUG_BUS
+
+/*
+ * ATA PIO modes
+ *
+ *      Name    | Mb/s  | Min cycle time | Mask
+ *      --------+-------+----------------+--------
+ *      Mode 0  | 3.3   | 600 ns         | 0x01
+ *      Mode 1  | 5.2   | 383 ns         | 0x03
+ *      Mode 2  | 8.3   | 240 ns         | 0x07
+ *      Mode 3  | 11.1  | 180 ns         | 0x0f
+ *      Mode 4  | 16.7  | 120 ns         | 0x1f
+ */
+#define PIO_MASK (0x1f)
+
+/*
+ * Struct containing private information about device.
+ */
+struct at32_ide_info {
+        unsigned int            irq;
+        struct resource         res_ide;
+        struct resource         res_alt;
+        void __iomem            *ide_addr;
+        void __iomem            *alt_addr;
+        unsigned int            cs;
+        struct smc_config       smc;
+};
+
+/*
+ * Setup SMC for the given ATA timing.
+ */
+static int pata_at32_setup_timing(struct device *dev,
+                                  struct at32_ide_info *info,
+                                  const struct ata_timing *timing)
+{
+        /* These two values are found through testing */
+        const int min_recover = 25;
+        const int ncs_hold    = 15;
+
+        struct smc_config *smc = &info->smc;
+
+        int active;
+        int recover;
+
+        /* Total cycle time */
+        smc->read_cycle = timing->cyc8b;
+
+        /* DIOR <= CFIOR timings */
+        smc->nrd_setup = timing->setup;
+        smc->nrd_pulse = timing->act8b;
+
+        /* Compute recover, extend total cycle if needed */
+        active  = smc->nrd_setup + smc->nrd_pulse;
+        recover = smc->read_cycle - active;
+
+        if (recover < min_recover) {
+                smc->read_cycle = active + min_recover;
+                recover = min_recover;
+        }
+
+        /* (CS0, CS1, DIR, OE) <= (CFCE1, CFCE2, CFRNW, NCSX) timings */
+        smc->ncs_read_setup  = 0;
+        smc->ncs_read_pulse  = active + ncs_hold;
+
+        /* Write timings same as read timings */
+        smc->write_cycle = smc->read_cycle;
+        smc->nwe_setup = smc->nrd_setup;
+        smc->nwe_pulse = smc->nrd_pulse;
+        smc->ncs_write_setup = smc->ncs_read_setup;
+        smc->ncs_write_pulse = smc->ncs_read_pulse;
+
+        /* Do some debugging output */
+        dev_dbg(dev, "SMC: C=%d S=%d P=%d R=%d NCSS=%d NCSP=%d NCSR=%d\n",
+                smc->read_cycle, smc->nrd_setup, smc->nrd_pulse,
+                recover, smc->ncs_read_setup, smc->ncs_read_pulse,
+                smc->read_cycle - smc->ncs_read_pulse);
+
+        /* Finally, configure the SMC */
+        return smc_set_configuration(info->cs, smc);
+}
+
+/*
+ * Procedures for libATA.
+ */
+static void pata_at32_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct ata_timing timing;
+        struct at32_ide_info *info = ap->host->private_data;
+
+        int ret;
+
+        /* Compute ATA timing */
+        ret = ata_timing_compute(adev, adev->pio_mode, &timing, 1000, 0);
+        if (ret) {
+                dev_warn(ap->dev, "Failed to compute ATA timing %d\n", ret);
+                return;
+        }
+
+        /* Setup SMC to ATA timing */
+        ret = pata_at32_setup_timing(ap->dev, info, &timing);
+        if (ret) {
+                dev_warn(ap->dev, "Failed to setup ATA timing %d\n", ret);
+                return;
+        }
+}
+
+static void pata_at32_irq_clear(struct ata_port *ap)
+{
+        /* No DMA controller yet */
+}
+
+static struct scsi_host_template at32_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+};
+
+static struct ata_port_operations at32_port_ops = {
+        .port_disable           = ata_port_disable,
+        .set_piomode            = pata_at32_set_piomode,
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .exec_command           = ata_exec_command,
+        .check_status           = ata_check_status,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .data_xfer              = ata_data_xfer,
+
+        .irq_clear              = pata_at32_irq_clear,
+        .irq_on                 = ata_irq_on,
+        .irq_ack                = ata_irq_ack,
+
+        .port_start             = ata_sff_port_start,
+};
+
+static int __init pata_at32_init_one(struct device *dev,
+                                     struct at32_ide_info *info)
+{
+        struct ata_host *host;
+        struct ata_port *ap;
+
+        host = ata_host_alloc(dev, 1);
+        if (!host)
+                return -ENOMEM;
+
+        ap = host->ports[0];
+
+        /* Setup ATA bindings */
+        ap->ops      = &at32_port_ops;
+        ap->pio_mask = PIO_MASK;
+        ap->flags    = ATA_FLAG_MMIO | ATA_FLAG_SLAVE_POSS
+                | ATA_FLAG_PIO_POLLING;
+
+        /*
+         * Since all 8-bit taskfile transfers has to go on the lower
+         * byte of the data bus and there is a bug in the SMC that
+         * makes it impossible to alter the bus width during runtime,
+         * we need to hardwire the address signals as follows:
+         *
+         *      A_IDE(2:0) <= A_EBI(3:1)
+         *
+         * This makes all addresses on the EBI even, thus all data
+         * will be on the lower byte of the data bus.  All addresses
+         * used by libATA need to be altered according to this.
+         */
+        ap->ioaddr.altstatus_addr = info->alt_addr + (0x06 << 1);
+        ap->ioaddr.ctl_addr       = info->alt_addr + (0x06 << 1);
+
+        ap->ioaddr.data_addr      = info->ide_addr + (ATA_REG_DATA << 1);
+        ap->ioaddr.error_addr     = info->ide_addr + (ATA_REG_ERR << 1);
+        ap->ioaddr.feature_addr   = info->ide_addr + (ATA_REG_FEATURE << 1);
+        ap->ioaddr.nsect_addr     = info->ide_addr + (ATA_REG_NSECT << 1);
+        ap->ioaddr.lbal_addr      = info->ide_addr + (ATA_REG_LBAL << 1);
+        ap->ioaddr.lbam_addr      = info->ide_addr + (ATA_REG_LBAM << 1);
+        ap->ioaddr.lbah_addr      = info->ide_addr + (ATA_REG_LBAH << 1);
+        ap->ioaddr.device_addr    = info->ide_addr + (ATA_REG_DEVICE << 1);
+        ap->ioaddr.status_addr    = info->ide_addr + (ATA_REG_STATUS << 1);
+        ap->ioaddr.command_addr   = info->ide_addr + (ATA_REG_CMD << 1);
+
+        /* Set info as private data of ATA host */
+        host->private_data = info;
+
+        /* Register ATA device and return */
+        return ata_host_activate(host, info->irq, ata_interrupt,
+                                 IRQF_SHARED | IRQF_TRIGGER_RISING,
+                                 &at32_sht);
+}
+
+/*
+ * This function may come in handy for people analyzing their own
+ * EBI -> PATA adaptors.
+ */
+#ifdef DEBUG_BUS
+
+static void __init pata_at32_debug_bus(struct device *dev,
+                                       struct at32_ide_info *info)
+{
+        const int d1 = 0xff;
+        const int d2 = 0x00;
+
+        int i;
+
+        /* Write 8-bit values (registers) */
+        iowrite8(d1, info->alt_addr + (0x06 << 1));
+        iowrite8(d2, info->alt_addr + (0x06 << 1));
+
+        for (i = 0; i < 8; i++) {
+                iowrite8(d1, info->ide_addr + (i << 1));
+                iowrite8(d2, info->ide_addr + (i << 1));
+        }
+
+        /* Write 16 bit values (data) */
+        iowrite16(d1,      info->ide_addr);
+        iowrite16(d1 << 8, info->ide_addr);
+
+        iowrite16(d1,      info->ide_addr);
+        iowrite16(d1 << 8, info->ide_addr);
+}
+
+#endif
+
+static int __init pata_at32_probe(struct platform_device *pdev)
+{
+        const struct ata_timing initial_timing =
+                {XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0};
+
+        struct device            *dev = &pdev->dev;
+        struct at32_ide_info     *info;
+        struct ide_platform_data *board = pdev->dev.platform_data;
+        struct resource          *res;
+
+        int irq;
+        int ret;
+
+        if (!board)
+                return -ENXIO;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENXIO;
+
+        /* Retrive IRQ */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        /* Setup struct containing private infomation */
+        info = kzalloc(sizeof(struct at32_ide_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        memset(info, 0, sizeof(struct at32_ide_info));
+
+        info->irq = irq;
+        info->cs  = board->cs;
+
+        /* Request memory resources */
+        info->res_ide.start = res->start + CF_IDE_OFFSET;
+        info->res_ide.end   = info->res_ide.start + CF_RES_SIZE - 1;
+        info->res_ide.name  = "ide";
+        info->res_ide.flags = IORESOURCE_MEM;
+
+        ret = request_resource(res, &info->res_ide);
+        if (ret)
+                goto err_req_res_ide;
+
+        info->res_alt.start = res->start + CF_ALT_IDE_OFFSET;
+        info->res_alt.end   = info->res_alt.start + CF_RES_SIZE - 1;
+        info->res_alt.name  = "alt";
+        info->res_alt.flags = IORESOURCE_MEM;
+
+        ret = request_resource(res, &info->res_alt);
+        if (ret)
+                goto err_req_res_alt;
+
+        /* Setup non-timing elements of SMC */
+        info->smc.bus_width      = 2; /* 16 bit data bus */
+        info->smc.nrd_controlled = 1; /* Sample data on rising edge of NRD */
+        info->smc.nwe_controlled = 0; /* Drive data on falling edge of NCS */
+        info->smc.nwait_mode     = 3; /* NWAIT is in READY mode */
+        info->smc.byte_write     = 0; /* Byte select access type */
+        info->smc.tdf_mode       = 0; /* TDF optimization disabled */
+        info->smc.tdf_cycles     = 0; /* No TDF wait cycles */
+
+        /* Setup ATA timing */
+        ret = pata_at32_setup_timing(dev, info, &initial_timing);
+        if (ret)
+                goto err_setup_timing;
+
+        /* Setup ATA addresses */
+        ret = -ENOMEM;
+        info->ide_addr = devm_ioremap(dev, info->res_ide.start, 16);
+        info->alt_addr = devm_ioremap(dev, info->res_alt.start, 16);
+        if (!info->ide_addr || !info->alt_addr)
+                goto err_ioremap;
+
+#ifdef DEBUG_BUS
+        pata_at32_debug_bus(dev, info);
+#endif
+
+        /* Register ATA device */
+        ret = pata_at32_init_one(dev, info);
+        if (ret)
+                goto err_ata_device;
+
+        return 0;
+
+ err_ata_device:
+ err_ioremap:
+ err_setup_timing:
+        release_resource(&info->res_alt);
+ err_req_res_alt:
+        release_resource(&info->res_ide);
+ err_req_res_ide:
+        kfree(info);
+
+        return ret;
+}
+
+static int __exit pata_at32_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = platform_get_drvdata(pdev);
+        struct at32_ide_info *info;
+
+        if (!host)
+                return 0;
+
+        info = host->private_data;
+        ata_host_detach(host);
+
+        if (!info)
+                return 0;
+
+        release_resource(&info->res_ide);
+        release_resource(&info->res_alt);
+
+        kfree(info);
+
+        return 0;
+}
+
+static struct platform_driver pata_at32_driver = {
+        .remove        = __exit_p(pata_at32_remove),
+        .driver        = {
+                .name  = "at32_ide",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init pata_at32_init(void)
+{
+        return platform_driver_probe(&pata_at32_driver, pata_at32_probe);
+}
+
+static void __exit pata_at32_exit(void)
+{
+        platform_driver_unregister(&pata_at32_driver);
+}
+
+module_init(pata_at32_init);
+module_exit(pata_at32_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("AVR32 SMC/CFC PATA Driver");
+MODULE_AUTHOR("Kristoffer Nyborg Gregertsen <kngregertsen@norway.atmel.com>");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 86f85a2cab..9623f52955 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -33,8 +33,9 @@ enum {
         ATIIXP_IDE_UDMA_MODE    = 0x56
 };
 
-static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int atiixp_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         static const struct pci_bits atiixp_enable_bits[] = {
                 { 0x48, 1, 0x01, 0x00 },
                 { 0x48, 1, 0x08, 0x00 }
@@ -44,7 +45,7 @@ static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &atiixp_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void atiixp_error_handler(struct ata_port *ap)
@@ -172,6 +173,9 @@ static void atiixp_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  *
  *      When DMA begins we need to ensure that the UDMA control
  *      register for the channel is correctly set.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void atiixp_bmdma_start(struct ata_queued_cmd *qc)
@@ -198,6 +202,9 @@ static void atiixp_bmdma_start(struct ata_queued_cmd *qc)
  *
  *      DMA has completed. Clear the UDMA flag as the next operations will
  *      be PIO ones not UDMA data transfer.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void atiixp_bmdma_stop(struct ata_queued_cmd *qc)
@@ -232,7 +239,6 @@ static struct scsi_host_template atiixp_sht = {
 };
 
 static struct ata_port_operations atiixp_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = atiixp_set_piomode,
         .set_dmamode    = atiixp_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -261,9 +267,8 @@ static struct ata_port_operations atiixp_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
new file mode 100644
index 0000000000..747549e456
--- /dev/null
+++ b/drivers/ata/pata_bf54x.c
@@ -0,0 +1,1627 @@
+/*
+ * File:         drivers/ata/pata_bf54x.c
+ * Author:       Sonic Zhang <sonic.zhang@analog.com>
+ *
+ * Created:
+ * Description:  PATA Driver for blackfin 54x
+ *
+ * Modified:
+ *               Copyright 2007 Analog Devices Inc.
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.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 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, see the file COPYING, or write
+ * to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/platform_device.h>
+#include <asm/dma.h>
+#include <asm/gpio.h>
+#include <asm/portmux.h>
+
+#define DRV_NAME                "pata-bf54x"
+#define DRV_VERSION             "0.9"
+
+#define ATA_REG_CTRL            0x0E
+#define ATA_REG_ALTSTATUS       ATA_REG_CTRL
+
+/* These are the offset of the controller's registers */
+#define ATAPI_OFFSET_CONTROL            0x00
+#define ATAPI_OFFSET_STATUS             0x04
+#define ATAPI_OFFSET_DEV_ADDR           0x08
+#define ATAPI_OFFSET_DEV_TXBUF          0x0c
+#define ATAPI_OFFSET_DEV_RXBUF          0x10
+#define ATAPI_OFFSET_INT_MASK           0x14
+#define ATAPI_OFFSET_INT_STATUS         0x18
+#define ATAPI_OFFSET_XFER_LEN           0x1c
+#define ATAPI_OFFSET_LINE_STATUS        0x20
+#define ATAPI_OFFSET_SM_STATE           0x24
+#define ATAPI_OFFSET_TERMINATE          0x28
+#define ATAPI_OFFSET_PIO_TFRCNT         0x2c
+#define ATAPI_OFFSET_DMA_TFRCNT         0x30
+#define ATAPI_OFFSET_UMAIN_TFRCNT       0x34
+#define ATAPI_OFFSET_UDMAOUT_TFRCNT     0x38
+#define ATAPI_OFFSET_REG_TIM_0          0x40
+#define ATAPI_OFFSET_PIO_TIM_0          0x44
+#define ATAPI_OFFSET_PIO_TIM_1          0x48
+#define ATAPI_OFFSET_MULTI_TIM_0        0x50
+#define ATAPI_OFFSET_MULTI_TIM_1        0x54
+#define ATAPI_OFFSET_MULTI_TIM_2        0x58
+#define ATAPI_OFFSET_ULTRA_TIM_0        0x60
+#define ATAPI_OFFSET_ULTRA_TIM_1        0x64
+#define ATAPI_OFFSET_ULTRA_TIM_2        0x68
+#define ATAPI_OFFSET_ULTRA_TIM_3        0x6c
+
+
+#define ATAPI_GET_CONTROL(base)\
+        bfin_read16(base + ATAPI_OFFSET_CONTROL)
+#define ATAPI_SET_CONTROL(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_CONTROL, val)
+#define ATAPI_GET_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_STATUS)
+#define ATAPI_GET_DEV_ADDR(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_ADDR)
+#define ATAPI_SET_DEV_ADDR(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_ADDR, val)
+#define ATAPI_GET_DEV_TXBUF(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_TXBUF)
+#define ATAPI_SET_DEV_TXBUF(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_TXBUF, val)
+#define ATAPI_GET_DEV_RXBUF(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_RXBUF)
+#define ATAPI_SET_DEV_RXBUF(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_RXBUF, val)
+#define ATAPI_GET_INT_MASK(base)\
+        bfin_read16(base + ATAPI_OFFSET_INT_MASK)
+#define ATAPI_SET_INT_MASK(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_INT_MASK, val)
+#define ATAPI_GET_INT_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_INT_STATUS)
+#define ATAPI_SET_INT_STATUS(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_INT_STATUS, val)
+#define ATAPI_GET_XFER_LEN(base)\
+        bfin_read16(base + ATAPI_OFFSET_XFER_LEN)
+#define ATAPI_SET_XFER_LEN(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_XFER_LEN, val)
+#define ATAPI_GET_LINE_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_LINE_STATUS)
+#define ATAPI_GET_SM_STATE(base)\
+        bfin_read16(base + ATAPI_OFFSET_SM_STATE)
+#define ATAPI_GET_TERMINATE(base)\
+        bfin_read16(base + ATAPI_OFFSET_TERMINATE)
+#define ATAPI_SET_TERMINATE(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_TERMINATE, val)
+#define ATAPI_GET_PIO_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TFRCNT)
+#define ATAPI_GET_DMA_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_DMA_TFRCNT)
+#define ATAPI_GET_UMAIN_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_UMAIN_TFRCNT)
+#define ATAPI_GET_UDMAOUT_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_UDMAOUT_TFRCNT)
+#define ATAPI_GET_REG_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_REG_TIM_0)
+#define ATAPI_SET_REG_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_REG_TIM_0, val)
+#define ATAPI_GET_PIO_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TIM_0)
+#define ATAPI_SET_PIO_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_PIO_TIM_0, val)
+#define ATAPI_GET_PIO_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TIM_1)
+#define ATAPI_SET_PIO_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_PIO_TIM_1, val)
+#define ATAPI_GET_MULTI_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_0)
+#define ATAPI_SET_MULTI_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_0, val)
+#define ATAPI_GET_MULTI_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_1)
+#define ATAPI_SET_MULTI_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_1, val)
+#define ATAPI_GET_MULTI_TIM_2(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_2)
+#define ATAPI_SET_MULTI_TIM_2(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_2, val)
+#define ATAPI_GET_ULTRA_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_0)
+#define ATAPI_SET_ULTRA_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_0, val)
+#define ATAPI_GET_ULTRA_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_1)
+#define ATAPI_SET_ULTRA_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_1, val)
+#define ATAPI_GET_ULTRA_TIM_2(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_2)
+#define ATAPI_SET_ULTRA_TIM_2(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_2, val)
+#define ATAPI_GET_ULTRA_TIM_3(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_3)
+#define ATAPI_SET_ULTRA_TIM_3(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_3, val)
+
+/**
+ * PIO Mode - Frequency compatibility
+ */
+/* mode: 0         1         2         3         4 */
+static const u32 pio_fsclk[] =
+{ 33333333, 33333333, 33333333, 33333333, 33333333 };
+
+/**
+ * MDMA Mode - Frequency compatibility
+ */
+/*               mode:      0         1         2        */
+static const u32 mdma_fsclk[] = { 33333333, 33333333, 33333333 };
+
+/**
+ * UDMA Mode - Frequency compatibility
+ *
+ * UDMA5 - 100 MB/s   - SCLK  = 133 MHz
+ * UDMA4 - 66 MB/s    - SCLK >=  80 MHz
+ * UDMA3 - 44.4 MB/s  - SCLK >=  50 MHz
+ * UDMA2 - 33 MB/s    - SCLK >=  40 MHz
+ */
+/* mode: 0         1         2         3         4          5 */
+static const u32 udma_fsclk[] =
+{ 33333333, 33333333, 40000000, 50000000, 80000000, 133333333 };
+
+/**
+ * Register transfer timing table
+ */
+/*               mode:       0    1    2    3    4    */
+/* Cycle Time                     */
+static const u32 reg_t0min[]   = { 600, 383, 330, 180, 120 };
+/* DIOR/DIOW to end cycle         */
+static const u32 reg_t2min[]   = { 290, 290, 290, 70,  25  };
+/* DIOR/DIOW asserted pulse width */
+static const u32 reg_teocmin[] = { 290, 290, 290, 80,  70  };
+
+/**
+ * PIO timing table
+ */
+/*               mode:       0    1    2    3    4    */
+/* Cycle Time                     */
+static const u32 pio_t0min[]   = { 600, 383, 240, 180, 120 };
+/* Address valid to DIOR/DIORW    */
+static const u32 pio_t1min[]   = { 70,  50,  30,  30,  25  };
+/* DIOR/DIOW to end cycle         */
+static const u32 pio_t2min[]   = { 165, 125, 100, 80,  70  };
+/* DIOR/DIOW asserted pulse width */
+static const u32 pio_teocmin[] = { 165, 125, 100, 70,  25  };
+/* DIOW data hold                 */
+static const u32 pio_t4min[]   = { 30,  20,  15,  10,  10  };
+
+/* ******************************************************************
+ * Multiword DMA timing table
+ * ******************************************************************
+ */
+/*               mode:       0   1    2        */
+/* Cycle Time                     */
+static const u32 mdma_t0min[]  = { 480, 150, 120 };
+/* DIOR/DIOW asserted pulse width */
+static const u32 mdma_tdmin[]  = { 215, 80,  70  };
+/* DMACK to read data released    */
+static const u32 mdma_thmin[]  = { 20,  15,  10  };
+/* DIOR/DIOW to DMACK hold        */
+static const u32 mdma_tjmin[]  = { 20,  5,   5   };
+/* DIOR negated pulse width       */
+static const u32 mdma_tkrmin[] = { 50,  50,  25  };
+/* DIOR negated pulse width       */
+static const u32 mdma_tkwmin[] = { 215, 50,  25  };
+/* CS[1:0] valid to DIOR/DIOW     */
+static const u32 mdma_tmmin[]  = { 50,  30,  25  };
+/* DMACK to read data released    */
+static const u32 mdma_tzmax[]  = { 20,  25,  25  };
+
+/**
+ * Ultra DMA timing table
+ */
+/*               mode:         0    1    2    3    4    5       */
+static const u32 udma_tcycmin[]  = { 112, 73,  54,  39,  25,  17 };
+static const u32 udma_tdvsmin[]  = { 70,  48,  31,  20,  7,   5  };
+static const u32 udma_tenvmax[]  = { 70,  70,  70,  55,  55,  50 };
+static const u32 udma_trpmin[]   = { 160, 125, 100, 100, 100, 85 };
+static const u32 udma_tmin[]     = { 5,   5,   5,   5,   3,   3  };
+
+
+static const u32 udma_tmlimin = 20;
+static const u32 udma_tzahmin = 20;
+static const u32 udma_tenvmin = 20;
+static const u32 udma_tackmin = 20;
+static const u32 udma_tssmin = 50;
+
+/**
+ *
+ *      Function:       num_clocks_min
+ *
+ *      Description:
+ *      calculate number of SCLK cycles to meet minimum timing
+ */
+static unsigned short num_clocks_min(unsigned long tmin,
+                                unsigned long fsclk)
+{
+        unsigned long tmp ;
+        unsigned short result;
+
+        tmp = tmin * (fsclk/1000/1000) / 1000;
+        result = (unsigned short)tmp;
+        if ((tmp*1000*1000) < (tmin*(fsclk/1000))) {
+                result++;
+        }
+
+        return result;
+}
+
+/**
+ *      bfin_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: um
+ *
+ *      Set PIO mode for device.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void bfin_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        int mode = adev->pio_mode - XFER_PIO_0;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int fsclk = get_sclk();
+        unsigned short teoc_reg, t2_reg, teoc_pio;
+        unsigned short t4_reg, t2_pio, t1_reg;
+        unsigned short n0, n6, t6min = 5;
+
+        /* the most restrictive timing value is t6 and tc, the DIOW - data hold
+        * If one SCLK pulse is longer than this minimum value then register
+        * transfers cannot be supported at this frequency.
+        */
+        n6 = num_clocks_min(t6min, fsclk);
+        if (mode >= 0 && mode <= 4 && n6 >= 1) {
+                pr_debug("set piomode: mode=%d, fsclk=%ud\n", mode, fsclk);
+                /* calculate the timing values for register transfers. */
+                while (mode > 0 && pio_fsclk[mode] > fsclk)
+                        mode--;
+
+                /* DIOR/DIOW to end cycle time */
+                t2_reg = num_clocks_min(reg_t2min[mode], fsclk);
+                /* DIOR/DIOW asserted pulse width */
+                teoc_reg = num_clocks_min(reg_teocmin[mode], fsclk);
+                /* Cycle Time */
+                n0  = num_clocks_min(reg_t0min[mode], fsclk);
+
+                /* increase t2 until we meed the minimum cycle length */
+                if (t2_reg + teoc_reg < n0)
+                        t2_reg = n0 - teoc_reg;
+
+                /* calculate the timing values for pio transfers. */
+
+                /* DIOR/DIOW to end cycle time */
+                t2_pio = num_clocks_min(pio_t2min[mode], fsclk);
+                /* DIOR/DIOW asserted pulse width */
+                teoc_pio = num_clocks_min(pio_teocmin[mode], fsclk);
+                /* Cycle Time */
+                n0  = num_clocks_min(pio_t0min[mode], fsclk);
+
+                /* increase t2 until we meed the minimum cycle length */
+                if (t2_pio + teoc_pio < n0)
+                        t2_pio = n0 - teoc_pio;
+
+                /* Address valid to DIOR/DIORW */
+                t1_reg = num_clocks_min(pio_t1min[mode], fsclk);
+
+                /* DIOW data hold */
+                t4_reg = num_clocks_min(pio_t4min[mode], fsclk);
+
+                ATAPI_SET_REG_TIM_0(base, (teoc_reg<<8 | t2_reg));
+                ATAPI_SET_PIO_TIM_0(base, (t4_reg<<12 | t2_pio<<4 | t1_reg));
+                ATAPI_SET_PIO_TIM_1(base, teoc_pio);
+                if (mode > 2) {
+                        ATAPI_SET_CONTROL(base,
+                                ATAPI_GET_CONTROL(base) | IORDY_EN);
+                } else {
+                        ATAPI_SET_CONTROL(base,
+                                ATAPI_GET_CONTROL(base) & ~IORDY_EN);
+                }
+
+                /* Disable host ATAPI PIO interrupts */
+                ATAPI_SET_INT_MASK(base, ATAPI_GET_INT_MASK(base)
+                        & ~(PIO_DONE_MASK | HOST_TERM_XFER_MASK));
+                SSYNC();
+        }
+}
+
+/**
+ *      bfin_set_dmamode - Initialize host controller PATA DMA timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: um
+ *      @udma: udma mode, 0 - 6
+ *
+ *      Set UDMA mode for device.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void bfin_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        int mode;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned long fsclk = get_sclk();
+        unsigned short tenv, tack, tcyc_tdvs, tdvs, tmli, tss, trp, tzah;
+        unsigned short tm, td, tkr, tkw, teoc, th;
+        unsigned short n0, nf, tfmin = 5;
+        unsigned short nmin, tcyc;
+
+        mode = adev->dma_mode - XFER_UDMA_0;
+        if (mode >= 0 && mode <= 5) {
+                pr_debug("set udmamode: mode=%d\n", mode);
+                /* the most restrictive timing value is t6 and tc,
+                 * the DIOW - data hold. If one SCLK pulse is longer
+                 * than this minimum value then register
+                 * transfers cannot be supported at this frequency.
+                 */
+                while (mode > 0 && udma_fsclk[mode] > fsclk)
+                        mode--;
+
+                nmin = num_clocks_min(udma_tmin[mode], fsclk);
+                if (nmin >= 1) {
+                        /* calculate the timing values for Ultra DMA. */
+                        tdvs = num_clocks_min(udma_tdvsmin[mode], fsclk);
+                        tcyc = num_clocks_min(udma_tcycmin[mode], fsclk);
+                        tcyc_tdvs = 2;
+
+                        /* increase tcyc - tdvs (tcyc_tdvs) until we meed
+                         * the minimum cycle length
+                         */
+                        if (tdvs + tcyc_tdvs < tcyc)
+                                tcyc_tdvs = tcyc - tdvs;
+
+                        /* Mow assign the values required for the timing
+                         * registers
+                         */
+                        if (tcyc_tdvs < 2)
+                                tcyc_tdvs = 2;
+
+                        if (tdvs < 2)
+                                tdvs = 2;
+
+                        tack = num_clocks_min(udma_tackmin, fsclk);
+                        tss = num_clocks_min(udma_tssmin, fsclk);
+                        tmli = num_clocks_min(udma_tmlimin, fsclk);
+                        tzah = num_clocks_min(udma_tzahmin, fsclk);
+                        trp = num_clocks_min(udma_trpmin[mode], fsclk);
+                        tenv = num_clocks_min(udma_tenvmin, fsclk);
+                        if (tenv <= udma_tenvmax[mode]) {
+                                ATAPI_SET_ULTRA_TIM_0(base, (tenv<<8 | tack));
+                                ATAPI_SET_ULTRA_TIM_1(base,
+                                        (tcyc_tdvs<<8 | tdvs));
+                                ATAPI_SET_ULTRA_TIM_2(base, (tmli<<8 | tss));
+                                ATAPI_SET_ULTRA_TIM_3(base, (trp<<8 | tzah));
+
+                                /* Enable host ATAPI Untra DMA interrupts */
+                                ATAPI_SET_INT_MASK(base,
+                                        ATAPI_GET_INT_MASK(base)
+                                        | UDMAIN_DONE_MASK
+                                        | UDMAOUT_DONE_MASK
+                                        | UDMAIN_TERM_MASK
+                                        | UDMAOUT_TERM_MASK);
+                        }
+                }
+        }
+
+        mode = adev->dma_mode - XFER_MW_DMA_0;
+        if (mode >= 0 && mode <= 2) {
+                pr_debug("set mdmamode: mode=%d\n", mode);
+                /* the most restrictive timing value is tf, the DMACK to
+                 * read data released. If one SCLK pulse is longer than
+                 * this maximum value then the MDMA mode
+                 * cannot be supported at this frequency.
+                 */
+                while (mode > 0 && mdma_fsclk[mode] > fsclk)
+                        mode--;
+
+                nf = num_clocks_min(tfmin, fsclk);
+                if (nf >= 1) {
+                        /* calculate the timing values for Multi-word DMA. */
+
+                        /* DIOR/DIOW asserted pulse width */
+                        td = num_clocks_min(mdma_tdmin[mode], fsclk);
+
+                        /* DIOR negated pulse width */
+                        tkw = num_clocks_min(mdma_tkwmin[mode], fsclk);
+
+                        /* Cycle Time */
+                        n0  = num_clocks_min(mdma_t0min[mode], fsclk);
+
+                        /* increase tk until we meed the minimum cycle length */
+                        if (tkw + td < n0)
+                                tkw = n0 - td;
+
+                        /* DIOR negated pulse width - read */
+                        tkr = num_clocks_min(mdma_tkrmin[mode], fsclk);
+                        /* CS{1:0] valid to DIOR/DIOW */
+                        tm = num_clocks_min(mdma_tmmin[mode], fsclk);
+                        /* DIOR/DIOW to DMACK hold */
+                        teoc = num_clocks_min(mdma_tjmin[mode], fsclk);
+                        /* DIOW Data hold */
+                        th = num_clocks_min(mdma_thmin[mode], fsclk);
+
+                        ATAPI_SET_MULTI_TIM_0(base, (tm<<8 | td));
+                        ATAPI_SET_MULTI_TIM_1(base, (tkr<<8 | tkw));
+                        ATAPI_SET_MULTI_TIM_2(base, (teoc<<8 | th));
+
+                        /* Enable host ATAPI Multi DMA interrupts */
+                        ATAPI_SET_INT_MASK(base, ATAPI_GET_INT_MASK(base)
+                                | MULTI_DONE_MASK | MULTI_TERM_MASK);
+                        SSYNC();
+                }
+        }
+        return;
+}
+
+/**
+ *
+ *    Function:       wait_complete
+ *
+ *    Description:    Waits the interrupt from device
+ *
+ */
+static inline void wait_complete(void __iomem *base, unsigned short mask)
+{
+        unsigned short status;
+        unsigned int i = 0;
+
+#define PATA_BF54X_WAIT_TIMEOUT         10000
+
+        for (i = 0; i < PATA_BF54X_WAIT_TIMEOUT; i++) {
+                status = ATAPI_GET_INT_STATUS(base) & mask;
+                if (status)
+                        break;
+        }
+
+        ATAPI_SET_INT_STATUS(base, mask);
+}
+
+/**
+ *
+ *    Function:       write_atapi_register
+ *
+ *    Description:    Writes to ATA Device Resgister
+ *
+ */
+
+static void write_atapi_register(void __iomem *base,
+                unsigned long ata_reg, unsigned short value)
+{
+        /* Program the ATA_DEV_TXBUF register with write data (to be
+         * written into the device).
+         */
+        ATAPI_SET_DEV_TXBUF(base, value);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * device register (0x01 to 0x0F).
+         */
+        ATAPI_SET_DEV_ADDR(base, ata_reg);
+
+        /* Program the ATA_CTRL register with dir set to write (1)
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        /* and start the transfer */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+        /* Wait for the interrupt to indicate the end of the transfer.
+         * (We need to wait on and clear rhe ATA_DEV_INT interrupt status)
+         */
+        wait_complete(base, PIO_DONE_INT);
+}
+
+/**
+ *
+ *      Function:       read_atapi_register
+ *
+ *Description:    Reads from ATA Device Resgister
+ *
+ */
+
+static unsigned short read_atapi_register(void __iomem *base,
+                unsigned long ata_reg)
+{
+        /* Program the ATA_DEV_ADDR register with address of the
+         * device register (0x01 to 0x0F).
+         */
+        ATAPI_SET_DEV_ADDR(base, ata_reg);
+
+        /* Program the ATA_CTRL register with dir set to read (0) and
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        /* and start the transfer */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+        /* Wait for the interrupt to indicate the end of the transfer.
+         * (PIO_DONE interrupt is set and it doesn't seem to matter
+         * that we don't clear it)
+         */
+        wait_complete(base, PIO_DONE_INT);
+
+        /* Read the ATA_DEV_RXBUF register with write data (to be
+         * written into the device).
+         */
+        return ATAPI_GET_DEV_RXBUF(base);
+}
+
+/**
+ *
+ *    Function:       write_atapi_register_data
+ *
+ *    Description:    Writes to ATA Device Resgister
+ *
+ */
+
+static void write_atapi_data(void __iomem *base,
+                int len, unsigned short *buf)
+{
+        int i;
+
+        /* Set transfer length to 1 */
+        ATAPI_SET_XFER_LEN(base, 1);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * ATA_REG_DATA
+         */
+        ATAPI_SET_DEV_ADDR(base, ATA_REG_DATA);
+
+        /* Program the ATA_CTRL register with dir set to write (1)
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        for (i = 0; i < len; i++) {
+                /* Program the ATA_DEV_TXBUF register with write data (to be
+                 * written into the device).
+                 */
+                ATAPI_SET_DEV_TXBUF(base, buf[i]);
+
+                /* and start the transfer */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+                /* Wait for the interrupt to indicate the end of the transfer.
+                 * (We need to wait on and clear rhe ATA_DEV_INT
+                 * interrupt status)
+                 */
+                wait_complete(base, PIO_DONE_INT);
+        }
+}
+
+/**
+ *
+ *      Function:       read_atapi_register_data
+ *
+ *      Description:    Reads from ATA Device Resgister
+ *
+ */
+
+static void read_atapi_data(void __iomem *base,
+                int len, unsigned short *buf)
+{
+        int i;
+
+        /* Set transfer length to 1 */
+        ATAPI_SET_XFER_LEN(base, 1);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * ATA_REG_DATA
+         */
+        ATAPI_SET_DEV_ADDR(base, ATA_REG_DATA);
+
+        /* Program the ATA_CTRL register with dir set to read (0) and
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        for (i = 0; i < len; i++) {
+                /* and start the transfer */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+                /* Wait for the interrupt to indicate the end of the transfer.
+                 * (PIO_DONE interrupt is set and it doesn't seem to matter
+                 * that we don't clear it)
+                 */
+                wait_complete(base, PIO_DONE_INT);
+
+                /* Read the ATA_DEV_RXBUF register with write data (to be
+                 * written into the device).
+                 */
+                buf[i] = ATAPI_GET_DEV_RXBUF(base);
+        }
+}
+
+/**
+ *      bfin_tf_load - send taskfile registers to host controller
+ *      @ap: Port to which output is sent
+ *      @tf: ATA taskfile register set
+ *
+ *      Note: Original code is ata_tf_load().
+ */
+
+static void bfin_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
+
+        if (tf->ctl != ap->last_ctl) {
+                write_atapi_register(base, ATA_REG_CTRL, tf->ctl);
+                ap->last_ctl = tf->ctl;
+                ata_wait_idle(ap);
+        }
+
+        if (is_addr) {
+                if (tf->flags & ATA_TFLAG_LBA48) {
+                        write_atapi_register(base, ATA_REG_FEATURE,
+                                                tf->hob_feature);
+                        write_atapi_register(base, ATA_REG_NSECT,
+                                                tf->hob_nsect);
+                        write_atapi_register(base, ATA_REG_LBAL, tf->hob_lbal);
+                        write_atapi_register(base, ATA_REG_LBAM, tf->hob_lbam);
+                        write_atapi_register(base, ATA_REG_LBAH, tf->hob_lbah);
+                        pr_debug("hob: feat 0x%X nsect 0x%X, lba 0x%X "
+                                 "0x%X 0x%X\n",
+                                tf->hob_feature,
+                                tf->hob_nsect,
+                                tf->hob_lbal,
+                                tf->hob_lbam,
+                                tf->hob_lbah);
+                }
+
+                write_atapi_register(base, ATA_REG_FEATURE, tf->feature);
+                write_atapi_register(base, ATA_REG_NSECT, tf->nsect);
+                write_atapi_register(base, ATA_REG_LBAL, tf->lbal);
+                write_atapi_register(base, ATA_REG_LBAM, tf->lbam);
+                write_atapi_register(base, ATA_REG_LBAH, tf->lbah);
+                pr_debug("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
+                        tf->feature,
+                        tf->nsect,
+                        tf->lbal,
+                        tf->lbam,
+                        tf->lbah);
+        }
+
+        if (tf->flags & ATA_TFLAG_DEVICE) {
+                write_atapi_register(base, ATA_REG_DEVICE, tf->device);
+                pr_debug("device 0x%X\n", tf->device);
+        }
+
+        ata_wait_idle(ap);
+}
+
+/**
+ *      bfin_check_status - Read device status reg & clear interrupt
+ *      @ap: port where the device is
+ *
+ *      Note: Original code is ata_check_status().
+ */
+
+static u8 bfin_check_status(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        return read_atapi_register(base, ATA_REG_STATUS);
+}
+
+/**
+ *      bfin_tf_read - input device's ATA taskfile shadow registers
+ *      @ap: Port from which input is read
+ *      @tf: ATA taskfile register set for storing input
+ *
+ *      Note: Original code is ata_tf_read().
+ */
+
+static void bfin_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        tf->command = bfin_check_status(ap);
+        tf->feature = read_atapi_register(base, ATA_REG_ERR);
+        tf->nsect = read_atapi_register(base, ATA_REG_NSECT);
+        tf->lbal = read_atapi_register(base, ATA_REG_LBAL);
+        tf->lbam = read_atapi_register(base, ATA_REG_LBAM);
+        tf->lbah = read_atapi_register(base, ATA_REG_LBAH);
+        tf->device = read_atapi_register(base, ATA_REG_DEVICE);
+
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                write_atapi_register(base, ATA_REG_CTRL, tf->ctl | ATA_HOB);
+                tf->hob_feature = read_atapi_register(base, ATA_REG_ERR);
+                tf->hob_nsect = read_atapi_register(base, ATA_REG_NSECT);
+                tf->hob_lbal = read_atapi_register(base, ATA_REG_LBAL);
+                tf->hob_lbam = read_atapi_register(base, ATA_REG_LBAM);
+                tf->hob_lbah = read_atapi_register(base, ATA_REG_LBAH);
+        }
+}
+
+/**
+ *      bfin_exec_command - issue ATA command to host controller
+ *      @ap: port to which command is being issued
+ *      @tf: ATA taskfile register set
+ *
+ *      Note: Original code is ata_exec_command().
+ */
+
+static void bfin_exec_command(struct ata_port *ap,
+                              const struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        pr_debug("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
+
+        write_atapi_register(base, ATA_REG_CMD, tf->command);
+        ata_pause(ap);
+}
+
+/**
+ *      bfin_check_altstatus - Read device alternate status reg
+ *      @ap: port where the device is
+ */
+
+static u8 bfin_check_altstatus(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        return read_atapi_register(base, ATA_REG_ALTSTATUS);
+}
+
+/**
+ *      bfin_std_dev_select - Select device 0/1 on ATA bus
+ *      @ap: ATA channel to manipulate
+ *      @device: ATA device (numbered from zero) to select
+ *
+ *      Note: Original code is ata_std_dev_select().
+ */
+
+static void bfin_std_dev_select(struct ata_port *ap, unsigned int device)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 tmp;
+
+        if (device == 0)
+                tmp = ATA_DEVICE_OBS;
+        else
+                tmp = ATA_DEVICE_OBS | ATA_DEV1;
+
+        write_atapi_register(base, ATA_REG_DEVICE, tmp);
+        ata_pause(ap);
+}
+
+/**
+ *      bfin_bmdma_setup - Set up IDE DMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_setup().
+ */
+
+static void bfin_bmdma_setup(struct ata_queued_cmd *qc)
+{
+        unsigned short config = WDSIZE_16;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma setup\n");
+        /* Program the ATA_CTRL register with dir */
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                /* fill the ATAPI DMA controller */
+                set_dma_config(CH_ATAPI_TX, config);
+                set_dma_x_modify(CH_ATAPI_TX, 2);
+                ata_for_each_sg(sg, qc) {
+                        set_dma_start_addr(CH_ATAPI_TX, sg_dma_address(sg));
+                        set_dma_x_count(CH_ATAPI_TX, sg_dma_len(sg) >> 1);
+                }
+        } else {
+                config |= WNR;
+                /* fill the ATAPI DMA controller */
+                set_dma_config(CH_ATAPI_RX, config);
+                set_dma_x_modify(CH_ATAPI_RX, 2);
+                ata_for_each_sg(sg, qc) {
+                        set_dma_start_addr(CH_ATAPI_RX, sg_dma_address(sg));
+                        set_dma_x_count(CH_ATAPI_RX, sg_dma_len(sg) >> 1);
+                }
+        }
+}
+
+/**
+ *      bfin_bmdma_start - Start an IDE DMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_start().
+ */
+
+static void bfin_bmdma_start(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma start\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return;
+
+        /* start ATAPI DMA controller*/
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                /*
+                 * On blackfin arch, uncacheable memory is not
+                 * allocated with flag GFP_DMA. DMA buffer from
+                 * common kenel code should be flushed if WB
+                 * data cache is enabled. Otherwise, this loop
+                 * is an empty loop and optimized out.
+                 */
+                ata_for_each_sg(sg, qc) {
+                        flush_dcache_range(sg_dma_address(sg),
+                                sg_dma_address(sg) + sg_dma_len(sg));
+                }
+                enable_dma(CH_ATAPI_TX);
+                pr_debug("enable udma write\n");
+
+                /* Send ATA DMA write command */
+                bfin_exec_command(ap, &qc->tf);
+
+                /* set ATA DMA write direction */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
+                        | XFER_DIR));
+        } else {
+                enable_dma(CH_ATAPI_RX);
+                pr_debug("enable udma read\n");
+
+                /* Send ATA DMA read command */
+                bfin_exec_command(ap, &qc->tf);
+
+                /* set ATA DMA read direction */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
+                        & ~XFER_DIR));
+        }
+
+        /* Reset all transfer count */
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) | TFRCNT_RST);
+
+                /* Set transfer length to buffer len */
+        ata_for_each_sg(sg, qc) {
+                ATAPI_SET_XFER_LEN(base, (sg_dma_len(sg) >> 1));
+        }
+
+        /* Enable ATA DMA operation*/
+        if (ap->udma_mask)
+                ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base)
+                        | ULTRA_START);
+        else
+                ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base)
+                        | MULTI_START);
+}
+
+/**
+ *      bfin_bmdma_stop - Stop IDE DMA transfer
+ *      @qc: Command we are ending DMA for
+ */
+
+static void bfin_bmdma_stop(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma stop\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return;
+
+        /* stop ATAPI DMA controller*/
+        if (qc->tf.flags & ATA_TFLAG_WRITE)
+                disable_dma(CH_ATAPI_TX);
+        else {
+                disable_dma(CH_ATAPI_RX);
+                if (ap->hsm_task_state & HSM_ST_LAST) {
+                        /*
+                         * On blackfin arch, uncacheable memory is not
+                         * allocated with flag GFP_DMA. DMA buffer from
+                         * common kenel code should be invalidated if
+                         * data cache is enabled. Otherwise, this loop
+                         * is an empty loop and optimized out.
+                         */
+                        ata_for_each_sg(sg, qc) {
+                                invalidate_dcache_range(
+                                        sg_dma_address(sg),
+                                        sg_dma_address(sg)
+                                        + sg_dma_len(sg));
+                        }
+                }
+        }
+}
+
+/**
+ *      bfin_devchk - PATA device presence detection
+ *      @ap: ATA channel to examine
+ *      @device: Device to examine (starting at zero)
+ *
+ *      Note: Original code is ata_devchk().
+ */
+
+static unsigned int bfin_devchk(struct ata_port *ap,
+                                unsigned int device)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 nsect, lbal;
+
+        bfin_std_dev_select(ap, device);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0x55);
+        write_atapi_register(base, ATA_REG_LBAL, 0xaa);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0xaa);
+        write_atapi_register(base, ATA_REG_LBAL, 0x55);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0x55);
+        write_atapi_register(base, ATA_REG_LBAL, 0xaa);
+
+        nsect = read_atapi_register(base, ATA_REG_NSECT);
+        lbal = read_atapi_register(base, ATA_REG_LBAL);
+
+        if ((nsect == 0x55) && (lbal == 0xaa))
+                return 1;       /* we found a device */
+
+        return 0;               /* nothing found */
+}
+
+/**
+ *      bfin_bus_post_reset - PATA device post reset
+ *
+ *      Note: Original code is ata_bus_post_reset().
+ */
+
+static void bfin_bus_post_reset(struct ata_port *ap, unsigned int devmask)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int dev0 = devmask & (1 << 0);
+        unsigned int dev1 = devmask & (1 << 1);
+        unsigned long timeout;
+
+        /* if device 0 was found in ata_devchk, wait for its
+         * BSY bit to clear
+         */
+        if (dev0)
+                ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+        /* if device 1 was found in ata_devchk, wait for
+         * register access, then wait for BSY to clear
+         */
+        timeout = jiffies + ATA_TMOUT_BOOT;
+        while (dev1) {
+                u8 nsect, lbal;
+
+                bfin_std_dev_select(ap, 1);
+                nsect = read_atapi_register(base, ATA_REG_NSECT);
+                lbal = read_atapi_register(base, ATA_REG_LBAL);
+                if ((nsect == 1) && (lbal == 1))
+                        break;
+                if (time_after(jiffies, timeout)) {
+                        dev1 = 0;
+                        break;
+                }
+                msleep(50);     /* give drive a breather */
+        }
+        if (dev1)
+                ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+        /* is all this really necessary? */
+        bfin_std_dev_select(ap, 0);
+        if (dev1)
+                bfin_std_dev_select(ap, 1);
+        if (dev0)
+                bfin_std_dev_select(ap, 0);
+}
+
+/**
+ *      bfin_bus_softreset - PATA device software reset
+ *
+ *      Note: Original code is ata_bus_softreset().
+ */
+
+static unsigned int bfin_bus_softreset(struct ata_port *ap,
+                                       unsigned int devmask)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* software reset.  causes dev0 to be selected */
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+        udelay(20);
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl | ATA_SRST);
+        udelay(20);
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+
+        /* spec mandates ">= 2ms" before checking status.
+         * We wait 150ms, because that was the magic delay used for
+         * ATAPI devices in Hale Landis's ATADRVR, for the period of time
+         * between when the ATA command register is written, and then
+         * status is checked.  Because waiting for "a while" before
+         * checking status is fine, post SRST, we perform this magic
+         * delay here as well.
+         *
+         * Old drivers/ide uses the 2mS rule and then waits for ready
+         */
+        msleep(150);
+
+        /* Before we perform post reset processing we want to see if
+         * the bus shows 0xFF because the odd clown forgets the D7
+         * pulldown resistor.
+         */
+        if (bfin_check_status(ap) == 0xFF)
+                return 0;
+
+        bfin_bus_post_reset(ap, devmask);
+
+        return 0;
+}
+
+/**
+ *      bfin_std_softreset - reset host port via ATA SRST
+ *      @ap: port to reset
+ *      @classes: resulting classes of attached devices
+ *
+ *      Note: Original code is ata_std_softreset().
+ */
+
+static int bfin_std_softreset(struct ata_port *ap, unsigned int *classes,
+                unsigned long deadline)
+{
+        unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
+        unsigned int devmask = 0, err_mask;
+        u8 err;
+
+        if (ata_port_offline(ap)) {
+                classes[0] = ATA_DEV_NONE;
+                goto out;
+        }
+
+        /* determine if device 0/1 are present */
+        if (bfin_devchk(ap, 0))
+                devmask |= (1 << 0);
+        if (slave_possible && bfin_devchk(ap, 1))
+                devmask |= (1 << 1);
+
+        /* select device 0 again */
+        bfin_std_dev_select(ap, 0);
+
+        /* issue bus reset */
+        err_mask = bfin_bus_softreset(ap, devmask);
+        if (err_mask) {
+                ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
+                                err_mask);
+                return -EIO;
+        }
+
+        /* determine by signature whether we have ATA or ATAPI devices */
+        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        if (slave_possible && err != 0x81)
+                classes[1] = ata_dev_try_classify(ap, 1, &err);
+
+ out:
+        return 0;
+}
+
+/**
+ *      bfin_bmdma_status - Read IDE DMA status
+ *      @ap: Port associated with this ATA transaction.
+ */
+
+static unsigned char bfin_bmdma_status(struct ata_port *ap)
+{
+        unsigned char host_stat = 0;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned short int_status = ATAPI_GET_INT_STATUS(base);
+
+        if (ATAPI_GET_STATUS(base) & (MULTI_XFER_ON|ULTRA_XFER_ON)) {
+                host_stat = ATA_DMA_ACTIVE;
+        }
+        if (int_status & (MULTI_DONE_INT|UDMAIN_DONE_INT|UDMAOUT_DONE_INT)) {
+                host_stat = ATA_DMA_INTR;
+        }
+        if (int_status & (MULTI_TERM_INT|UDMAIN_TERM_INT|UDMAOUT_TERM_INT)) {
+                host_stat = ATA_DMA_ERR;
+        }
+
+        return host_stat;
+}
+
+/**
+ *      bfin_data_xfer - Transfer data by PIO
+ *      @adev: device for this I/O
+ *      @buf: data buffer
+ *      @buflen: buffer length
+ *      @write_data: read/write
+ *
+ *      Note: Original code is ata_data_xfer().
+ */
+
+static void bfin_data_xfer(struct ata_device *adev, unsigned char *buf,
+                           unsigned int buflen, int write_data)
+{
+        struct ata_port *ap = adev->ap;
+        unsigned int words = buflen >> 1;
+        unsigned short *buf16 = (u16 *) buf;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* Transfer multiple of 2 bytes */
+        if (write_data) {
+                write_atapi_data(base, words, buf16);
+        } else {
+                read_atapi_data(base, words, buf16);
+        }
+
+        /* Transfer trailing 1 byte, if any. */
+        if (unlikely(buflen & 0x01)) {
+                unsigned short align_buf[1] = { 0 };
+                unsigned char *trailing_buf = buf + buflen - 1;
+
+                if (write_data) {
+                        memcpy(align_buf, trailing_buf, 1);
+                        write_atapi_data(base, 1, align_buf);
+                } else {
+                        read_atapi_data(base, 1, align_buf);
+                        memcpy(trailing_buf, align_buf, 1);
+                }
+        }
+}
+
+/**
+ *      bfin_irq_clear - Clear ATAPI interrupt.
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_irq_clear().
+ */
+
+static void bfin_irq_clear(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        pr_debug("in atapi irq clear\n");
+        ATAPI_SET_INT_STATUS(base, 0x1FF);
+}
+
+/**
+ *      bfin_irq_on - Enable interrupts on a port.
+ *      @ap: Port on which interrupts are enabled.
+ *
+ *      Note: Original code is ata_irq_on().
+ */
+
+static unsigned char bfin_irq_on(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 tmp;
+
+        pr_debug("in atapi irq on\n");
+        ap->ctl &= ~ATA_NIEN;
+        ap->last_ctl = ap->ctl;
+
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+        tmp = ata_wait_idle(ap);
+
+        bfin_irq_clear(ap);
+
+        return tmp;
+}
+
+/**
+ *      bfin_irq_ack - Acknowledge a device interrupt.
+ *      @ap: Port on which interrupts are enabled.
+ *
+ *      Note: Original code is ata_irq_ack().
+ */
+
+static unsigned char bfin_irq_ack(struct ata_port *ap, unsigned int chk_drq)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
+        unsigned char status;
+
+        pr_debug("in atapi irq ack\n");
+        status = ata_busy_wait(ap, bits, 1000);
+        if (status & bits)
+                if (ata_msg_err(ap))
+                        dev_err(ap->dev, "abnormal status 0x%X\n", status);
+
+        /* get controller status; clear intr, err bits */
+        ATAPI_SET_INT_STATUS(base, ATAPI_GET_INT_STATUS(base)|ATAPI_DEV_INT
+                | MULTI_DONE_INT | UDMAIN_DONE_INT | UDMAOUT_DONE_INT
+                | MULTI_TERM_INT | UDMAIN_TERM_INT | UDMAOUT_TERM_INT);
+
+        return bfin_bmdma_status(ap);
+}
+
+/**
+ *      bfin_bmdma_freeze - Freeze DMA controller port
+ *      @ap: port to freeze
+ *
+ *      Note: Original code is ata_bmdma_freeze().
+ */
+
+static void bfin_bmdma_freeze(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        pr_debug("in atapi dma freeze\n");
+        ap->ctl |= ATA_NIEN;
+        ap->last_ctl = ap->ctl;
+
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+
+        /* Under certain circumstances, some controllers raise IRQ on
+         * ATA_NIEN manipulation.  Also, many controllers fail to mask
+         * previously pending IRQ on ATA_NIEN assertion.  Clear it.
+         */
+        ata_chk_status(ap);
+
+        bfin_irq_clear(ap);
+}
+
+/**
+ *      bfin_bmdma_thaw - Thaw DMA controller port
+ *      @ap: port to thaw
+ *
+ *      Note: Original code is ata_bmdma_thaw().
+ */
+
+void bfin_bmdma_thaw(struct ata_port *ap)
+{
+        bfin_check_status(ap);
+        bfin_irq_clear(ap);
+        bfin_irq_on(ap);
+}
+
+/**
+ *      bfin_std_postreset - standard postreset callback
+ *      @ap: the target ata_port
+ *      @classes: classes of attached devices
+ *
+ *      Note: Original code is ata_std_postreset().
+ */
+
+static void bfin_std_postreset(struct ata_port *ap, unsigned int *classes)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* re-enable interrupts */
+        bfin_irq_on(ap);
+
+        /* is double-select really necessary? */
+        if (classes[0] != ATA_DEV_NONE)
+                bfin_std_dev_select(ap, 1);
+        if (classes[1] != ATA_DEV_NONE)
+                bfin_std_dev_select(ap, 0);
+
+        /* bail out if no device is present */
+        if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
+                return;
+        }
+
+        /* set up device control */
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+}
+
+/**
+ *      bfin_error_handler - Stock error handler for DMA controller
+ *      @ap: port to handle error for
+ */
+
+static void bfin_error_handler(struct ata_port *ap)
+{
+        ata_bmdma_drive_eh(ap, ata_std_prereset, bfin_std_softreset, NULL,
+                           bfin_std_postreset);
+}
+
+static void bfin_port_stop(struct ata_port *ap)
+{
+        pr_debug("in atapi port stop\n");
+        if (ap->udma_mask != 0 || ap->mwdma_mask != 0) {
+                free_dma(CH_ATAPI_RX);
+                free_dma(CH_ATAPI_TX);
+        }
+}
+
+static int bfin_port_start(struct ata_port *ap)
+{
+        pr_debug("in atapi port start\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return 0;
+
+        if (request_dma(CH_ATAPI_RX, "BFIN ATAPI RX DMA") >= 0) {
+                if (request_dma(CH_ATAPI_TX,
+                        "BFIN ATAPI TX DMA") >= 0)
+                        return 0;
+
+                free_dma(CH_ATAPI_RX);
+        }
+
+        ap->udma_mask = 0;
+        ap->mwdma_mask = 0;
+        dev_err(ap->dev, "Unable to request ATAPI DMA!"
+                " Continue in PIO mode.\n");
+
+        return 0;
+}
+
+static struct scsi_host_template bfin_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = SG_NONE,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+#ifdef CONFIG_PM
+        .resume                 = ata_scsi_device_resume,
+        .suspend                = ata_scsi_device_suspend,
+#endif
+};
+
+static const struct ata_port_operations bfin_pata_ops = {
+        .port_disable           = ata_port_disable,
+        .set_piomode            = bfin_set_piomode,
+        .set_dmamode            = bfin_set_dmamode,
+
+        .tf_load                = bfin_tf_load,
+        .tf_read                = bfin_tf_read,
+        .exec_command           = bfin_exec_command,
+        .check_status           = bfin_check_status,
+        .check_altstatus        = bfin_check_altstatus,
+        .dev_select             = bfin_std_dev_select,
+
+        .bmdma_setup            = bfin_bmdma_setup,
+        .bmdma_start            = bfin_bmdma_start,
+        .bmdma_stop             = bfin_bmdma_stop,
+        .bmdma_status           = bfin_bmdma_status,
+        .data_xfer              = bfin_data_xfer,
+
+        .qc_prep                = ata_noop_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .freeze                 = bfin_bmdma_freeze,
+        .thaw                   = bfin_bmdma_thaw,
+        .error_handler          = bfin_error_handler,
+        .post_internal_cmd      = bfin_bmdma_stop,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = bfin_irq_clear,
+        .irq_on                 = bfin_irq_on,
+        .irq_ack                = bfin_irq_ack,
+
+        .port_start             = bfin_port_start,
+        .port_stop              = bfin_port_stop,
+};
+
+static struct ata_port_info bfin_port_info[] = {
+        {
+                .sht            = &bfin_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS
+                                | ATA_FLAG_MMIO
+                                | ATA_FLAG_NO_LEGACY,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0,
+#ifdef CONFIG_PATA_BF54X_DMA
+                .udma_mask      = ATA_UDMA5,
+#else
+                .udma_mask      = 0,
+#endif
+                .port_ops       = &bfin_pata_ops,
+        },
+};
+
+/**
+ *      bfin_reset_controller - initialize BF54x ATAPI controller.
+ */
+
+static int bfin_reset_controller(struct ata_host *host)
+{
+        void __iomem *base = (void __iomem *)host->ports[0]->ioaddr.ctl_addr;
+        int count;
+        unsigned short status;
+
+        /* Disable all ATAPI interrupts */
+        ATAPI_SET_INT_MASK(base, 0);
+        SSYNC();
+
+        /* Assert the RESET signal 25us*/
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) | DEV_RST);
+        udelay(30);
+
+        /* Negate the RESET signal for 2ms*/
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) & ~DEV_RST);
+        msleep(2);
+
+        /* Wait on Busy flag to clear */
+        count = 10000000;
+        do {
+                status = read_atapi_register(base, ATA_REG_STATUS);
+        } while (count-- && (status & ATA_BUSY));
+
+        /* Enable only ATAPI Device interrupt */
+        ATAPI_SET_INT_MASK(base, 1);
+        SSYNC();
+
+        return (!count);
+}
+
+/**
+ *      atapi_io_port - define atapi peripheral port pins.
+ */
+static unsigned short atapi_io_port[] = {
+        P_ATAPI_RESET,
+        P_ATAPI_DIOR,
+        P_ATAPI_DIOW,
+        P_ATAPI_CS0,
+        P_ATAPI_CS1,
+        P_ATAPI_DMACK,
+        P_ATAPI_DMARQ,
+        P_ATAPI_INTRQ,
+        P_ATAPI_IORDY,
+        0
+};
+
+/**
+ *      bfin_atapi_probe        -       attach a bfin atapi interface
+ *      @pdev: platform device
+ *
+ *      Register a bfin atapi interface.
+ *
+ *
+ *      Platform devices are expected to contain 2 resources per port:
+ *
+ *              - I/O Base (IORESOURCE_IO)
+ *              - IRQ      (IORESOURCE_IRQ)
+ *
+ */
+static int __devinit bfin_atapi_probe(struct platform_device *pdev)
+{
+        int board_idx = 0;
+        struct resource *res;
+        struct ata_host *host;
+        const struct ata_port_info *ppi[] =
+                { &bfin_port_info[board_idx], NULL };
+
+        /*
+         * Simple resource validation ..
+         */
+        if (unlikely(pdev->num_resources != 2)) {
+                dev_err(&pdev->dev, "invalid number of resources\n");
+                return -EINVAL;
+        }
+
+        /*
+         * Get the register base first
+         */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL)
+                return -EINVAL;
+
+        /*
+         * Now that that's out of the way, wire up the port..
+         */
+        host = ata_host_alloc_pinfo(&pdev->dev, ppi, 1);
+        if (!host)
+                return -ENOMEM;
+
+        host->ports[0]->ioaddr.ctl_addr = (void *)res->start;
+
+        if (peripheral_request_list(atapi_io_port, "atapi-io-port")) {
+                dev_err(&pdev->dev, "Requesting Peripherals faild\n");
+                return -EFAULT;
+        }
+
+        if (bfin_reset_controller(host)) {
+                peripheral_free_list(atapi_io_port);
+                dev_err(&pdev->dev, "Fail to reset ATAPI device\n");
+                return -EFAULT;
+        }
+
+        if (ata_host_activate(host, platform_get_irq(pdev, 0),
+                ata_interrupt, IRQF_SHARED, &bfin_sht) != 0) {
+                peripheral_free_list(atapi_io_port);
+                dev_err(&pdev->dev, "Fail to attach ATAPI device\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+/**
+ *      bfin_atapi_remove       -       unplug a bfin atapi interface
+ *      @pdev: platform device
+ *
+ *      A bfin atapi device has been unplugged. Perform the needed
+ *      cleanup. Also called on module unload for any active devices.
+ */
+static int __devexit bfin_atapi_remove(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct ata_host *host = dev_get_drvdata(dev);
+
+        ata_host_detach(host);
+
+        peripheral_free_list(atapi_io_port);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+int bfin_atapi_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        return 0;
+}
+
+int bfin_atapi_resume(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+
+static struct platform_driver bfin_atapi_driver = {
+        .probe                  = bfin_atapi_probe,
+        .remove                 = __devexit_p(bfin_atapi_remove),
+        .driver = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+#ifdef CONFIG_PM
+                .suspend        = bfin_atapi_suspend,
+                .resume         = bfin_atapi_resume,
+#endif
+        },
+};
+
+static int __init bfin_atapi_init(void)
+{
+        pr_info("register bfin atapi driver\n");
+        return platform_driver_register(&bfin_atapi_driver);
+}
+
+static void __exit bfin_atapi_exit(void)
+{
+        platform_driver_unregister(&bfin_atapi_driver);
+}
+
+module_init(bfin_atapi_init);
+module_exit(bfin_atapi_exit);
+
+MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
+MODULE_DESCRIPTION("PATA driver for blackfin 54x ATAPI controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_cmd640.c b/drivers/ata/pata_cmd640.c
index 0feb5ae8c4..43d198f909 100644
--- a/drivers/ata/pata_cmd640.c
+++ b/drivers/ata/pata_cmd640.c
@@ -153,7 +153,7 @@ static int cmd640_port_start(struct ata_port *ap)
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         struct cmd640_reg *timing;
 
-        int ret = ata_port_start(ap);
+        int ret = ata_sff_port_start(ap);
         if (ret < 0)
                 return ret;
 
@@ -184,7 +184,6 @@ static struct scsi_host_template cmd640_sht = {
 };
 
 static struct ata_port_operations cmd640_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd640_set_piomode,
         .mode_filter    = ata_pci_default_filter,
         .tf_load        = ata_tf_load,
@@ -213,7 +212,6 @@ static struct ata_port_operations cmd640_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = cmd640_port_start,
 };
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index e34b632487..9e412c26b2 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -31,7 +31,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_cmd64x"
-#define DRV_VERSION "0.2.4"
+#define DRV_VERSION "0.2.5"
 
 /*
  * CMD64x specific registers definition.
@@ -88,14 +88,15 @@ static int cmd648_cable_detect(struct ata_port *ap)
 }
 
 /**
- *      cmd64x_set_piomode      -       set initial PIO mode data
+ *      cmd64x_set_piomode      -       set PIO and MWDMA timing
  *      @ap: ATA interface
  *      @adev: ATA device
+ *      @mode: mode
  *
- *      Called to do the PIO mode setup.
+ *      Called to do the PIO and MWDMA mode setup.
  */
 
-static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
+static void cmd64x_set_timing(struct ata_port *ap, struct ata_device *adev, u8 mode)
 {
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         struct ata_timing t;
@@ -117,8 +118,9 @@ static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
         int arttim = arttim_port[ap->port_no][adev->devno];
         int drwtim = drwtim_port[ap->port_no][adev->devno];
 
-
-        if (ata_timing_compute(adev, adev->pio_mode, &t, T, 0) < 0) {
+        /* ata_timing_compute is smart and will produce timings for MWDMA
+           that don't violate the drives PIO capabilities. */
+        if (ata_timing_compute(adev, mode, &t, T, 0) < 0) {
                 printk(KERN_ERR DRV_NAME ": mode computation failed.\n");
                 return;
         }
@@ -168,6 +170,20 @@ static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
 }
 
 /**
+ *      cmd64x_set_piomode      -       set initial PIO mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ *
+ *      Used when configuring the devices ot set the PIO timings. All the
+ *      actual work is done by the PIO/MWDMA setting helper
+ */
+
+static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        cmd64x_set_timing(ap, adev, adev->pio_mode);
+}
+
+/**
  *      cmd64x_set_dmamode      -       set initial DMA mode data
  *      @ap: ATA interface
  *      @adev: ATA device
@@ -180,9 +196,6 @@ static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
         static const u8 udma_data[] = {
                 0x30, 0x20, 0x10, 0x20, 0x10, 0x00
         };
-        static const u8 mwdma_data[] = {
-                0x30, 0x20, 0x10
-        };
 
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u8 regU, regD;
@@ -208,8 +221,10 @@ static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 regU |= 1 << adev->devno; /* UDMA on */
                 if (adev->dma_mode > 2) /* 15nS timing */
                         regU |= 4 << adev->devno;
-        } else
-                regD |= mwdma_data[adev->dma_mode - XFER_MW_DMA_0] << shift;
+        } else {
+                regU &= ~ (1 << adev->devno);   /* UDMA off */
+                cmd64x_set_timing(ap, adev, adev->dma_mode);
+        }
 
         regD |= 0x20 << adev->devno;
 
@@ -269,7 +284,6 @@ static struct scsi_host_template cmd64x_sht = {
 };
 
 static struct ata_port_operations cmd64x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -298,13 +312,11 @@ static struct ata_port_operations cmd64x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
 
 static struct ata_port_operations cmd646r1_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -333,13 +345,11 @@ static struct ata_port_operations cmd646r1_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
 
 static struct ata_port_operations cmd648_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -368,7 +378,6 @@ static struct ata_port_operations cmd648_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index e2459088cd..33f7f0843f 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -158,7 +158,6 @@ static struct scsi_host_template cs5520_sht = {
 };
 
 static struct ata_port_operations cs5520_port_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = cs5520_set_piomode,
         .set_dmamode            = cs5520_set_dmamode,
 
@@ -184,13 +183,14 @@ static struct ata_port_operations cs5520_port_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
+        static const unsigned int cmd_port[] = { 0x1F0, 0x170 };
+        static const unsigned int ctl_port[] = { 0x3F6, 0x376 };
         struct ata_port_info pi = {
                 .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = 0x1f,
@@ -244,10 +244,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         }
 
         /* Map IO ports and initialize host accordingly */
-        iomap[0] = devm_ioport_map(&pdev->dev, 0x1F0, 8);
-        iomap[1] = devm_ioport_map(&pdev->dev, 0x3F6, 1);
-        iomap[2] = devm_ioport_map(&pdev->dev, 0x170, 8);
-        iomap[3] = devm_ioport_map(&pdev->dev, 0x376, 1);
+        iomap[0] = devm_ioport_map(&pdev->dev, cmd_port[0], 8);
+        iomap[1] = devm_ioport_map(&pdev->dev, ctl_port[0], 1);
+        iomap[2] = devm_ioport_map(&pdev->dev, cmd_port[1], 8);
+        iomap[3] = devm_ioport_map(&pdev->dev, ctl_port[1], 1);
         iomap[4] = pcim_iomap(pdev, 2, 0);
 
         if (!iomap[0] || !iomap[1] || !iomap[2] || !iomap[3] || !iomap[4])
@@ -260,6 +260,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         ioaddr->bmdma_addr = iomap[4];
         ata_std_ports(ioaddr);
 
+        ata_port_desc(host->ports[0],
+                      "cmd 0x%x ctl 0x%x", cmd_port[0], ctl_port[0]);
+        ata_port_pbar_desc(host->ports[0], 4, 0, "bmdma");
+
         ioaddr = &host->ports[1]->ioaddr;
         ioaddr->cmd_addr = iomap[2];
         ioaddr->ctl_addr = iomap[3];
@@ -267,6 +271,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         ioaddr->bmdma_addr = iomap[4] + 8;
         ata_std_ports(ioaddr);
 
+        ata_port_desc(host->ports[1],
+                      "cmd 0x%x ctl 0x%x", cmd_port[1], ctl_port[1]);
+        ata_port_pbar_desc(host->ports[1], 4, 8, "bmdma");
+
         /* activate the host */
         pci_set_master(pdev);
         rc = ata_host_start(host);
@@ -285,33 +293,12 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
                 if (rc)
                         return rc;
 
-                if (i == 0)
-                        host->irq = irq[0];
-                else
-                        host->irq2 = irq[1];
+                ata_port_desc(ap, "irq %d", irq[i]);
         }
 
         return ata_host_register(host, &cs5520_sht);
 }
 
-/**
- *      cs5520_remove_one       -       device unload
- *      @pdev: PCI device being removed
- *
- *      Handle an unplug/unload event for a PCI device. Unload the
- *      PCI driver but do not use the default handler as we manage
- *      resources ourself and *MUST NOT* disable the device as it has
- *      other functions.
- */
-
-static void __devexit cs5520_remove_one(struct pci_dev *pdev)
-{
-        struct device *dev = pci_dev_to_dev(pdev);
-        struct ata_host *host = dev_get_drvdata(dev);
-
-        ata_host_detach(host);
-}
-
 #ifdef CONFIG_PM
 /**
  *      cs5520_reinit_one       -       device resume
@@ -368,7 +355,7 @@ static struct pci_driver cs5520_pci_driver = {
         .name           = DRV_NAME,
         .id_table       = pata_cs5520,
         .probe          = cs5520_init_one,
-        .remove         = cs5520_remove_one,
+        .remove         = ata_pci_remove_one,
 #ifdef CONFIG_PM
         .suspend        = cs5520_pci_device_suspend,
         .resume         = cs5520_reinit_one,
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index eaaea848b6..57e827e410 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -179,7 +179,6 @@ static struct scsi_host_template cs5530_sht = {
 };
 
 static struct ata_port_operations cs5530_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cs5530_set_piomode,
         .set_dmamode    = cs5530_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -209,9 +208,8 @@ static struct ata_port_operations cs5530_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static const struct dmi_system_id palmax_dmi_table[] = {
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index 360b6f32e1..3578593a88 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -176,7 +176,6 @@ static struct scsi_host_template cs5535_sht = {
 };
 
 static struct ata_port_operations cs5535_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cs5535_set_piomode,
         .set_dmamode    = cs5535_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -206,9 +205,8 @@ static struct ata_port_operations cs5535_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_cypress.c b/drivers/ata/pata_cypress.c
index 6cbc8778bf..fc5f9c4e5d 100644
--- a/drivers/ata/pata_cypress.c
+++ b/drivers/ata/pata_cypress.c
@@ -128,7 +128,6 @@ static struct scsi_host_template cy82c693_sht = {
 };
 
 static struct ata_port_operations cy82c693_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cy82c693_set_piomode,
         .set_dmamode    = cy82c693_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -158,9 +157,8 @@ static struct ata_port_operations cy82c693_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index c8ba59c561..043dcd3510 100644
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -26,25 +26,26 @@
 
 /**
  *      efar_pre_reset  -       Enable bits
- *      @ap: Port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform cable detection for the EFAR ATA interface. This is
  *      different to the PIIX arrangement
  */
 
-static int efar_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int efar_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits efar_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
                 { 0x43U, 1U, 0x80UL, 0x80UL },  /* port 1 */
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &efar_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -250,7 +251,6 @@ static struct scsi_host_template efar_sht = {
 };
 
 static const struct ata_port_operations efar_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = efar_set_piomode,
         .set_dmamode            = efar_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -278,9 +278,8 @@ static const struct ata_port_operations efar_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 6f7d34ad19..0713872cf6 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -312,7 +312,6 @@ static struct scsi_host_template hpt36x_sht = {
  */
 
 static struct ata_port_operations hpt366_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt366_set_piomode,
         .set_dmamode    = hpt366_set_dmamode,
         .mode_filter    = hpt366_filter,
@@ -342,9 +341,8 @@ static struct ata_port_operations hpt366_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index c5ddd937db..e61cb1fd57 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -304,15 +304,16 @@ static unsigned long hpt370a_filter(struct ata_device *adev, unsigned long mask)
 
 /**
  *      hpt37x_pre_reset        -       reset the hpt37x bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the initial reset handling for the 370/372 and 374 func 0
  */
 
-static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt37x_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         u8 scr2, ata66;
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits hpt37x_enable_bits[] = {
                 { 0x50, 1, 0x04, 0x04 },
@@ -337,7 +338,7 @@ static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -352,7 +353,7 @@ static void hpt37x_error_handler(struct ata_port *ap)
         ata_bmdma_drive_eh(ap, hpt37x_pre_reset, ata_std_softreset, NULL, ata_std_postreset);
 }
 
-static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt374_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits hpt37x_enable_bits[] = {
                 { 0x50, 1, 0x04, 0x04 },
@@ -360,6 +361,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
         };
         u16 mcr3, mcr6;
         u8 ata66;
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
@@ -387,7 +389,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -642,7 +644,6 @@ static struct scsi_host_template hpt37x_sht = {
  */
 
 static struct ata_port_operations hpt370_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt370_set_piomode,
         .set_dmamode    = hpt370_set_dmamode,
         .mode_filter    = hpt370_filter,
@@ -671,9 +672,8 @@ static struct ata_port_operations hpt370_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -681,7 +681,6 @@ static struct ata_port_operations hpt370_port_ops = {
  */
 
 static struct ata_port_operations hpt370a_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt370_set_piomode,
         .set_dmamode    = hpt370_set_dmamode,
         .mode_filter    = hpt370a_filter,
@@ -710,9 +709,8 @@ static struct ata_port_operations hpt370a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -721,7 +719,6 @@ static struct ata_port_operations hpt370a_port_ops = {
  */
 
 static struct ata_port_operations hpt372_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt372_set_piomode,
         .set_dmamode    = hpt372_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -750,9 +747,8 @@ static struct ata_port_operations hpt372_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -761,7 +757,6 @@ static struct ata_port_operations hpt372_port_ops = {
  */
 
 static struct ata_port_operations hpt374_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt372_set_piomode,
         .set_dmamode    = hpt372_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -790,9 +785,8 @@ static struct ata_port_operations hpt374_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index f8f234bfc8..9f1c084f84 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -141,21 +141,22 @@ static int hpt3x2n_cable_detect(struct ata_port *ap)
 
 /**
  *      hpt3x2n_pre_reset       -       reset the hpt3x2n bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the initial reset handling for the 3x2n series controllers.
  *      Reset the hardware and state machine,
  */
 
-static int hpt3xn_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt3xn_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         /* Reset the state machine */
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -360,7 +361,6 @@ static struct scsi_host_template hpt3x2n_sht = {
  */
 
 static struct ata_port_operations hpt3x2n_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt3x2n_set_piomode,
         .set_dmamode    = hpt3x2n_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -390,9 +390,8 @@ static struct ata_port_operations hpt3x2n_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index be0f05efac..cb8bdb6887 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -120,7 +120,6 @@ static struct scsi_host_template hpt3x3_sht = {
 };
 
 static struct ata_port_operations hpt3x3_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt3x3_set_piomode,
 #if defined(CONFIG_PATA_HPT3X3_DMA)
         .set_dmamode    = hpt3x3_set_dmamode,
@@ -153,9 +152,8 @@ static struct ata_port_operations hpt3x3_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -239,7 +237,8 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         base = host->iomap[4];  /* Bus mastering base */
 
         for (i = 0; i < host->n_ports; i++) {
-                struct ata_ioports *ioaddr = &host->ports[i]->ioaddr;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *ioaddr = &ap->ioaddr;
 
                 ioaddr->cmd_addr = base + offset_cmd[i];
                 ioaddr->altstatus_addr =
@@ -247,6 +246,9 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 ioaddr->scr_addr = NULL;
                 ata_std_ports(ioaddr);
                 ioaddr->bmdma_addr = base + 8 * i;
+
+                ata_port_pbar_desc(ap, 4, -1, "ioport");
+                ata_port_pbar_desc(ap, 4, offset_cmd[i], "cmd");
         }
         pci_set_master(pdev);
         return ata_host_activate(host, pdev->irq, ata_interrupt, IRQF_SHARED,
diff --git a/drivers/ata/pata_icside.c b/drivers/ata/pata_icside.c
index 64a711776c..be30923566 100644
--- a/drivers/ata/pata_icside.c
+++ b/drivers/ata/pata_icside.c
@@ -70,6 +70,8 @@ struct pata_icside_info {
         unsigned int            mwdma_mask;
         unsigned int            nr_ports;
         const struct portinfo   *port[2];
+        unsigned long           raw_base;
+        unsigned long           raw_ioc_base;
 };
 
 #define ICS_TYPE_A3IN   0
@@ -357,26 +359,7 @@ static void pata_icside_error_handler(struct ata_port *ap)
                            pata_icside_postreset);
 }
 
-static u8 pata_icside_irq_ack(struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: drv_stat 0x%X\n",
-                        __FUNCTION__, status);
-
-        return status;
-}
-
 static struct ata_port_operations pata_icside_port_ops = {
-        .port_disable           = ata_port_disable,
-
         .set_dmamode            = pata_icside_set_dmamode,
 
         .tf_load                = ata_tf_load,
@@ -403,7 +386,6 @@ static struct ata_port_operations pata_icside_port_ops = {
 
         .irq_clear              = ata_dummy_noret,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = pata_icside_irq_ack,
 
         .port_start             = pata_icside_port_start,
 
@@ -412,9 +394,10 @@ static struct ata_port_operations pata_icside_port_ops = {
 };
 
 static void __devinit
-pata_icside_setup_ioaddr(struct ata_ioports *ioaddr, void __iomem *base,
+pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base,
                          const struct portinfo *info)
 {
+        struct ata_ioports *ioaddr = &ap->ioaddr;
         void __iomem *cmd = base + info->dataoffset;
 
         ioaddr->cmd_addr        = cmd;
@@ -431,6 +414,13 @@ pata_icside_setup_ioaddr(struct ata_ioports *ioaddr, void __iomem *base,
 
         ioaddr->ctl_addr        = base + info->ctrloffset;
         ioaddr->altstatus_addr  = ioaddr->ctl_addr;
+
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx",
+                      info->raw_base + info->dataoffset,
+                      info->raw_base + info->ctrloffset);
+
+        if (info->raw_ioc_base)
+                ata_port_desc(ap, "iocbase 0x%lx", info->raw_ioc_base);
 }
 
 static int __devinit pata_icside_register_v5(struct pata_icside_info *info)
@@ -451,6 +441,8 @@ static int __devinit pata_icside_register_v5(struct pata_icside_info *info)
         info->nr_ports = 1;
         info->port[0] = &pata_icside_portinfo_v5;
 
+        info->raw_base = ecard_resource_start(ec, ECARD_RES_MEMC);
+
         return 0;
 }
 
@@ -491,6 +483,9 @@ static int __devinit pata_icside_register_v6(struct pata_icside_info *info)
         info->port[0] = &pata_icside_portinfo_v6_1;
         info->port[1] = &pata_icside_portinfo_v6_2;
 
+        info->raw_base = ecard_resource_start(ec, ECARD_RES_EASI);
+        info->raw_ioc_base = ecard_resource_start(ec, ECARD_RES_IOCFAST);
+
         return icside_dma_init(info);
 }
 
@@ -527,7 +522,7 @@ static int __devinit pata_icside_add_ports(struct pata_icside_info *info)
                 ap->flags |= ATA_FLAG_SLAVE_POSS;
                 ap->ops = &pata_icside_port_ops;
 
-                pata_icside_setup_ioaddr(&ap->ioaddr, info->base, info->port[i]);
+                pata_icside_setup_ioaddr(ap, info->base, info->port[i]);
         }
 
         return ata_host_activate(host, ec->irq, ata_interrupt, 0,
diff --git a/drivers/ata/pata_isapnp.c b/drivers/ata/pata_isapnp.c
index 9e553c5420..88ab0e1d35 100644
--- a/drivers/ata/pata_isapnp.c
+++ b/drivers/ata/pata_isapnp.c
@@ -38,7 +38,6 @@ static struct scsi_host_template isapnp_sht = {
 };
 
 static struct ata_port_operations isapnp_port_ops = {
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -58,9 +57,8 @@ static struct ata_port_operations isapnp_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -112,6 +110,10 @@ static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev
 
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                      (unsigned long long)pnp_port_start(idev, 0),
+                      (unsigned long long)pnp_port_start(idev, 1));
+
         /* activate */
         return ata_host_activate(host, pnp_irq(idev, 0), ata_interrupt, 0,
                                  &isapnp_sht);
diff --git a/drivers/ata/pata_it8213.c b/drivers/ata/pata_it8213.c
index b8af55e891..1eda821e5e 100644
--- a/drivers/ata/pata_it8213.c
+++ b/drivers/ata/pata_it8213.c
@@ -23,23 +23,24 @@
 
 /**
  *      it8213_pre_reset        -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      Filter out ports by the enable bits before doing the normal reset
  *      and probe.
  */
 
-static int it8213_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int it8213_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits it8213_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         if (!pci_test_config_bits(pdev, &it8213_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -260,7 +261,6 @@ static struct scsi_host_template it8213_sht = {
 };
 
 static const struct ata_port_operations it8213_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = it8213_set_piomode,
         .set_dmamode            = it8213_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -288,9 +288,8 @@ static const struct ata_port_operations it8213_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index 5d8b91e70e..988ef736b9 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -391,7 +391,7 @@ static void it821x_passthru_dev_select(struct ata_port *ap,
 {
         struct it821x_dev *itdev = ap->private_data;
         if (itdev && device != itdev->last_device) {
-                struct ata_device *adev = &ap->device[device];
+                struct ata_device *adev = &ap->link.device[device];
                 it821x_program(ap, adev, itdev->pio[adev->devno]);
                 itdev->last_device = device;
         }
@@ -450,7 +450,7 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
 
 /**
  *      it821x_smart_set_mode   -       mode setting
- *      @ap: interface to set up
+ *      @link: interface to set up
  *      @unused: device that failed (error only)
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -459,12 +459,11 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
  *      and respect them.
  */
 
-static int it821x_smart_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int it821x_smart_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
@@ -564,7 +563,7 @@ static int it821x_port_start(struct ata_port *ap)
         struct it821x_dev *itdev;
         u8 conf;
 
-        int ret = ata_port_start(ap);
+        int ret = ata_sff_port_start(ap);
         if (ret < 0)
                 return ret;
 
@@ -621,7 +620,6 @@ static struct scsi_host_template it821x_sht = {
 
 static struct ata_port_operations it821x_smart_port_ops = {
         .set_mode       = it821x_smart_set_mode,
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .mode_filter    = ata_pci_default_filter,
@@ -651,13 +649,11 @@ static struct ata_port_operations it821x_smart_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = it821x_port_start,
 };
 
 static struct ata_port_operations it821x_passthru_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = it821x_passthru_set_piomode,
         .set_dmamode    = it821x_passthru_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -688,7 +684,6 @@ static struct ata_port_operations it821x_passthru_port_ops = {
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_handler    = ata_interrupt,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = it821x_port_start,
 };
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index 5dea3584c6..fcd532afbf 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -26,12 +26,11 @@
 #define DRV_NAME        "pata_ixp4xx_cf"
 #define DRV_VERSION     "0.2"
 
-static int ixp4xx_set_mode(struct ata_port *ap, struct ata_device **error)
+static int ixp4xx_set_mode(struct ata_link *link, struct ata_device **error)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         ata_dev_printk(dev, KERN_INFO, "configured for PIO0\n");
                         dev->pio_mode = XFER_PIO_0;
@@ -49,7 +48,7 @@ static void ixp4xx_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
         unsigned int i;
         unsigned int words = buflen >> 1;
         u16 *buf16 = (u16 *) buf;
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         void __iomem *mmio = ap->ioaddr.data_addr;
         struct ixp4xx_pata_data *data = ap->host->dev->platform_data;
 
@@ -108,7 +107,6 @@ static struct ata_port_operations ixp4xx_port_ops = {
         .set_mode               = ixp4xx_set_mode,
         .mode_filter            = ata_pci_default_filter,
 
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -128,14 +126,17 @@ static struct ata_port_operations ixp4xx_port_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
-                                struct ixp4xx_pata_data *data)
+                              struct ixp4xx_pata_data *data,
+                              unsigned long raw_cs0, unsigned long raw_cs1)
 {
+        unsigned long raw_cmd = raw_cs0;
+        unsigned long raw_ctl = raw_cs1 + 0x06;
+
         ioaddr->cmd_addr        = data->cs0;
         ioaddr->altstatus_addr  = data->cs1 + 0x06;
         ioaddr->ctl_addr        = data->cs1 + 0x06;
@@ -161,7 +162,12 @@ static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
         *(unsigned long *)&ioaddr->device_addr          ^= 0x03;
         *(unsigned long *)&ioaddr->status_addr          ^= 0x03;
         *(unsigned long *)&ioaddr->command_addr         ^= 0x03;
+
+        raw_cmd ^= 0x03;
+        raw_ctl ^= 0x03;
 #endif
+
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl);
 }
 
 static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
@@ -206,7 +212,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
         ap->pio_mask = 0x1f; /* PIO4 */
         ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_NO_ATAPI;
 
-        ixp4xx_setup_port(&ap->ioaddr, data);
+        ixp4xx_setup_port(ap, data, cs0->start, cs1->start);
 
         dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
 
diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index 4d67f238ee..225a7223a7 100644
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -29,7 +29,7 @@ typedef enum {
 
 /**
  *      jmicron_pre_reset       -       check for 40/80 pin
- *      @ap: Port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the PATA port setup we need.
@@ -39,9 +39,9 @@ typedef enum {
  *      and setup here. We assume that has been done by init_one and the
  *      BIOS.
  */
-
-static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int jmicron_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u32 control;
         u32 control5;
@@ -103,7 +103,7 @@ static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
                 ap->cbl = ATA_CBL_SATA;
                 break;
         }
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -141,8 +141,6 @@ static struct scsi_host_template jmicron_sht = {
 };
 
 static const struct ata_port_operations jmicron_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -168,7 +166,6 @@ static const struct ata_port_operations jmicron_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
         .port_start             = ata_port_start,
@@ -207,17 +204,8 @@ static int jmicron_init_one (struct pci_dev *pdev, const struct pci_device_id *i
 }
 
 static const struct pci_device_id jmicron_pci_tbl[] = {
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 361 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 363 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 365 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 366 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 368 },
-
+        { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
+          PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 0 },
         { }     /* terminate list */
 };
 
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index edffc25d2d..7bed8d8063 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -96,7 +96,7 @@ static int iordy_mask = 0xFFFFFFFF;	/* Use iordy if available */
 
 /**
  *      legacy_set_mode         -       mode setting
- *      @ap: IDE interface
+ *      @link: IDE link
  *      @unused: Device that failed when error is returned
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -107,12 +107,11 @@ static int iordy_mask = 0xFFFFFFFF;	/* Use iordy if available */
  *      expand on this as per hdparm in the base kernel.
  */
 
-static int legacy_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int legacy_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                         dev->pio_mode = XFER_PIO_0;
@@ -151,7 +150,6 @@ static struct scsi_host_template legacy_sht = {
  */
 
 static struct ata_port_operations simple_port_ops = {
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -172,7 +170,6 @@ static struct ata_port_operations simple_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -180,7 +177,6 @@ static struct ata_port_operations simple_port_ops = {
 static struct ata_port_operations legacy_port_ops = {
         .set_mode       = legacy_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -201,7 +197,6 @@ static struct ata_port_operations legacy_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -256,7 +251,7 @@ static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
 
 static void pdc_data_xfer_vlb(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
         unsigned long flags;
 
@@ -296,7 +291,6 @@ static void pdc_data_xfer_vlb(struct ata_device *adev, unsigned char *buf, unsig
 static struct ata_port_operations pdc20230_port_ops = {
         .set_piomode    = pdc20230_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -317,7 +311,6 @@ static struct ata_port_operations pdc20230_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -352,7 +345,6 @@ static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static struct ata_port_operations ht6560a_port_ops = {
         .set_piomode    = ht6560a_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -373,7 +365,6 @@ static struct ata_port_operations ht6560a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -419,7 +410,6 @@ static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static struct ata_port_operations ht6560b_port_ops = {
         .set_piomode    = ht6560b_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -440,7 +430,6 @@ static struct ata_port_operations ht6560b_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -541,7 +530,6 @@ static void opti82c611a_set_piomode(struct ata_port *ap, struct ata_device *adev
 static struct ata_port_operations opti82c611a_port_ops = {
         .set_piomode    = opti82c611a_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -562,7 +550,6 @@ static struct ata_port_operations opti82c611a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -675,7 +662,6 @@ static unsigned int opti82c46x_qc_issue_prot(struct ata_queued_cmd *qc)
 static struct ata_port_operations opti82c46x_port_ops = {
         .set_piomode    = opti82c46x_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -696,7 +682,6 @@ static struct ata_port_operations opti82c46x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -814,6 +799,8 @@ static __init int legacy_init_one(int port, unsigned long io, unsigned long ctrl
         ata_std_ports(&ap->ioaddr);
         ap->private_data = ld;
 
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io, ctrl);
+
         ret = ata_host_activate(host, irq, ata_interrupt, 0, &legacy_sht);
         if (ret)
                 goto fail;
diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index b45506f1ef..9afc8a32b2 100644
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -24,14 +24,15 @@
 
 /**
  *      marvell_pre_reset       -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the PATA port setup we need.
  */
 
-static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int marvell_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u32 devices;
         void __iomem *barp;
@@ -54,7 +55,7 @@ static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
             (!(devices & 0x10)))        /* PATA enable ? */
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static int marvell_cable_detect(struct ata_port *ap)
@@ -110,8 +111,6 @@ static struct scsi_host_template marvell_sht = {
 };
 
 static const struct ata_port_operations marvell_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -138,10 +137,9 @@ static const struct ata_port_operations marvell_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index 099f4cdc4c..412140f028 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -283,7 +283,6 @@ static struct scsi_host_template mpc52xx_ata_sht = {
 };
 
 static struct ata_port_operations mpc52xx_ata_port_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = mpc52xx_ata_set_piomode,
         .dev_select             = mpc52xx_ata_dev_select,
         .tf_load                = ata_tf_load,
@@ -299,12 +298,12 @@ static struct ata_port_operations mpc52xx_ata_port_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = ata_port_start,
 };
 
 static int __devinit
-mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv)
+mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv,
+                     unsigned long raw_ata_regs)
 {
         struct ata_host *host;
         struct ata_port *ap;
@@ -338,6 +337,8 @@ mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv)
         aio->status_addr        = &priv->ata_regs->tf_command;
         aio->command_addr       = &priv->ata_regs->tf_command;
 
+        ata_port_desc(ap, "ata_regs 0x%lx", raw_ata_regs);
+
         /* activate host */
         return ata_host_activate(host, priv->ata_irq, ata_interrupt, 0,
                                  &mpc52xx_ata_sht);
@@ -434,7 +435,7 @@ mpc52xx_ata_probe(struct of_device *op, const struct of_device_id *match)
         }
 
         /* Register ourselves to libata */
-        rv = mpc52xx_ata_init_one(&op->dev, priv);
+        rv = mpc52xx_ata_init_one(&op->dev, priv, res_mem.start);
         if (rv) {
                 printk(KERN_ERR DRV_NAME ": "
                         "Error while registering to ATA layer\n");
diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index 4ea4283829..d5483087a3 100644
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -46,15 +46,16 @@ enum {
         SECONDARY = (1 << 14)
 };
 
-static int mpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int mpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits mpiix_enable_bits = { 0x6D, 1, 0x80, 0x80 };
 
         if (!pci_test_config_bits(pdev, &mpiix_enable_bits))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -168,7 +169,6 @@ static struct scsi_host_template mpiix_sht = {
 };
 
 static struct ata_port_operations mpiix_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = mpiix_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -189,9 +189,8 @@ static struct ata_port_operations mpiix_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
@@ -202,7 +201,7 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         struct ata_port *ap;
         void __iomem *cmd_addr, *ctl_addr;
         u16 idetim;
-        int irq;
+        int cmd, ctl, irq;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
@@ -210,6 +209,7 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         host = ata_host_alloc(&dev->dev, 1);
         if (!host)
                 return -ENOMEM;
+        ap = host->ports[0];
 
         /* MPIIX has many functions which can be turned on or off according
            to other devices present. Make sure IDE is enabled before we try
@@ -221,25 +221,28 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 
         /* See if it's primary or secondary channel... */
         if (!(idetim & SECONDARY)) {
+                cmd = 0x1F0;
+                ctl = 0x3F6;
                 irq = 14;
-                cmd_addr = devm_ioport_map(&dev->dev, 0x1F0, 8);
-                ctl_addr = devm_ioport_map(&dev->dev, 0x3F6, 1);
         } else {
+                cmd = 0x170;
+                ctl = 0x376;
                 irq = 15;
-                cmd_addr = devm_ioport_map(&dev->dev, 0x170, 8);
-                ctl_addr = devm_ioport_map(&dev->dev, 0x376, 1);
         }
 
+        cmd_addr = devm_ioport_map(&dev->dev, cmd, 8);
+        ctl_addr = devm_ioport_map(&dev->dev, ctl, 1);
         if (!cmd_addr || !ctl_addr)
                 return -ENOMEM;
 
+        ata_port_desc(ap, "cmd 0x%x ctl 0x%x", cmd, ctl);
+
         /* We do our own plumbing to avoid leaking special cases for whacko
            ancient hardware into the core code. There are two issues to
            worry about.  #1 The chip is a bridge so if in legacy mode and
            without BARs set fools the setup.  #2 If you pci_disable_device
            the MPIIX your box goes castors up */
 
-        ap = host->ports[0];
         ap->ops = &mpiix_port_ops;
         ap->pio_mask = 0x1F;
         ap->flags |= ATA_FLAG_SLAVE_POSS;
diff --git a/drivers/ata/pata_netcell.c b/drivers/ata/pata_netcell.c
index 40eb574828..25c922abd5 100644
--- a/drivers/ata/pata_netcell.c
+++ b/drivers/ata/pata_netcell.c
@@ -40,8 +40,6 @@ static struct scsi_host_template netcell_sht = {
 };
 
 static const struct ata_port_operations netcell_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -68,10 +66,9 @@ static const struct ata_port_operations netcell_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_ns87410.c b/drivers/ata/pata_ns87410.c
index 2f5d714ebf..6e8e55745b 100644
--- a/drivers/ata/pata_ns87410.c
+++ b/drivers/ata/pata_ns87410.c
@@ -32,14 +32,15 @@
 
 /**
  *      ns87410_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Check enabled ports
  */
 
-static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int ns87410_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits ns87410_enable_bits[] = {
                 { 0x43, 1, 0x08, 0x08 },
@@ -49,7 +50,7 @@ static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &ns87410_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -161,7 +162,6 @@ static struct scsi_host_template ns87410_sht = {
 };
 
 static struct ata_port_operations ns87410_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ns87410_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -184,9 +184,8 @@ static struct ata_port_operations ns87410_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int ns87410_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_ns87415.c b/drivers/ata/pata_ns87415.c
new file mode 100644
index 0000000000..bb97ef583f
--- /dev/null
+++ b/drivers/ata/pata_ns87415.c
@@ -0,0 +1,467 @@
+/*
+ *    pata_ns87415.c - NS87415 (non PARISC) PATA
+ *
+ *      (C) 2005 Red Hat <alan@redhat.com>
+ *
+ *    This is a fairly generic MWDMA controller. It has some limitations
+ *    as it requires timing reloads on PIO/DMA transitions but it is otherwise
+ *    fairly well designed.
+ *
+ *    This driver assumes the firmware has left the chip in a valid ST506
+ *    compliant state, either legacy IRQ 14/15 or native INTA shared. You
+ *    may need to add platform code if your system fails to do this.
+ *
+ *    The same cell appears in the 87560 controller used by some PARISC
+ *    systems. This has its own special mountain of errata.
+ *
+ *    TODO:
+ *      Test PARISC SuperIO
+ *      Get someone to test on SPARC
+ *      Implement lazy pio/dma switching for better performance 
+ *      8bit shared timing.
+ *      See if we need to kill the FIFO for ATAPI
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/ata.h>
+
+#define DRV_NAME        "pata_ns87415"
+#define DRV_VERSION     "0.0.1"
+
+/**
+ *      ns87415_set_mode - Initialize host controller mode timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: Device whose timings we are configuring
+ *      @mode: Mode to set
+ *
+ *      Program the mode registers for this controller, channel and
+ *      device. Because the chip is quite an old design we have to do this
+ *      for PIO/DMA switches.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void ns87415_set_mode(struct ata_port *ap, struct ata_device *adev, u8 mode)
+{
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        int unit                = 2 * ap->port_no + adev->devno;
+        int timing              = 0x44 + 2 * unit;
+        unsigned long T         = 1000000000 / 33333;   /* PCI clocks */
+        struct ata_timing t;
+        u16 clocking;
+        u8 iordy;
+        u8 status;
+        
+        /* Timing register format is 17 - low nybble read timing with
+           the high nybble being 16 - x for recovery time in PCI clocks */
+   
+        ata_timing_compute(adev, adev->pio_mode, &t, T, 0);
+
+        clocking = 17 - FIT(t.active, 2, 17);
+        clocking |= (16 - FIT(t.recover, 1, 16)) << 4;
+        /* Use the same timing for read and write bytes */
+        clocking |= (clocking << 8);
+        pci_write_config_word(dev, timing, clocking);
+        
+        /* Set the IORDY enable versus DMA enable on or off properly */
+        pci_read_config_byte(dev, 0x42, &iordy);
+        iordy &= ~(1 << (4 + unit));
+        if (mode >= XFER_MW_DMA_0 || !ata_pio_need_iordy(adev))
+                iordy |= (1 << (4 + unit));
+
+        /* Paranoia: We shouldn't ever get here with busy write buffers
+           but if so wait */
+
+        pci_read_config_byte(dev, 0x43, &status);
+        while (status & 0x03) {
+                udelay(1);
+                pci_read_config_byte(dev, 0x43, &status);
+        }
+        /* Flip the IORDY/DMA bits now we are sure the write buffers are
+           clear */
+        pci_write_config_byte(dev, 0x42, iordy);
+
+        /* TODO: Set byte 54 command timing to the best 8bit
+           mode shared by all four devices */
+}
+
+/**
+ *      ns87415_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: Device to program
+ *
+ *      Set PIO mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void ns87415_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        ns87415_set_mode(ap, adev, adev->pio_mode);
+}
+
+/**
+ *      ns87415_bmdma_setup             -       Set up DMA
+ *      @qc: Command block
+ *
+ *      Set up for bus masterng DMA. We have to do this ourselves
+ *      rather than use the helper due to a chip erratum
+ */
+
+static void ns87415_bmdma_setup(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
+        u8 dmactl;
+
+        /* load PRD table addr. */
+        mb();   /* make sure PRD table writes are visible to controller */
+        iowrite32(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
+
+        /* specify data direction, triple-check start bit is clear */
+        dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+        dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
+        /* Due to an erratum we need to write these bits to the wrong
+           place - which does save us an I/O bizarrely */
+        dmactl |= ATA_DMA_INTR | ATA_DMA_ERR;
+        if (!rw)
+                dmactl |= ATA_DMA_WR;
+        iowrite8(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+        /* issue r/w command */
+        ap->ops->exec_command(ap, &qc->tf);
+}
+
+/**
+ *      ns87415_bmdma_start             -       Begin DMA transfer
+ *      @qc: Command block
+ *
+ *      Switch the timings for the chip and set up for a DMA transfer
+ *      before the DMA burst begins.
+ *
+ *      FIXME: We should do lazy switching on bmdma_start versus
+ *      ata_pio_data_xfer for better performance.
+ */
+
+static void ns87415_bmdma_start(struct ata_queued_cmd *qc)
+{
+        ns87415_set_mode(qc->ap, qc->dev, qc->dev->dma_mode);
+        ata_bmdma_start(qc);
+}
+
+/**
+ *      ns87415_bmdma_stop              -       End DMA transfer
+ *      @qc: Command block
+ *
+ *      End DMA mode and switch the controller back into PIO mode
+ */
+
+static void ns87415_bmdma_stop(struct ata_queued_cmd *qc)
+{
+        ata_bmdma_stop(qc);
+        ns87415_set_mode(qc->ap, qc->dev, qc->dev->pio_mode);
+}
+
+/**
+ *      ns87415_bmdma_irq_clear         -       Clear interrupt
+ *      @ap: Channel to clear
+ *
+ *      Erratum: Due to a chip bug regisers 02 and 0A bit 1 and 2 (the
+ *      error bits) are reset by writing to register 00 or 08.
+ */
+
+static void ns87415_bmdma_irq_clear(struct ata_port *ap)
+{
+        void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+        if (!mmio)
+                return;
+        iowrite8((ioread8(mmio + ATA_DMA_CMD) | ATA_DMA_INTR | ATA_DMA_ERR), 
+                        mmio + ATA_DMA_CMD);
+}
+
+/**
+ *      ns87415_check_atapi_dma         -       ATAPI DMA filter
+ *      @qc: Command block
+ *
+ *      Disable ATAPI DMA (for now). We may be able to do DMA if we
+ *      kill the prefetching. This isn't clear.
+ */
+
+static int ns87415_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        return -EOPNOTSUPP;
+}
+
+#if defined(CONFIG_SUPERIO)
+
+/* SUPERIO 87560 is a PoS chip that NatSem denies exists.
+ * Unfortunately, it's built-in on all Astro-based PA-RISC workstations
+ * which use the integrated NS87514 cell for CD-ROM support.
+ * i.e we have to support for CD-ROM installs.
+ * See drivers/parisc/superio.c for more gory details.
+ *
+ * Workarounds taken from drivers/ide/pci/ns87415.c
+ */
+
+#include <asm/superio.h>
+
+/**
+ *      ns87560_read_buggy      -       workaround buggy Super I/O chip
+ *      @port: Port to read
+ *
+ *      Work around chipset problems in the 87560 SuperIO chip
+ */
+
+static u8 ns87560_read_buggy(void __iomem *port)
+{
+        u8 tmp;
+        int retries = SUPERIO_IDE_MAX_RETRIES;
+        do {
+                tmp = ioread8(port);
+                if (tmp != 0)
+                        return tmp;
+                udelay(50);
+        } while(retries-- > 0);
+        return tmp;
+}
+
+/**
+ *      ns87560_check_status
+ *      @ap: channel to check
+ *
+ *      Return the status of the channel working around the
+ *      87560 flaws.
+ */
+
+static u8 ns87560_check_status(struct ata_port *ap)
+{
+        return ns87560_read_buggy(ap->ioaddr.status_addr);
+}
+
+/**
+ *      ns87560_tf_read - input device's ATA taskfile shadow registers
+ *      @ap: Port from which input is read
+ *      @tf: ATA taskfile register set for storing input
+ *
+ *      Reads ATA taskfile registers for currently-selected device
+ *      into @tf. Work around the 87560 bugs.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+void ns87560_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        struct ata_ioports *ioaddr = &ap->ioaddr;
+
+        tf->command = ns87560_check_status(ap);
+        tf->feature = ioread8(ioaddr->error_addr);
+        tf->nsect = ioread8(ioaddr->nsect_addr);
+        tf->lbal = ioread8(ioaddr->lbal_addr);
+        tf->lbam = ioread8(ioaddr->lbam_addr);
+        tf->lbah = ioread8(ioaddr->lbah_addr);
+        tf->device = ns87560_read_buggy(ioaddr->device_addr);
+
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                iowrite8(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
+                tf->hob_feature = ioread8(ioaddr->error_addr);
+                tf->hob_nsect = ioread8(ioaddr->nsect_addr);
+                tf->hob_lbal = ioread8(ioaddr->lbal_addr);
+                tf->hob_lbam = ioread8(ioaddr->lbam_addr);
+                tf->hob_lbah = ioread8(ioaddr->lbah_addr);
+                iowrite8(tf->ctl, ioaddr->ctl_addr);
+                ap->last_ctl = tf->ctl;
+        }
+}
+
+/**
+ *      ns87560_bmdma_status
+ *      @ap: channel to check
+ *
+ *      Return the DMA status of the channel working around the
+ *      87560 flaws.
+ */
+
+static u8 ns87560_bmdma_status(struct ata_port *ap)
+{
+        return ns87560_read_buggy(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+}
+
+static const struct ata_port_operations ns87560_pata_ops = {
+        .set_piomode            = ns87415_set_piomode,
+        .mode_filter            = ata_pci_default_filter,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ns87560_tf_read,
+        .check_status           = ns87560_check_status,
+        .check_atapi_dma        = ns87415_check_atapi_dma,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .bmdma_setup            = ns87415_bmdma_setup,
+        .bmdma_start            = ns87415_bmdma_start,
+        .bmdma_stop             = ns87415_bmdma_stop,
+        .bmdma_status           = ns87560_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ns87415_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        .port_start             = ata_sff_port_start,
+};
+
+#endif          /* 87560 SuperIO Support */
+
+
+static const struct ata_port_operations ns87415_pata_ops = {
+        .set_piomode            = ns87415_set_piomode,
+        .mode_filter            = ata_pci_default_filter,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .check_atapi_dma        = ns87415_check_atapi_dma,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .bmdma_setup            = ns87415_bmdma_setup,
+        .bmdma_start            = ns87415_bmdma_start,
+        .bmdma_stop             = ns87415_bmdma_stop,
+        .bmdma_status           = ata_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ns87415_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        .port_start             = ata_sff_port_start,
+};
+
+static struct scsi_host_template ns87415_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+};
+
+
+/**
+ *      ns87415_init_one - Register 87415 ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in ns87415_pci_tbl matching with @pdev
+ *
+ *      Called from kernel PCI layer.  We probe for combined mode (sigh),
+ *      and then hand over control to libata, for it to do the rest.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int ns87415_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version;
+        static const struct ata_port_info info = {
+                .sht            = &ns87415_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .port_ops       = &ns87415_pata_ops,
+        };
+        const struct ata_port_info *ppi[] = { &info, NULL };
+#if defined(CONFIG_SUPERIO)
+        static const struct ata_port_info info87560 = {
+                .sht            = &ns87415_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .port_ops       = &ns87560_pata_ops,
+        };
+
+        if (PCI_SLOT(pdev->devfn) == 0x0E)
+                ppi[0] = &info87560;
+#endif
+        if (!printed_version++)
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
+        /* Select 512 byte sectors */
+        pci_write_config_byte(pdev, 0x55, 0xEE);
+        /* Select PIO0 8bit clocking */
+        pci_write_config_byte(pdev, 0x54, 0xB7);
+        return ata_pci_init_one(pdev, ppi);
+}
+
+static const struct pci_device_id ns87415_pci_tbl[] = {
+        { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_87415), },
+
+        { }     /* terminate list */
+};
+
+static struct pci_driver ns87415_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = ns87415_pci_tbl,
+        .probe                  = ns87415_init_one,
+        .remove                 = ata_pci_remove_one,
+#ifdef CONFIG_PM
+        .suspend                = ata_pci_device_suspend,
+        .resume                 = ata_pci_device_resume,
+#endif
+};
+
+static int __init ns87415_init(void)
+{
+        return pci_register_driver(&ns87415_pci_driver);
+}
+
+static void __exit ns87415_exit(void)
+{
+        pci_unregister_driver(&ns87415_pci_driver);
+}
+
+module_init(ns87415_init);
+module_exit(ns87415_exit);
+
+MODULE_AUTHOR("Alan Cox");
+MODULE_DESCRIPTION("ATA low-level driver for NS87415 controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, ns87415_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 091a70a0ef..3cd5eb2b6c 100644
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -29,14 +29,15 @@
 
 /**
  *      oldpiix_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int oldpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits oldpiix_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
@@ -46,7 +47,7 @@ static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &oldpiix_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -237,7 +238,6 @@ static struct scsi_host_template oldpiix_sht = {
 };
 
 static const struct ata_port_operations oldpiix_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = oldpiix_set_piomode,
         .set_dmamode            = oldpiix_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -265,9 +265,8 @@ static const struct ata_port_operations oldpiix_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_opti.c b/drivers/ata/pata_opti.c
index 458bf67f76..8f79447b61 100644
--- a/drivers/ata/pata_opti.c
+++ b/drivers/ata/pata_opti.c
@@ -46,14 +46,15 @@ enum {
 
 /**
  *      opti_pre_reset          -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int opti_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits opti_enable_bits[] = {
                 { 0x45, 1, 0x80, 0x00 },
@@ -63,7 +64,7 @@ static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &opti_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -182,7 +183,6 @@ static struct scsi_host_template opti_sht = {
 };
 
 static struct ata_port_operations opti_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = opti_set_piomode,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
@@ -209,9 +209,8 @@ static struct ata_port_operations opti_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int opti_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index f89bdfde16..6b07b5b485 100644
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -47,14 +47,15 @@ static int pci_clock;	/* 0 = 33 1 = 25 */
 
 /**
  *      optidma_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int optidma_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits optidma_enable_bits = {
                 0x40, 1, 0x08, 0x00
@@ -63,7 +64,7 @@ static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (ap->port_no && !pci_test_config_bits(pdev, &optidma_enable_bits))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -323,25 +324,26 @@ static u8 optidma_make_bits43(struct ata_device *adev)
 
 /**
  *      optidma_set_mode        -       mode setup
- *      @ap: port to set up
+ *      @link: link to set up
  *
  *      Use the standard setup to tune the chipset and then finalise the
  *      configuration by writing the nibble of extra bits of data into
  *      the chip.
  */
 
-static int optidma_set_mode(struct ata_port *ap, struct ata_device **r_failed)
+static int optidma_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
+        struct ata_port *ap = link->ap;
         u8 r;
         int nybble = 4 * ap->port_no;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-        int rc  = ata_do_set_mode(ap, r_failed);
+        int rc  = ata_do_set_mode(link, r_failed);
         if (rc == 0) {
                 pci_read_config_byte(pdev, 0x43, &r);
 
                 r &= (0x0F << nybble);
-                r |= (optidma_make_bits43(&ap->device[0]) +
-                     (optidma_make_bits43(&ap->device[0]) << 2)) << nybble;
+                r |= (optidma_make_bits43(&link->device[0]) +
+                     (optidma_make_bits43(&link->device[0]) << 2)) << nybble;
                 pci_write_config_byte(pdev, 0x43, r);
         }
         return rc;
@@ -366,7 +368,6 @@ static struct scsi_host_template optidma_sht = {
 };
 
 static struct ata_port_operations optidma_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = optidma_set_pio_mode,
         .set_dmamode    = optidma_set_dma_mode,
 
@@ -396,13 +397,11 @@ static struct ata_port_operations optidma_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations optiplus_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = optiplus_set_pio_mode,
         .set_dmamode    = optiplus_set_dma_mode,
 
@@ -432,9 +431,8 @@ static struct ata_port_operations optiplus_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index 0f2b027624..782ff4ada9 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -56,7 +56,7 @@ struct ata_pcmcia_info {
 
 /**
  *      pcmcia_set_mode -       PCMCIA specific mode setup
- *      @ap: Port
+ *      @link: link
  *      @r_failed_dev: Return pointer for failed device
  *
  *      Perform the tuning and setup of the devices and timings, which
@@ -65,13 +65,13 @@ struct ata_pcmcia_info {
  *      decode, which alas is embarrassingly common in the PC world
  */
 
-static int pcmcia_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+static int pcmcia_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
-        struct ata_device *master = &ap->device[0];
-        struct ata_device *slave = &ap->device[1];
+        struct ata_device *master = &link->device[0];
+        struct ata_device *slave = &link->device[1];
 
         if (!ata_dev_enabled(master) || !ata_dev_enabled(slave))
-                return ata_do_set_mode(ap, r_failed_dev);
+                return ata_do_set_mode(link, r_failed_dev);
 
         if (memcmp(master->id + ATA_ID_FW_REV,  slave->id + ATA_ID_FW_REV,
                            ATA_ID_FW_REV_LEN + ATA_ID_PROD_LEN) == 0)
@@ -84,7 +84,7 @@ static int pcmcia_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev
                         ata_dev_disable(slave);
                 }
         }
-        return ata_do_set_mode(ap, r_failed_dev);
+        return ata_do_set_mode(link, r_failed_dev);
 }
 
 static struct scsi_host_template pcmcia_sht = {
@@ -107,7 +107,6 @@ static struct scsi_host_template pcmcia_sht = {
 
 static struct ata_port_operations pcmcia_port_ops = {
         .set_mode       = pcmcia_set_mode,
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -127,7 +126,6 @@ static struct ata_port_operations pcmcia_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_sff_port_start,
 };
@@ -304,6 +302,8 @@ next_entry:
         ap->ioaddr.ctl_addr = ctl_addr;
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io_base, ctl_base);
+
         /* activate */
         ret = ata_host_activate(host, pdev->irq.AssignedIRQ, ata_interrupt,
                                 IRQF_SHARED, &pcmcia_sht);
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index bb64a986e8..3d3f1558cd 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -69,7 +69,7 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev);
 static int pdc2027x_check_atapi_dma(struct ata_queued_cmd *qc);
 static unsigned long pdc2027x_mode_filter(struct ata_device *adev, unsigned long mask);
 static int pdc2027x_cable_detect(struct ata_port *ap);
-static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed);
+static int pdc2027x_set_mode(struct ata_link *link, struct ata_device **r_failed);
 
 /*
  * ATA Timing Tables based on 133MHz controller clock.
@@ -147,7 +147,6 @@ static struct scsi_host_template pdc2027x_sht = {
 };
 
 static struct ata_port_operations pdc2027x_pata100_ops = {
-        .port_disable           = ata_port_disable,
         .mode_filter            = ata_pci_default_filter,
 
         .tf_load                = ata_tf_load,
@@ -173,13 +172,11 @@ static struct ata_port_operations pdc2027x_pata100_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static struct ata_port_operations pdc2027x_pata133_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = pdc2027x_set_piomode,
         .set_dmamode            = pdc2027x_set_dmamode,
         .set_mode               = pdc2027x_set_mode,
@@ -208,9 +205,8 @@ static struct ata_port_operations pdc2027x_pata133_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static struct ata_port_info pdc2027x_port_info[] = {
@@ -277,7 +273,7 @@ static int pdc2027x_cable_detect(struct ata_port *ap)
         u32 cgcr;
 
         /* check cable detect results */
-        cgcr = readl(port_mmio(ap, PDC_GLOBAL_CTL));
+        cgcr = ioread32(port_mmio(ap, PDC_GLOBAL_CTL));
         if (cgcr & (1 << 26))
                 goto cbl40;
 
@@ -295,12 +291,12 @@ cbl40:
  */
 static inline int pdc2027x_port_enabled(struct ata_port *ap)
 {
-        return readb(port_mmio(ap, PDC_ATA_CTL)) & 0x02;
+        return ioread8(port_mmio(ap, PDC_ATA_CTL)) & 0x02;
 }
 
 /**
  *      pdc2027x_prereset - prereset for PATA host controller
- *      @ap: Target port
+ *      @link: Target link
  *      @deadline: deadline jiffies for the operation
  *
  *      Probeinit including cable detection.
@@ -309,12 +305,12 @@ static inline int pdc2027x_port_enabled(struct ata_port *ap)
  *      None (inherited from caller).
  */
 
-static int pdc2027x_prereset(struct ata_port *ap, unsigned long deadline)
+static int pdc2027x_prereset(struct ata_link *link, unsigned long deadline)
 {
         /* Check whether port enabled */
-        if (!pdc2027x_port_enabled(ap))
+        if (!pdc2027x_port_enabled(link->ap))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -387,16 +383,16 @@ static void pdc2027x_set_piomode(struct ata_port *ap, struct ata_device *adev)
         /* Set the PIO timing registers using value table for 133MHz */
         PDPRINTK("Set pio regs... \n");
 
-        ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
+        ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));
         ctcr0 &= 0xffff0000;
         ctcr0 |= pdc2027x_pio_timing_tbl[pio].value0 |
                 (pdc2027x_pio_timing_tbl[pio].value1 << 8);
-        writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
+        iowrite32(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
 
-        ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
+        ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
         ctcr1 &= 0x00ffffff;
         ctcr1 |= (pdc2027x_pio_timing_tbl[pio].value2 << 24);
-        writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
+        iowrite32(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
 
         PDPRINTK("Set pio regs done\n");
 
@@ -430,18 +426,18 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                          * If tHOLD is '1', the hardware will add half clock for data hold time.
                          * This code segment seems to be no effect. tHOLD will be overwritten below.
                          */
-                        ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
-                        writel(ctcr1 & ~(1 << 7), dev_mmio(ap, adev, PDC_CTCR1));
+                        ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
+                        iowrite32(ctcr1 & ~(1 << 7), dev_mmio(ap, adev, PDC_CTCR1));
                 }
 
                 PDPRINTK("Set udma regs... \n");
 
-                ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
+                ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
                 ctcr1 &= 0xff000000;
                 ctcr1 |= pdc2027x_udma_timing_tbl[udma_mode].value0 |
                         (pdc2027x_udma_timing_tbl[udma_mode].value1 << 8) |
                         (pdc2027x_udma_timing_tbl[udma_mode].value2 << 16);
-                writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
+                iowrite32(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
 
                 PDPRINTK("Set udma regs done\n");
 
@@ -453,13 +449,13 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 unsigned int mdma_mode = dma_mode & 0x07;
 
                 PDPRINTK("Set mdma regs... \n");
-                ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
+                ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));
 
                 ctcr0 &= 0x0000ffff;
                 ctcr0 |= (pdc2027x_mdma_timing_tbl[mdma_mode].value0 << 16) |
                         (pdc2027x_mdma_timing_tbl[mdma_mode].value1 << 24);
 
-                writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
+                iowrite32(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
                 PDPRINTK("Set mdma regs done\n");
 
                 PDPRINTK("Set to mdma mode[%u] \n", mdma_mode);
@@ -470,24 +466,24 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 
 /**
  *      pdc2027x_set_mode - Set the timing registers back to correct values.
- *      @ap: Port to configure
+ *      @link: link to configure
  *      @r_failed: Returned device for failure
  *
  *      The pdc2027x hardware will look at "SET FEATURES" and change the timing registers
  *      automatically. The values set by the hardware might be incorrect, under 133Mhz PLL.
  *      This function overwrites the possibly incorrect values set by the hardware to be correct.
  */
-static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed)
+static int pdc2027x_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
-        int i;
-
-        i = ata_do_set_mode(ap, r_failed);
-        if (i < 0)
-                return i;
+        struct ata_port *ap = link->ap;
+        struct ata_device *dev;
+        int rc;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        rc = ata_do_set_mode(link, r_failed);
+        if (rc < 0)
+                return rc;
 
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
 
                         pdc2027x_set_piomode(ap, dev);
@@ -496,9 +492,9 @@ static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed)
                          * Enable prefetch if the device support PIO only.
                          */
                         if (dev->xfer_shift == ATA_SHIFT_PIO) {
-                                u32 ctcr1 = readl(dev_mmio(ap, dev, PDC_CTCR1));
+                                u32 ctcr1 = ioread32(dev_mmio(ap, dev, PDC_CTCR1));
                                 ctcr1 |= (1 << 25);
-                                writel(ctcr1, dev_mmio(ap, dev, PDC_CTCR1));
+                                iowrite32(ctcr1, dev_mmio(ap, dev, PDC_CTCR1));
 
                                 PDPRINTK("Turn on prefetch\n");
                         } else {
@@ -563,14 +559,12 @@ static long pdc_read_counter(struct ata_host *host)
         u32 bccrl, bccrh, bccrlv, bccrhv;
 
 retry:
-        bccrl = readl(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
-        bccrh = readl(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
-        rmb();
+        bccrl = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
+        bccrh = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
 
         /* Read the counter values again for verification */
-        bccrlv = readl(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
-        bccrhv = readl(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
-        rmb();
+        bccrlv = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
+        bccrhv = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
 
         counter = (bccrh << 15) | bccrl;
 
@@ -619,7 +613,7 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
         /* Show the current clock value of PLL control register
          * (maybe already configured by the firmware)
          */
-        pll_ctl = readw(mmio_base + PDC_PLL_CTL);
+        pll_ctl = ioread16(mmio_base + PDC_PLL_CTL);
 
         PDPRINTK("pll_ctl[%X]\n", pll_ctl);
 #endif
@@ -659,8 +653,8 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
 
         PDPRINTK("Writing pll_ctl[%X]\n", pll_ctl);
 
-        writew(pll_ctl, mmio_base + PDC_PLL_CTL);
-        readw(mmio_base + PDC_PLL_CTL); /* flush */
+        iowrite16(pll_ctl, mmio_base + PDC_PLL_CTL);
+        ioread16(mmio_base + PDC_PLL_CTL); /* flush */
 
         /* Wait the PLL circuit to be stable */
         mdelay(30);
@@ -670,7 +664,7 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
          *  Show the current clock value of PLL control register
          * (maybe configured by the firmware)
          */
-        pll_ctl = readw(mmio_base + PDC_PLL_CTL);
+        pll_ctl = ioread16(mmio_base + PDC_PLL_CTL);
 
         PDPRINTK("pll_ctl[%X]\n", pll_ctl);
 #endif
@@ -693,10 +687,10 @@ static long pdc_detect_pll_input_clock(struct ata_host *host)
         long pll_clock, usec_elapsed;
 
         /* Start the test mode */
-        scr = readl(mmio_base + PDC_SYS_CTL);
+        scr = ioread32(mmio_base + PDC_SYS_CTL);
         PDPRINTK("scr[%X]\n", scr);
-        writel(scr | (0x01 << 14), mmio_base + PDC_SYS_CTL);
-        readl(mmio_base + PDC_SYS_CTL); /* flush */
+        iowrite32(scr | (0x01 << 14), mmio_base + PDC_SYS_CTL);
+        ioread32(mmio_base + PDC_SYS_CTL); /* flush */
 
         /* Read current counter value */
         start_count = pdc_read_counter(host);
@@ -710,10 +704,10 @@ static long pdc_detect_pll_input_clock(struct ata_host *host)
         do_gettimeofday(&end_time);
 
         /* Stop the test mode */
-        scr = readl(mmio_base + PDC_SYS_CTL);
+        scr = ioread32(mmio_base + PDC_SYS_CTL);
         PDPRINTK("scr[%X]\n", scr);
-        writel(scr & ~(0x01 << 14), mmio_base + PDC_SYS_CTL);
-        readl(mmio_base + PDC_SYS_CTL); /* flush */
+        iowrite32(scr & ~(0x01 << 14), mmio_base + PDC_SYS_CTL);
+        ioread32(mmio_base + PDC_SYS_CTL); /* flush */
 
         /* calculate the input clock in Hz */
         usec_elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
@@ -745,9 +739,6 @@ static int pdc_hardware_init(struct ata_host *host, unsigned int board_idx)
          */
         pll_clock = pdc_detect_pll_input_clock(host);
 
-        if (pll_clock < 0) /* counter overflow? Try again. */
-                pll_clock = pdc_detect_pll_input_clock(host);
-
         dev_printk(KERN_INFO, host->dev, "PLL input clock %ld kHz\n", pll_clock/1000);
 
         /* Adjust PLL control register */
@@ -791,12 +782,14 @@ static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base)
 static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
+        static const unsigned long cmd_offset[] = { 0x17c0, 0x15c0 };
+        static const unsigned long bmdma_offset[] = { 0x1000, 0x1008 };
         unsigned int board_idx = (unsigned int) ent->driver_data;
         const struct ata_port_info *ppi[] =
                 { &pdc2027x_port_info[board_idx], NULL };
         struct ata_host *host;
         void __iomem *mmio_base;
-        int rc;
+        int i, rc;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -826,10 +819,15 @@ static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_de
 
         mmio_base = host->iomap[PDC_MMIO_BAR];
 
-        pdc_ata_setup_port(&host->ports[0]->ioaddr, mmio_base + 0x17c0);
-        host->ports[0]->ioaddr.bmdma_addr = mmio_base + 0x1000;
-        pdc_ata_setup_port(&host->ports[1]->ioaddr, mmio_base + 0x15c0);
-        host->ports[1]->ioaddr.bmdma_addr = mmio_base + 0x1008;
+        for (i = 0; i < 2; i++) {
+                struct ata_port *ap = host->ports[i];
+
+                pdc_ata_setup_port(&ap->ioaddr, mmio_base + cmd_offset[i]);
+                ap->ioaddr.bmdma_addr = mmio_base + bmdma_offset[i];
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, cmd_offset[i], "cmd");
+        }
 
         //pci_enable_intx(pdev);
 
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index 92447bed5e..65d951618c 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -9,7 +9,7 @@
  * First cut with LBA48/ATAPI
  *
  * TODO:
- *      Channel interlock/reset on both required
+ *      Channel interlock/reset on both required ?
  */
 
 #include <linux/kernel.h>
@@ -22,7 +22,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_pdc202xx_old"
-#define DRV_VERSION "0.4.2"
+#define DRV_VERSION "0.4.3"
 
 static int pdc2026x_cable_detect(struct ata_port *ap)
 {
@@ -106,9 +106,9 @@ static void pdc202xx_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 { 0x20, 0x01 }
         };
         static u8 mdma_timing[3][2] = {
-                { 0x60, 0x03 },
-                { 0x60, 0x04 },
                 { 0xe0, 0x0f },
+                { 0x60, 0x04 },
+                { 0x60, 0x03 },
         };
         u8 r_bp, r_cp;
 
@@ -139,6 +139,9 @@ static void pdc202xx_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  *
  *      In UDMA3 or higher we have to clock switch for the duration of the
  *      DMA transfer sequence.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void pdc2026x_bmdma_start(struct ata_queued_cmd *qc)
@@ -187,6 +190,9 @@ static void pdc2026x_bmdma_start(struct ata_queued_cmd *qc)
  *
  *      After a DMA completes we need to put the clock back to 33MHz for
  *      PIO timings.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void pdc2026x_bmdma_stop(struct ata_queued_cmd *qc)
@@ -206,7 +212,6 @@ static void pdc2026x_bmdma_stop(struct ata_queued_cmd *qc)
                 iowrite32(0, atapi_reg);
                 iowrite8(ioread8(clock) & ~sel66, clock);
         }
-        /* Check we keep host level locking here */
         /* Flip back to 33Mhz for PIO */
         if (adev->dma_mode >= XFER_UDMA_2)
                 iowrite8(ioread8(clock) & ~sel66, clock);
@@ -247,7 +252,6 @@ static struct scsi_host_template pdc202xx_sht = {
 };
 
 static struct ata_port_operations pdc2024x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = pdc202xx_set_piomode,
         .set_dmamode    = pdc202xx_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -275,13 +279,11 @@ static struct ata_port_operations pdc2024x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations pdc2026x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = pdc202xx_set_piomode,
         .set_dmamode    = pdc202xx_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -310,9 +312,8 @@ static struct ata_port_operations pdc2026x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_platform.c b/drivers/ata/pata_platform.c
index 5086d03f2d..fc72a96564 100644
--- a/drivers/ata/pata_platform.c
+++ b/drivers/ata/pata_platform.c
@@ -30,13 +30,11 @@ static int pio_mask = 1;
  * Provide our own set_mode() as we don't want to change anything that has
  * already been configured..
  */
-static int pata_platform_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int pata_platform_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
-
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        struct ata_device *dev;
 
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
@@ -71,7 +69,6 @@ static struct scsi_host_template pata_platform_sht = {
 static struct ata_port_operations pata_platform_port_ops = {
         .set_mode               = pata_platform_set_mode,
 
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -91,7 +88,6 @@ static struct ata_port_operations pata_platform_port_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_dummy_ret0,
 };
@@ -209,9 +205,13 @@ static int __devinit pata_platform_probe(struct platform_device *pdev)
 
         ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
 
-        pp_info = (struct pata_platform_info *)(pdev->dev.platform_data);
+        pp_info = pdev->dev.platform_data;
         pata_platform_setup_port(&ap->ioaddr, pp_info);
 
+        ata_port_desc(ap, "%s cmd 0x%llx ctl 0x%llx", mmio ? "mmio" : "ioport",
+                      (unsigned long long)io_res->start,
+                      (unsigned long long)ctl_res->start);
+
         /* activate */
         return ata_host_activate(host, platform_get_irq(pdev, 0),
                                  ata_interrupt, pp_info ? pp_info->irq_flags
diff --git a/drivers/ata/pata_qdi.c b/drivers/ata/pata_qdi.c
index 1998c19e87..7d4c696c4c 100644
--- a/drivers/ata/pata_qdi.c
+++ b/drivers/ata/pata_qdi.c
@@ -126,7 +126,7 @@ static unsigned int qdi_qc_issue_prot(struct ata_queued_cmd *qc)
 
 static void qdi_data_xfer(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
 
         if (ata_id_has_dword_io(adev->id)) {
@@ -170,7 +170,6 @@ static struct scsi_host_template qdi_sht = {
 };
 
 static struct ata_port_operations qdi6500_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = qdi6500_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -192,13 +191,11 @@ static struct ata_port_operations qdi6500_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations qdi6580_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = qdi6580_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -220,9 +217,8 @@ static struct ata_port_operations qdi6580_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -238,6 +234,7 @@ static struct ata_port_operations qdi6580_port_ops = {
 
 static __init int qdi_init_one(unsigned long port, int type, unsigned long io, int irq, int fast)
 {
+        unsigned long ctl = io + 0x206;
         struct platform_device *pdev;
         struct ata_host *host;
         struct ata_port *ap;
@@ -254,7 +251,7 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
 
         ret = -ENOMEM;
         io_addr = devm_ioport_map(&pdev->dev, io, 8);
-        ctl_addr = devm_ioport_map(&pdev->dev, io + 0x206, 1);
+        ctl_addr = devm_ioport_map(&pdev->dev, ctl, 1);
         if (!io_addr || !ctl_addr)
                 goto fail;
 
@@ -279,6 +276,8 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
         ap->ioaddr.ctl_addr = ctl_addr;
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd %lx ctl %lx", io, ctl);
+
         /*
          *      Hook in a private data structure per channel
          */
diff --git a/drivers/ata/pata_radisys.c b/drivers/ata/pata_radisys.c
index 7d1aabed42..d5b76497f4 100644
--- a/drivers/ata/pata_radisys.c
+++ b/drivers/ata/pata_radisys.c
@@ -203,7 +203,6 @@ static struct scsi_host_template radisys_sht = {
 };
 
 static const struct ata_port_operations radisys_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = radisys_set_piomode,
         .set_dmamode            = radisys_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -231,9 +230,8 @@ static const struct ata_port_operations radisys_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 7632fcb070..ba8a31c55e 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -26,7 +26,7 @@
 
 /**
  *      rz1000_set_mode         -       mode setting function
- *      @ap: ATA interface
+ *      @link: ATA link
  *      @unused: returned device on set_mode failure
  *
  *      Use a non standard set_mode function. We don't want to be tuned. We
@@ -34,12 +34,11 @@
  *      whacked out.
  */
 
-static int rz1000_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int rz1000_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
@@ -74,7 +73,6 @@ static struct scsi_host_template rz1000_sht = {
 static struct ata_port_operations rz1000_port_ops = {
         .set_mode       = rz1000_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -100,9 +98,8 @@ static struct ata_port_operations rz1000_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int rz1000_fifo_disable(struct pci_dev *pdev)
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index 5edf67b1f3..21ebc485ca 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -197,7 +197,6 @@ static struct scsi_host_template sc1200_sht = {
 };
 
 static struct ata_port_operations sc1200_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sc1200_set_piomode,
         .set_dmamode    = sc1200_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -227,9 +226,8 @@ static struct ata_port_operations sc1200_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index 2d048ef25a..55576138fa 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -603,16 +603,17 @@ static unsigned int scc_bus_softreset(struct ata_port *ap, unsigned int devmask,
  *      Note: Original code is ata_std_softreset().
  */
 
-static int scc_std_softreset (struct ata_port *ap, unsigned int *classes,
-                              unsigned long deadline)
+static int scc_std_softreset(struct ata_link *link, unsigned int *classes,
+                             unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         unsigned int devmask = 0, err_mask;
         u8 err;
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 classes[0] = ATA_DEV_NONE;
                 goto out;
         }
@@ -636,9 +637,11 @@ static int scc_std_softreset (struct ata_port *ap, unsigned int *classes,
         }
 
         /* determine by signature whether we have ATA or ATAPI devices */
-        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        classes[0] = ata_dev_try_classify(&ap->link.device[0],
+                                          devmask & (1 << 0), &err);
         if (slave_possible && err != 0x81)
-                classes[1] = ata_dev_try_classify(ap, 1, &err);
+                classes[1] = ata_dev_try_classify(&ap->link.device[1],
+                                                  devmask & (1 << 1), &err);
 
  out:
         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
@@ -701,7 +704,7 @@ static void scc_bmdma_stop (struct ata_queued_cmd *qc)
                         printk(KERN_WARNING "%s: Internal Bus Error\n", DRV_NAME);
                         out_be32(bmid_base + SCC_DMA_INTST, INTSTS_BMSINT);
                         /* TBD: SW reset */
-                        scc_std_softreset(ap, &classes, deadline);
+                        scc_std_softreset(&ap->link, &classes, deadline);
                         continue;
                 }
 
@@ -740,7 +743,7 @@ static u8 scc_bmdma_status (struct ata_port *ap)
         void __iomem *mmio = ap->ioaddr.bmdma_addr;
         u8 host_stat = in_be32(mmio + SCC_DMA_STATUS);
         u32 int_status = in_be32(mmio + SCC_DMA_INTST);
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
         static int retry = 0;
 
         /* return if IOS_SS is cleared */
@@ -785,7 +788,7 @@ static u8 scc_bmdma_status (struct ata_port *ap)
 static void scc_data_xfer (struct ata_device *adev, unsigned char *buf,
                            unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         unsigned int words = buflen >> 1;
         unsigned int i;
         u16 *buf16 = (u16 *) buf;
@@ -839,38 +842,6 @@ static u8 scc_irq_on (struct ata_port *ap)
 }
 
 /**
- *      scc_irq_ack - Acknowledge a device interrupt.
- *      @ap: Port on which interrupts are enabled.
- *
- *      Note: Original code is ata_irq_ack().
- */
-
-static u8 scc_irq_ack (struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 host_stat, post_stat, status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        /* get controller status; clear intr, err bits */
-        host_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
-        out_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS,
-                 host_stat | ATA_DMA_INTR | ATA_DMA_ERR);
-
-        post_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
-
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
-                       __FUNCTION__,
-                       host_stat, post_stat, status);
-
-        return status;
-}
-
-/**
  *      scc_bmdma_freeze - Freeze BMDMA controller port
  *      @ap: port to freeze
  *
@@ -901,10 +872,10 @@ static void scc_bmdma_freeze (struct ata_port *ap)
  *      @deadline: deadline jiffies for the operation
  */
 
-static int scc_pata_prereset(struct ata_port *ap, unsigned long deadline)
+static int scc_pata_prereset(struct ata_link *link, unsigned long deadline)
 {
-        ap->cbl = ATA_CBL_PATA80;
-        return ata_std_prereset(ap, deadline);
+        link->ap->cbl = ATA_CBL_PATA80;
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -915,8 +886,10 @@ static int scc_pata_prereset(struct ata_port *ap, unsigned long deadline)
  *      Note: Original code is ata_std_postreset().
  */
 
-static void scc_std_postreset (struct ata_port *ap, unsigned int *classes)
+static void scc_std_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
+
         DPRINTK("ENTER\n");
 
         /* is double-select really necessary? */
@@ -1020,7 +993,6 @@ static struct scsi_host_template scc_sht = {
 };
 
 static const struct ata_port_operations scc_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = scc_set_piomode,
         .set_dmamode            = scc_set_dmamode,
         .mode_filter            = scc_mode_filter,
@@ -1047,7 +1019,6 @@ static const struct ata_port_operations scc_pata_ops = {
 
         .irq_clear              = scc_bmdma_irq_clear,
         .irq_on                 = scc_irq_on,
-        .irq_ack                = scc_irq_ack,
 
         .port_start             = scc_port_start,
         .port_stop              = scc_port_stop,
@@ -1193,6 +1164,9 @@ static int scc_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 return rc;
         host->iomap = pcim_iomap_table(pdev);
 
+        ata_port_pbar_desc(host->ports[0], SCC_CTRL_BAR, -1, "ctrl");
+        ata_port_pbar_desc(host->ports[0], SCC_BMID_BAR, -1, "bmid");
+
         rc = scc_host_init(host);
         if (rc)
                 return rc;
diff --git a/drivers/ata/pata_serverworks.c b/drivers/ata/pata_serverworks.c
index 0faf99c8f1..df68806df4 100644
--- a/drivers/ata/pata_serverworks.c
+++ b/drivers/ata/pata_serverworks.c
@@ -318,7 +318,6 @@ static struct scsi_host_template serverworks_sht = {
 };
 
 static struct ata_port_operations serverworks_osb4_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = serverworks_set_piomode,
         .set_dmamode    = serverworks_set_dmamode,
         .mode_filter    = serverworks_osb4_filter,
@@ -348,13 +347,11 @@ static struct ata_port_operations serverworks_osb4_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations serverworks_csb_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = serverworks_set_piomode,
         .set_dmamode    = serverworks_set_dmamode,
         .mode_filter    = serverworks_csb_filter,
@@ -384,9 +381,8 @@ static struct ata_port_operations serverworks_csb_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int serverworks_fixup_osb4(struct pci_dev *pdev)
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 40395804a6..2eb75cd74a 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -95,15 +95,16 @@ static int sil680_cable_detect(struct ata_port *ap) {
 
 /**
  *      sil680_bus_reset        -       reset the SIL680 bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the SIL680 housekeeping when doing an ATA bus reset
  */
 
-static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
+static int sil680_bus_reset(struct ata_link *link, unsigned int *classes,
                             unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         unsigned long addr = sil680_selreg(ap, 0);
         u8 reset;
@@ -112,7 +113,7 @@ static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
         pci_write_config_byte(pdev, addr, reset | 0x03);
         udelay(25);
         pci_write_config_byte(pdev, addr, reset);
-        return ata_std_softreset(ap, classes, deadline);
+        return ata_std_softreset(link, classes, deadline);
 }
 
 static void sil680_error_handler(struct ata_port *ap)
@@ -237,7 +238,6 @@ static struct scsi_host_template sil680_sht = {
 };
 
 static struct ata_port_operations sil680_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sil680_set_piomode,
         .set_dmamode    = sil680_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -266,9 +266,8 @@ static struct ata_port_operations sil680_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index cce2834b2b..3b5be77e86 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -84,7 +84,7 @@ static int sis_short_ata40(struct pci_dev *dev)
 
 static int sis_old_port_base(struct ata_device *adev)
 {
-        return  0x40 + (4 * adev->ap->port_no) +  (2 * adev->devno);
+        return  0x40 + (4 * adev->link->ap->port_no) +  (2 * adev->devno);
 }
 
 /**
@@ -133,19 +133,20 @@ static int sis_66_cable_detect(struct ata_port *ap)
 
 /**
  *      sis_pre_reset           -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sis_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits sis_enable_bits[] = {
                 { 0x4aU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                 { 0x4aU, 1U, 0x04UL, 0x04UL },  /* port 1 */
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no]))
@@ -154,7 +155,7 @@ static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
         /* Clear the FIFO settings. We can't enable the FIFO until
            we know we are poking at a disk */
         pci_write_config_byte(pdev, 0x4B, 0);
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -530,7 +531,6 @@ static struct scsi_host_template sis_sht = {
 };
 
 static const struct ata_port_operations sis_133_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_133_set_piomode,
         .set_dmamode            = sis_133_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -558,13 +558,11 @@ static const struct ata_port_operations sis_133_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_133_for_sata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_133_set_piomode,
         .set_dmamode            = sis_133_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -592,13 +590,11 @@ static const struct ata_port_operations sis_133_for_sata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_133_early_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_100_set_piomode,
         .set_dmamode            = sis_133_early_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -626,13 +622,11 @@ static const struct ata_port_operations sis_133_early_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_100_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_100_set_piomode,
         .set_dmamode            = sis_100_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -660,13 +654,11 @@ static const struct ata_port_operations sis_100_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_66_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_old_set_piomode,
         .set_dmamode            = sis_66_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -694,13 +686,11 @@ static const struct ata_port_operations sis_66_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_old_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_old_set_piomode,
         .set_dmamode            = sis_old_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -728,9 +718,8 @@ static const struct ata_port_operations sis_old_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_info sis_info = {
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index c0f43bb259..1388cef52c 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -43,23 +43,24 @@ enum {
 
 /**
  *      sl82c105_pre_reset              -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int sl82c105_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sl82c105_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits sl82c105_enable_bits[] = {
                 { 0x40, 1, 0x01, 0x01 },
                 { 0x40, 1, 0x10, 0x10 }
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (ap->port_no && !pci_test_config_bits(pdev, &sl82c105_enable_bits[ap->port_no]))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -224,7 +225,6 @@ static struct scsi_host_template sl82c105_sht = {
 };
 
 static struct ata_port_operations sl82c105_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sl82c105_set_piomode,
         .mode_filter    = ata_pci_default_filter,
 
@@ -253,9 +253,8 @@ static struct ata_port_operations sl82c105_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index af21f443db..403eafcffe 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -47,25 +47,26 @@
 
 /**
  *      triflex_prereset                -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int triflex_prereset(struct ata_port *ap, unsigned long deadline)
+static int triflex_prereset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits triflex_enable_bits[] = {
                 { 0x80, 1, 0x01, 0x01 },
                 { 0x80, 1, 0x02, 0x02 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -197,7 +198,6 @@ static struct scsi_host_template triflex_sht = {
 };
 
 static struct ata_port_operations triflex_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = triflex_set_piomode,
         .mode_filter    = ata_pci_default_filter,
 
@@ -226,9 +226,8 @@ static struct ata_port_operations triflex_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index f143db4559..5d41b6612d 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -184,11 +184,15 @@ static int via_cable_detect(struct ata_port *ap) {
            two drives */
         if (ata66 & (0x10100000 >> (16 * ap->port_no)))
                 return ATA_CBL_PATA80;
+        /* Check with ACPI so we can spot BIOS reported SATA bridges */
+        if (ata_acpi_cbl_80wire(ap))
+                return ATA_CBL_PATA80;
         return ATA_CBL_PATA40;
 }
 
-static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int via_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         const struct via_isa_bridge *config = ap->host->private_data;
 
         if (!(config->flags & VIA_NO_ENABLES)) {
@@ -201,7 +205,7 @@ static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
                         return -ENOENT;
         }
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -344,7 +348,6 @@ static struct scsi_host_template via_sht = {
 };
 
 static struct ata_port_operations via_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = via_set_piomode,
         .set_dmamode    = via_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -374,13 +377,11 @@ static struct ata_port_operations via_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations via_port_ops_noirq = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = via_set_piomode,
         .set_dmamode    = via_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -410,9 +411,8 @@ static struct ata_port_operations via_port_ops_noirq = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_winbond.c b/drivers/ata/pata_winbond.c
index 83abfeca40..549cbbe9fd 100644
--- a/drivers/ata/pata_winbond.c
+++ b/drivers/ata/pata_winbond.c
@@ -94,7 +94,7 @@ static void winbond_set_piomode(struct ata_port *ap, struct ata_device *adev)
 
 static void winbond_data_xfer(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
 
         if (ata_id_has_dword_io(adev->id)) {
@@ -138,7 +138,6 @@ static struct scsi_host_template winbond_sht = {
 };
 
 static struct ata_port_operations winbond_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = winbond_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -160,9 +159,8 @@ static struct ata_port_operations winbond_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -199,6 +197,7 @@ static __init int winbond_init_one(unsigned long port)
 
         for (i = 0; i < 2 ; i ++) {
                 unsigned long cmd_port = 0x1F0 - (0x80 * i);
+                unsigned long ctl_port = cmd_port + 0x206;
                 struct ata_host *host;
                 struct ata_port *ap;
                 void __iomem *cmd_addr, *ctl_addr;
@@ -214,14 +213,16 @@ static __init int winbond_init_one(unsigned long port)
                 host = ata_host_alloc(&pdev->dev, 1);
                 if (!host)
                         goto err_unregister;
+                ap = host->ports[0];
 
                 rc = -ENOMEM;
                 cmd_addr = devm_ioport_map(&pdev->dev, cmd_port, 8);
-                ctl_addr = devm_ioport_map(&pdev->dev, cmd_port + 0x0206, 1);
+                ctl_addr = devm_ioport_map(&pdev->dev, ctl_port, 1);
                 if (!cmd_addr || !ctl_addr)
                         goto err_unregister;
 
-                ap = host->ports[0];
+                ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", cmd_port, ctl_port);
+
                 ap->ops = &winbond_port_ops;
                 ap->pio_mask = 0x1F;
                 ap->flags |= ATA_FLAG_SLAVE_POSS;
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index 5c79271401..8d1b03d5bc 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -92,6 +92,8 @@ enum {
 
         /* CPB bits */
         cDONE                   = (1 << 0),
+        cATERR                  = (1 << 3),
+
         cVLD                    = (1 << 0),
         cDAT                    = (1 << 2),
         cIEN                    = (1 << 3),
@@ -131,14 +133,15 @@ static int adma_ata_init_one (struct pci_dev *pdev,
 static int adma_port_start(struct ata_port *ap);
 static void adma_host_stop(struct ata_host *host);
 static void adma_port_stop(struct ata_port *ap);
-static void adma_phy_reset(struct ata_port *ap);
 static void adma_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int adma_qc_issue(struct ata_queued_cmd *qc);
 static int adma_check_atapi_dma(struct ata_queued_cmd *qc);
 static void adma_bmdma_stop(struct ata_queued_cmd *qc);
 static u8 adma_bmdma_status(struct ata_port *ap);
 static void adma_irq_clear(struct ata_port *ap);
-static void adma_eng_timeout(struct ata_port *ap);
+static void adma_freeze(struct ata_port *ap);
+static void adma_thaw(struct ata_port *ap);
+static void adma_error_handler(struct ata_port *ap);
 
 static struct scsi_host_template adma_ata_sht = {
         .module                 = THIS_MODULE,
@@ -159,21 +162,20 @@ static struct scsi_host_template adma_ata_sht = {
 };
 
 static const struct ata_port_operations adma_ata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
         .check_status           = ata_check_status,
         .dev_select             = ata_std_dev_select,
-        .phy_reset              = adma_phy_reset,
         .check_atapi_dma        = adma_check_atapi_dma,
         .data_xfer              = ata_data_xfer,
         .qc_prep                = adma_qc_prep,
         .qc_issue               = adma_qc_issue,
-        .eng_timeout            = adma_eng_timeout,
+        .freeze                 = adma_freeze,
+        .thaw                   = adma_thaw,
+        .error_handler          = adma_error_handler,
         .irq_clear              = adma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = adma_port_start,
         .port_stop              = adma_port_stop,
         .host_stop              = adma_host_stop,
@@ -184,7 +186,7 @@ static const struct ata_port_operations adma_ata_ops = {
 static struct ata_port_info adma_port_info[] = {
         /* board_1841_idx */
         {
-                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST |
+                .flags          = ATA_FLAG_SLAVE_POSS |
                                   ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO |
                                   ATA_FLAG_PIO_POLLING,
                 .pio_mask       = 0x10, /* pio4 */
@@ -273,24 +275,42 @@ static inline void adma_enter_reg_mode(struct ata_port *ap)
         readb(chan + ADMA_STATUS);      /* flush */
 }
 
-static void adma_phy_reset(struct ata_port *ap)
+static void adma_freeze(struct ata_port *ap)
 {
-        struct adma_port_priv *pp = ap->private_data;
+        void __iomem *chan = ADMA_PORT_REGS(ap);
+
+        /* mask/clear ATA interrupts */
+        writeb(ATA_NIEN, ap->ioaddr.ctl_addr);
+        ata_check_status(ap);
 
-        pp->state = adma_state_idle;
+        /* reset ADMA to idle state */
+        writew(aPIOMD4 | aNIEN | aRSTADM, chan + ADMA_CONTROL);
+        udelay(2);
+        writew(aPIOMD4 | aNIEN, chan + ADMA_CONTROL);
+        udelay(2);
+}
+
+static void adma_thaw(struct ata_port *ap)
+{
         adma_reinit_engine(ap);
-        ata_port_probe(ap);
-        ata_bus_reset(ap);
 }
 
-static void adma_eng_timeout(struct ata_port *ap)
+static int adma_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct adma_port_priv *pp = ap->private_data;
 
         if (pp->state != adma_state_idle) /* healthy paranoia */
                 pp->state = adma_state_mmio;
         adma_reinit_engine(ap);
-        ata_eng_timeout(ap);
+
+        return ata_std_prereset(link, deadline);
+}
+
+static void adma_error_handler(struct ata_port *ap)
+{
+        ata_do_eh(ap, adma_prereset, ata_std_softreset, NULL,
+                  ata_std_postreset);
 }
 
 static int adma_fill_sg(struct ata_queued_cmd *qc)
@@ -464,14 +484,33 @@ static inline unsigned int adma_intr_pkt(struct ata_host *host)
                 pp = ap->private_data;
                 if (!pp || pp->state != adma_state_pkt)
                         continue;
-                qc = ata_qc_from_tag(ap, ap->active_tag);
+                qc = ata_qc_from_tag(ap, ap->link.active_tag);
                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
-                        if ((status & (aPERR | aPSD | aUIRQ)))
+                        if (status & aPERR)
+                                qc->err_mask |= AC_ERR_HOST_BUS;
+                        else if ((status & (aPSD | aUIRQ)))
                                 qc->err_mask |= AC_ERR_OTHER;
+
+                        if (pp->pkt[0] & cATERR)
+                                qc->err_mask |= AC_ERR_DEV;
                         else if (pp->pkt[0] != cDONE)
                                 qc->err_mask |= AC_ERR_OTHER;
 
-                        ata_qc_complete(qc);
+                        if (!qc->err_mask)
+                                ata_qc_complete(qc);
+                        else {
+                                struct ata_eh_info *ehi = &ap->link.eh_info;
+                                ata_ehi_clear_desc(ehi);
+                                ata_ehi_push_desc(ehi,
+                                        "ADMA-status 0x%02X", status);
+                                ata_ehi_push_desc(ehi,
+                                        "pkt[0] 0x%02X", pp->pkt[0]);
+
+                                if (qc->err_mask == AC_ERR_DEV)
+                                        ata_port_abort(ap);
+                                else
+                                        ata_port_freeze(ap);
+                        }
                 }
         }
         return handled;
@@ -489,7 +528,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
                         struct adma_port_priv *pp = ap->private_data;
                         if (!pp || pp->state != adma_state_mmio)
                                 continue;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
 
                                 /* check main status, clearing INTRQ */
@@ -502,7 +541,20 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
                                 /* complete taskfile transaction */
                                 pp->state = adma_state_idle;
                                 qc->err_mask |= ac_err_mask(status);
-                                ata_qc_complete(qc);
+                                if (!qc->err_mask)
+                                        ata_qc_complete(qc);
+                                else {
+                                        struct ata_eh_info *ehi =
+                                                &ap->link.eh_info;
+                                        ata_ehi_clear_desc(ehi);
+                                        ata_ehi_push_desc(ehi,
+                                                "status 0x%02X", status);
+
+                                        if (qc->err_mask == AC_ERR_DEV)
+                                                ata_port_abort(ap);
+                                        else
+                                                ata_port_freeze(ap);
+                                }
                                 handled = 1;
                         }
                 }
@@ -652,9 +704,16 @@ static int adma_ata_init_one(struct pci_dev *pdev,
         if (rc)
                 return rc;
 
-        for (port_no = 0; port_no < ADMA_PORTS; ++port_no)
-                adma_ata_setup_port(&host->ports[port_no]->ioaddr,
-                                    ADMA_ATA_REGS(mmio_base, port_no));
+        for (port_no = 0; port_no < ADMA_PORTS; ++port_no) {
+                struct ata_port *ap = host->ports[port_no];
+                void __iomem *port_base = ADMA_ATA_REGS(mmio_base, port_no);
+                unsigned int offset = port_base - mmio_base;
+
+                adma_ata_setup_port(&ap->ioaddr, port_base);
+
+                ata_port_pbar_desc(ap, ADMA_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, ADMA_MMIO_BAR, offset, "port");
+        }
 
         /* initialize adapter */
         adma_host_init(host, board_idx);
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index fdbed8ecdf..08595f34b3 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -285,7 +285,7 @@ static void inic_irq_clear(struct ata_port *ap)
 static void inic_host_intr(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         u8 irq_stat;
 
         /* fetch and clear irq */
@@ -293,7 +293,8 @@ static void inic_host_intr(struct ata_port *ap)
         writeb(irq_stat, port_base + PORT_IRQ_STAT);
 
         if (likely(!(irq_stat & PIRQ_ERR))) {
-                struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+                struct ata_queued_cmd *qc =
+                        ata_qc_from_tag(ap, ap->link.active_tag);
 
                 if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
                         ata_chk_status(ap);     /* clear ATA interrupt */
@@ -416,12 +417,13 @@ static void inic_thaw(struct ata_port *ap)
  * SRST and SControl hardreset don't give valid signature on this
  * controller.  Only controller specific hardreset mechanism works.
  */
-static int inic_hardreset(struct ata_port *ap, unsigned int *class,
+static int inic_hardreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port_base = inic_port_base(ap);
         void __iomem *idma_ctl = port_base + PORT_IDMA_CTL;
-        const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
         u16 val;
         int rc;
 
@@ -434,15 +436,15 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
         msleep(1);
         writew(val & ~IDMA_CTL_RST_ATA, idma_ctl);
 
-        rc = sata_phy_resume(ap, timing, deadline);
+        rc = sata_link_resume(link, timing, deadline);
         if (rc) {
-                ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                ata_link_printk(link, KERN_WARNING, "failed to resume "
                                 "link after reset (errno=%d)\n", rc);
                 return rc;
         }
 
         *class = ATA_DEV_NONE;
-        if (ata_port_online(ap)) {
+        if (ata_link_online(link)) {
                 struct ata_taskfile tf;
 
                 /* wait a while before checking status */
@@ -451,7 +453,7 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
                 rc = ata_wait_ready(ap, deadline);
                 /* link occupied, -ENODEV too is an error */
                 if (rc) {
-                        ata_port_printk(ap, KERN_WARNING, "device not ready "
+                        ata_link_printk(link, KERN_WARNING, "device not ready "
                                         "after hardreset (errno=%d)\n", rc);
                         return rc;
                 }
@@ -550,7 +552,6 @@ static int inic_port_start(struct ata_port *ap)
 }
 
 static struct ata_port_operations inic_port_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -567,7 +568,6 @@ static struct ata_port_operations inic_port_ops = {
 
         .irq_clear              = inic_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .qc_prep                = ata_qc_prep,
         .qc_issue               = inic_qc_issue,
@@ -693,16 +693,24 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         host->iomap = iomap = pcim_iomap_table(pdev);
 
         for (i = 0; i < NR_PORTS; i++) {
-                struct ata_ioports *port = &host->ports[i]->ioaddr;
-                void __iomem *port_base = iomap[MMIO_BAR] + i * PORT_SIZE;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *port = &ap->ioaddr;
+                unsigned int offset = i * PORT_SIZE;
 
                 port->cmd_addr = iomap[2 * i];
                 port->altstatus_addr =
                 port->ctl_addr = (void __iomem *)
                         ((unsigned long)iomap[2 * i + 1] | ATA_PCI_CTL_OFS);
-                port->scr_addr = port_base + PORT_SCR;
+                port->scr_addr = iomap[MMIO_BAR] + offset + PORT_SCR;
 
                 ata_std_ports(port);
+
+                ata_port_pbar_desc(ap, MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, MMIO_BAR, offset, "port");
+                ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                  (unsigned long long)pci_resource_start(pdev, 2 * i),
+                  (unsigned long long)pci_resource_start(pdev, (2 * i + 1)) |
+                                      ATA_PCI_CTL_OFS);
         }
 
         hpriv->cached_hctl = readw(iomap[MMIO_BAR] + HOST_CTL);
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index d9832e234e..4df8311968 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -483,8 +483,6 @@ static struct scsi_host_template mv6_sht = {
 };
 
 static const struct ata_port_operations mv5_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -499,7 +497,6 @@ static const struct ata_port_operations mv5_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -514,8 +511,6 @@ static const struct ata_port_operations mv5_ops = {
 };
 
 static const struct ata_port_operations mv6_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -530,7 +525,6 @@ static const struct ata_port_operations mv6_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -545,8 +539,6 @@ static const struct ata_port_operations mv6_ops = {
 };
 
 static const struct ata_port_operations mv_iie_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -561,7 +553,6 @@ static const struct ata_port_operations mv_iie_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -1415,7 +1406,7 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         struct mv_host_priv *hpriv = ap->host->private_data;
         unsigned int edma_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
         unsigned int action = 0, err_mask = 0;
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
 
         ata_ehi_clear_desc(ehi);
 
@@ -1423,8 +1414,8 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 /* just a guess: do we need to do this? should we
                  * expand this, and do it in all cases?
                  */
-                sata_scr_read(ap, SCR_ERROR, &serr);
-                sata_scr_write_flush(ap, SCR_ERROR, serr);
+                sata_scr_read(&ap->link, SCR_ERROR, &serr);
+                sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
         }
 
         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
@@ -1468,8 +1459,8 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 }
 
                 if (edma_err_cause & EDMA_ERR_SERR) {
-                        sata_scr_read(ap, SCR_ERROR, &serr);
-                        sata_scr_write_flush(ap, SCR_ERROR, serr);
+                        sata_scr_read(&ap->link, SCR_ERROR, &serr);
+                        sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
                         err_mask = AC_ERR_ATA_BUS;
                         action |= ATA_EH_HARDRESET;
                 }
@@ -1508,7 +1499,7 @@ static void mv_intr_pio(struct ata_port *ap)
                 return;
 
         /* get active ATA command */
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (unlikely(!qc))                      /* no active tag */
                 return;
         if (qc->tf.flags & ATA_TFLAG_POLLING)   /* polling; we don't own qc */
@@ -1543,7 +1534,7 @@ static void mv_intr_edma(struct ata_port *ap)
 
                 /* 50xx: get active ATA command */
                 if (IS_GEN_I(hpriv))
-                        tag = ap->active_tag;
+                        tag = ap->link.active_tag;
 
                 /* Gen II/IIE: get active ATA command via tag, to enable
                  * support for queueing.  this works transparently for
@@ -1646,7 +1637,7 @@ static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
                 if (unlikely(have_err_bits)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
                                 continue;
 
@@ -1687,15 +1678,15 @@ static void mv_pci_error(struct ata_host *host, void __iomem *mmio)
 
         for (i = 0; i < host->n_ports; i++) {
                 ap = host->ports[i];
-                if (!ata_port_offline(ap)) {
-                        ehi = &ap->eh_info;
+                if (!ata_link_offline(&ap->link)) {
+                        ehi = &ap->link.eh_info;
                         ata_ehi_clear_desc(ehi);
                         if (!printed++)
                                 ata_ehi_push_desc(ehi,
                                         "PCI err cause 0x%08x", err_cause);
                         err_mask = AC_ERR_HOST_BUS;
                         ehi->action = ATA_EH_HARDRESET;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc)
                                 qc->err_mask |= err_mask;
                         else
@@ -2198,14 +2189,14 @@ static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
 
         /* Issue COMRESET via SControl */
 comreset_retry:
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
+        sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x301);
         msleep(1);
 
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
+        sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x300);
         msleep(20);
 
         do {
-                sata_scr_read(ap, SCR_STATUS, &sstatus);
+                sata_scr_read(&ap->link, SCR_STATUS, &sstatus);
                 if (((sstatus & 0x3) == 3) || ((sstatus & 0x3) == 0))
                         break;
 
@@ -2230,7 +2221,7 @@ comreset_retry:
         }
 #endif
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(&ap->link)) {
                 *class = ATA_DEV_NONE;
                 return;
         }
@@ -2257,7 +2248,7 @@ comreset_retry:
          */
 
         /* finally, read device signature from TF registers */
-        *class = ata_dev_try_classify(ap, 0, NULL);
+        *class = ata_dev_try_classify(ap->link.device, 1, NULL);
 
         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 
@@ -2266,10 +2257,11 @@ comreset_retry:
         VPRINTK("EXIT\n");
 }
 
-static int mv_prereset(struct ata_port *ap, unsigned long deadline)
+static int mv_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct mv_port_priv *pp = ap->private_data;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &link->eh_context;
         int rc;
 
         rc = mv_stop_dma(ap);
@@ -2285,7 +2277,7 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
         if (ehc->i.action & ATA_EH_HARDRESET)
                 return 0;
 
-        if (ata_port_online(ap))
+        if (ata_link_online(link))
                 rc = ata_wait_ready(ap, deadline);
         else
                 rc = -ENODEV;
@@ -2293,9 +2285,10 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
         return rc;
 }
 
-static int mv_hardreset(struct ata_port *ap, unsigned int *class,
+static int mv_hardreset(struct ata_link *link, unsigned int *class,
                         unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct mv_host_priv *hpriv = ap->host->private_data;
         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
 
@@ -2308,16 +2301,17 @@ static int mv_hardreset(struct ata_port *ap, unsigned int *class,
         return 0;
 }
 
-static void mv_postreset(struct ata_port *ap, unsigned int *classes)
+static void mv_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
         u32 serr;
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* clear SError */
-        sata_scr_read(ap, SCR_ERROR, &serr);
-        sata_scr_write_flush(ap, SCR_ERROR, serr);
+        sata_scr_read(link, SCR_ERROR, &serr);
+        sata_scr_write_flush(link, SCR_ERROR, serr);
 
         /* bail out if no device is present */
         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
@@ -2590,8 +2584,14 @@ static int mv_init_host(struct ata_host *host, unsigned int board_idx)
         }
 
         for (port = 0; port < host->n_ports; port++) {
+                struct ata_port *ap = host->ports[port];
                 void __iomem *port_mmio = mv_port_base(mmio, port);
-                mv_port_init(&host->ports[port]->ioaddr, port_mmio);
+                unsigned int offset = port_mmio - mmio;
+
+                mv_port_init(&ap->ioaddr, port_mmio);
+
+                ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
         }
 
         for (hc = 0; hc < n_hc; hc++) {
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 40dc731398..40557fe2ff 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -340,7 +340,6 @@ static struct scsi_host_template nv_adma_sht = {
 };
 
 static const struct ata_port_operations nv_generic_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -359,14 +358,12 @@ static const struct ata_port_operations nv_generic_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations nv_nf2_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -385,14 +382,12 @@ static const struct ata_port_operations nv_nf2_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations nv_ck804_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -411,7 +406,6 @@ static const struct ata_port_operations nv_ck804_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
@@ -419,7 +413,6 @@ static const struct ata_port_operations nv_ck804_ops = {
 };
 
 static const struct ata_port_operations nv_adma_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = nv_adma_tf_read,
         .check_atapi_dma        = nv_adma_check_atapi_dma,
@@ -430,6 +423,7 @@ static const struct ata_port_operations nv_adma_ops = {
         .bmdma_start            = ata_bmdma_start,
         .bmdma_stop             = ata_bmdma_stop,
         .bmdma_status           = ata_bmdma_status,
+        .qc_defer               = ata_std_qc_defer,
         .qc_prep                = nv_adma_qc_prep,
         .qc_issue               = nv_adma_qc_issue,
         .freeze                 = nv_adma_freeze,
@@ -439,7 +433,6 @@ static const struct ata_port_operations nv_adma_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = nv_adma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = nv_adma_port_start,
@@ -455,8 +448,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* generic */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -466,8 +459,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* nforce2/3 */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -477,8 +470,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* ck804 */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -489,8 +482,8 @@ static const struct ata_port_info nv_port_info[] = {
         {
                 .sht            = &nv_adma_sht,
                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME |
                                   ATA_FLAG_MMIO | ATA_FLAG_NCQ,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -594,7 +587,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
                 /* Not a proper libata device, ignore */
                 return rc;
 
-        if (ap->device[sdev->id].class == ATA_DEV_ATAPI) {
+        if (ap->link.device[sdev->id].class == ATA_DEV_ATAPI) {
                 /*
                  * NVIDIA reports that ADMA mode does not support ATAPI commands.
                  * Therefore ATAPI commands are sent through the legacy interface.
@@ -711,7 +704,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                      flags & (NV_CPB_RESP_ATA_ERR |
                               NV_CPB_RESP_CMD_ERR |
                               NV_CPB_RESP_CPB_ERR)))) {
-                struct ata_eh_info *ehi = &ap->eh_info;
+                struct ata_eh_info *ehi = &ap->link.eh_info;
                 int freeze = 0;
 
                 ata_ehi_clear_desc(ehi);
@@ -747,7 +740,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                         DPRINTK("Completing qc from tag %d\n",cpb_num);
                         ata_qc_complete(qc);
                 } else {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         /* Notifier bits set without a command may indicate the drive
                            is misbehaving. Raise host state machine violation on this
                            condition. */
@@ -764,7 +757,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
 
 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
 {
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
 
         /* freeze if hotplugged */
         if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
@@ -817,7 +810,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
                                 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
                                         >> (NV_INT_PORT_SHIFT * i);
-                                if(ata_tag_valid(ap->active_tag))
+                                if(ata_tag_valid(ap->link.active_tag))
                                         /** NV_INT_DEV indication seems unreliable at times
                                             at least in ADMA mode. Force it on always when a
                                             command is active, to prevent losing interrupts. */
@@ -852,7 +845,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                                NV_ADMA_STAT_HOTUNPLUG |
                                                NV_ADMA_STAT_TIMEOUT |
                                                NV_ADMA_STAT_SERROR))) {
-                                struct ata_eh_info *ehi = &ap->eh_info;
+                                struct ata_eh_info *ehi = &ap->link.eh_info;
 
                                 ata_ehi_clear_desc(ehi);
                                 __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status );
@@ -879,10 +872,10 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                 u32 check_commands;
                                 int pos, error = 0;
 
-                                if(ata_tag_valid(ap->active_tag))
-                                        check_commands = 1 << ap->active_tag;
+                                if(ata_tag_valid(ap->link.active_tag))
+                                        check_commands = 1 << ap->link.active_tag;
                                 else
-                                        check_commands = ap->sactive;
+                                        check_commands = ap->link.sactive;
 
                                 /** Check CPBs for completed commands */
                                 while ((pos = ffs(check_commands)) && !error) {
@@ -1333,7 +1326,7 @@ static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += ata_host_intr(ap, qc);
                         else
@@ -1459,7 +1452,7 @@ static void nv_ck804_thaw(struct ata_port *ap)
         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
 }
 
-static int nv_hardreset(struct ata_port *ap, unsigned int *class,
+static int nv_hardreset(struct ata_link *link, unsigned int *class,
                         unsigned long deadline)
 {
         unsigned int dummy;
@@ -1468,7 +1461,7 @@ static int nv_hardreset(struct ata_port *ap, unsigned int *class,
          * some controllers.  Don't classify on hardreset.  For more
          * info, see http://bugme.osdl.org/show_bug.cgi?id=3352
          */
-        return sata_std_hardreset(ap, &dummy, deadline);
+        return sata_std_hardreset(link, &dummy, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)
@@ -1485,7 +1478,7 @@ static void nv_adma_error_handler(struct ata_port *ap)
                 int i;
                 u16 tmp;
 
-                if(ata_tag_valid(ap->active_tag) || ap->sactive) {
+                if(ata_tag_valid(ap->link.active_tag) || ap->link.sactive) {
                         u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
                         u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
                         u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
@@ -1501,8 +1494,8 @@ static void nv_adma_error_handler(struct ata_port *ap)
 
                         for( i=0;i<NV_ADMA_MAX_CPBS;i++) {
                                 struct nv_adma_cpb *cpb = &pp->cpb[i];
-                                if( (ata_tag_valid(ap->active_tag) && i == ap->active_tag) ||
-                                    ap->sactive & (1 << i) )
+                                if( (ata_tag_valid(ap->link.active_tag) && i == ap->link.active_tag) ||
+                                    ap->link.sactive & (1 << i) )
                                         ata_port_printk(ap, KERN_ERR,
                                                 "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
                                                 i, cpb->ctl_flags, cpb->resp_flags);
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 25698cf0dc..903213153b 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -167,7 +167,6 @@ static struct scsi_host_template pdc_ata_sht = {
 };
 
 static const struct ata_port_operations pdc_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -185,7 +184,6 @@ static const struct ata_port_operations pdc_sata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = pdc_sata_scr_read,
         .scr_write              = pdc_sata_scr_write,
@@ -194,7 +192,6 @@ static const struct ata_port_operations pdc_sata_ops = {
 
 /* First-generation chips need a more restrictive ->check_atapi_dma op */
 static const struct ata_port_operations pdc_old_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -212,7 +209,6 @@ static const struct ata_port_operations pdc_old_sata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = pdc_sata_scr_read,
         .scr_write              = pdc_sata_scr_write,
@@ -220,7 +216,6 @@ static const struct ata_port_operations pdc_old_sata_ops = {
 };
 
 static const struct ata_port_operations pdc_pata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -238,7 +233,6 @@ static const struct ata_port_operations pdc_pata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = pdc_common_port_start,
 };
@@ -475,7 +469,7 @@ static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
         buf32[2] = 0;                           /* no next-packet */
 
         /* select drive */
-        if (sata_scr_valid(ap)) {
+        if (sata_scr_valid(&ap->link)) {
                 dev_sel = PDC_DEVICE_SATA;
         } else {
                 dev_sel = ATA_DEVICE_OBS;
@@ -626,7 +620,7 @@ static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
 static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
                            u32 port_status, u32 err_mask)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         unsigned int ac_err_mask = 0;
 
         ata_ehi_clear_desc(ehi);
@@ -643,7 +637,7 @@ static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
                            | PDC_PCI_SYS_ERR | PDC1_PCI_PARITY_ERR))
                 ac_err_mask |= AC_ERR_HOST_BUS;
 
-        if (sata_scr_valid(ap)) {
+        if (sata_scr_valid(&ap->link)) {
                 u32 serror;
 
                 pdc_sata_scr_read(ap, SCR_ERROR, &serror);
@@ -773,7 +767,7 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
                 tmp = hotplug_status & (0x11 << ata_no);
                 if (tmp && ap &&
                     !(ap->flags & ATA_FLAG_DISABLED)) {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         ata_ehi_clear_desc(ehi);
                         ata_ehi_hotplugged(ehi);
                         ata_ehi_push_desc(ehi, "hotplug_status %#x", tmp);
@@ -788,7 +782,7 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += pdc_host_intr(ap, qc);
                 }
@@ -1009,10 +1003,15 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 
         is_sataii_tx4 = pdc_is_sataii_tx4(pi->flags);
         for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
                 unsigned int ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
-                pdc_ata_setup_port(host->ports[i],
-                                   base + 0x200 + ata_no * 0x80,
-                                   base + 0x400 + ata_no * 0x100);
+                unsigned int port_offset = 0x200 + ata_no * 0x80;
+                unsigned int scr_offset = 0x400 + ata_no * 0x100;
+
+                pdc_ata_setup_port(ap, base + port_offset, base + scr_offset);
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, port_offset, "port");
         }
 
         /* initialize adapter */
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index 5e1dfdda69..c4c4cd29ee 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -145,7 +145,6 @@ static struct scsi_host_template qs_ata_sht = {
 };
 
 static const struct ata_port_operations qs_ata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -159,7 +158,6 @@ static const struct ata_port_operations qs_ata_ops = {
         .eng_timeout            = qs_eng_timeout,
         .irq_clear              = qs_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = qs_scr_read,
         .scr_write              = qs_scr_write,
         .port_start             = qs_port_start,
@@ -404,7 +402,7 @@ static inline unsigned int qs_intr_pkt(struct ata_host *host)
                                 struct qs_port_priv *pp = ap->private_data;
                                 if (!pp || pp->state != qs_state_pkt)
                                         continue;
-                                qc = ata_qc_from_tag(ap, ap->active_tag);
+                                qc = ata_qc_from_tag(ap, ap->link.active_tag);
                                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
                                         switch (sHST) {
                                         case 0: /* successful CPB */
@@ -437,7 +435,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
                         struct qs_port_priv *pp = ap->private_data;
                         if (!pp || pp->state != qs_state_mmio)
                                 continue;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
 
                                 /* check main status, clearing INTRQ */
@@ -637,9 +635,14 @@ static int qs_ata_init_one(struct pci_dev *pdev,
                 return rc;
 
         for (port_no = 0; port_no < host->n_ports; ++port_no) {
-                void __iomem *chan =
-                        host->iomap[QS_MMIO_BAR] + (port_no * 0x4000);
-                qs_ata_setup_port(&host->ports[port_no]->ioaddr, chan);
+                struct ata_port *ap = host->ports[port_no];
+                unsigned int offset = port_no * 0x4000;
+                void __iomem *chan = host->iomap[QS_MMIO_BAR] + offset;
+
+                qs_ata_setup_port(&ap->ioaddr, chan);
+
+                ata_port_pbar_desc(ap, QS_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, QS_MMIO_BAR, offset, "port");
         }
 
         /* initialize adapter */
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 8c72e714b4..ea3a0ab7e0 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -59,7 +59,8 @@ enum {
         SIL_FLAG_MOD15WRITE     = (1 << 30),
 
         SIL_DFL_PORT_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_HRST_TO_RESUME,
+                                  ATA_FLAG_MMIO,
+        SIL_DFL_LINK_FLAGS      = ATA_LFLAG_HRST_TO_RESUME,
 
         /*
          * Controller IDs
@@ -117,7 +118,7 @@ static int sil_pci_device_resume(struct pci_dev *pdev);
 static void sil_dev_config(struct ata_device *dev);
 static int sil_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
 static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
-static int sil_set_mode (struct ata_port *ap, struct ata_device **r_failed);
+static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed);
 static void sil_freeze(struct ata_port *ap);
 static void sil_thaw(struct ata_port *ap);
 
@@ -185,7 +186,6 @@ static struct scsi_host_template sil_sht = {
 };
 
 static const struct ata_port_operations sil_ops = {
-        .port_disable           = ata_port_disable,
         .dev_config             = sil_dev_config,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -206,7 +206,6 @@ static const struct ata_port_operations sil_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = sil_scr_read,
         .scr_write              = sil_scr_write,
         .port_start             = ata_port_start,
@@ -216,6 +215,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3112 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -225,6 +225,7 @@ static const struct ata_port_info sil_port_info[] = {
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE |
                                   SIL_FLAG_NO_SATA_IRQ,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -233,6 +234,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3512 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -241,6 +243,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3114 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -290,35 +293,33 @@ static unsigned char sil_get_device_cache_line(struct pci_dev *pdev)
 
 /**
  *      sil_set_mode            -       wrap set_mode functions
- *      @ap: port to set up
+ *      @link: link to set up
  *      @r_failed: returned device when we fail
  *
  *      Wrap the libata method for device setup as after the setup we need
  *      to inspect the results and do some configuration work
  */
 
-static int sil_set_mode (struct ata_port *ap, struct ata_device **r_failed)
+static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
-        struct ata_host *host = ap->host;
-        struct ata_device *dev;
-        void __iomem *mmio_base = host->iomap[SIL_MMIO_BAR];
+        struct ata_port *ap = link->ap;
+        void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR];
         void __iomem *addr = mmio_base + sil_port[ap->port_no].xfer_mode;
-        u32 tmp, dev_mode[2];
-        unsigned int i;
+        struct ata_device *dev;
+        u32 tmp, dev_mode[2] = { };
         int rc;
 
-        rc = ata_do_set_mode(ap, r_failed);
+        rc = ata_do_set_mode(link, r_failed);
         if (rc)
                 return rc;
 
-        for (i = 0; i < 2; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev))
-                        dev_mode[i] = 0;        /* PIO0/1/2 */
+                        dev_mode[dev->devno] = 0;       /* PIO0/1/2 */
                 else if (dev->flags & ATA_DFLAG_PIO)
-                        dev_mode[i] = 1;        /* PIO3/4 */
+                        dev_mode[dev->devno] = 1;       /* PIO3/4 */
                 else
-                        dev_mode[i] = 3;        /* UDMA */
+                        dev_mode[dev->devno] = 3;       /* UDMA */
                 /* value 2 indicates MDMA */
         }
 
@@ -374,8 +375,8 @@ static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
         u8 status;
 
         if (unlikely(bmdma2 & SIL_DMA_SATA_IRQ)) {
@@ -394,8 +395,8 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
                  * repeat probing needlessly.
                  */
                 if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
-                        ata_ehi_hotplugged(&ap->eh_info);
-                        ap->eh_info.serror |= serror;
+                        ata_ehi_hotplugged(&ap->link.eh_info);
+                        ap->link.eh_info.serror |= serror;
                 }
 
                 goto freeze;
@@ -562,8 +563,8 @@ static void sil_thaw(struct ata_port *ap)
  */
 static void sil_dev_config(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        int print_info = ap->eh_context.i.flags & ATA_EHI_PRINTINFO;
+        struct ata_port *ap = dev->link->ap;
+        int print_info = ap->link.eh_context.i.flags & ATA_EHI_PRINTINFO;
         unsigned int n, quirks = 0;
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
 
@@ -686,7 +687,8 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         mmio_base = host->iomap[SIL_MMIO_BAR];
 
         for (i = 0; i < host->n_ports; i++) {
-                struct ata_ioports *ioaddr = &host->ports[i]->ioaddr;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *ioaddr = &ap->ioaddr;
 
                 ioaddr->cmd_addr = mmio_base + sil_port[i].tf;
                 ioaddr->altstatus_addr =
@@ -694,6 +696,9 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 ioaddr->bmdma_addr = mmio_base + sil_port[i].bmdma;
                 ioaddr->scr_addr = mmio_base + sil_port[i].scr;
                 ata_std_ports(ioaddr);
+
+                ata_port_pbar_desc(ap, SIL_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, SIL_MMIO_BAR, sil_port[i].tf, "tf");
         }
 
         /* initialize and activate */
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 233e886933..b061927845 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -30,7 +30,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "sata_sil24"
-#define DRV_VERSION     "1.0"
+#define DRV_VERSION     "1.1"
 
 /*
  * Port request block (PRB) 32 bytes
@@ -168,7 +168,7 @@ enum {
 
         DEF_PORT_IRQ            = PORT_IRQ_COMPLETE | PORT_IRQ_ERROR |
                                   PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG |
-                                  PORT_IRQ_UNK_FIS,
+                                  PORT_IRQ_UNK_FIS | PORT_IRQ_SDB_NOTIFY,
 
         /* bits[27:16] are unmasked (raw) */
         PORT_IRQ_RAW_SHIFT      = 16,
@@ -237,8 +237,9 @@ enum {
         /* host flags */
         SIL24_COMMON_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                   ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                  ATA_FLAG_NCQ | ATA_FLAG_SKIP_D2H_BSY |
-                                  ATA_FLAG_ACPI_SATA,
+                                  ATA_FLAG_NCQ | ATA_FLAG_ACPI_SATA |
+                                  ATA_FLAG_AN | ATA_FLAG_PMP,
+        SIL24_COMMON_LFLAGS     = ATA_LFLAG_SKIP_D2H_BSY,
         SIL24_FLAG_PCIX_IRQ_WOC = (1 << 24), /* IRQ loss errata on PCI-X */
 
         IRQ_STAT_4PORTS         = 0xf,
@@ -322,6 +323,7 @@ struct sil24_port_priv {
         union sil24_cmd_block *cmd_block;       /* 32 cmd blocks */
         dma_addr_t cmd_block_dma;               /* DMA base addr for them */
         struct ata_taskfile tf;                 /* Cached taskfile registers */
+        int do_port_rst;
 };
 
 static void sil24_dev_config(struct ata_device *dev);
@@ -329,9 +331,12 @@ static u8 sil24_check_status(struct ata_port *ap);
 static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val);
 static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
+static int sil24_qc_defer(struct ata_queued_cmd *qc);
 static void sil24_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
 static void sil24_irq_clear(struct ata_port *ap);
+static void sil24_pmp_attach(struct ata_port *ap);
+static void sil24_pmp_detach(struct ata_port *ap);
 static void sil24_freeze(struct ata_port *ap);
 static void sil24_thaw(struct ata_port *ap);
 static void sil24_error_handler(struct ata_port *ap);
@@ -340,6 +345,7 @@ static int sil24_port_start(struct ata_port *ap);
 static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 #ifdef CONFIG_PM
 static int sil24_pci_device_resume(struct pci_dev *pdev);
+static int sil24_port_resume(struct ata_port *ap);
 #endif
 
 static const struct pci_device_id sil24_pci_tbl[] = {
@@ -384,8 +390,6 @@ static struct scsi_host_template sil24_sht = {
 };
 
 static const struct ata_port_operations sil24_ops = {
-        .port_disable           = ata_port_disable,
-
         .dev_config             = sil24_dev_config,
 
         .check_status           = sil24_check_status,
@@ -394,22 +398,28 @@ static const struct ata_port_operations sil24_ops = {
 
         .tf_read                = sil24_tf_read,
 
+        .qc_defer               = sil24_qc_defer,
         .qc_prep                = sil24_qc_prep,
         .qc_issue               = sil24_qc_issue,
 
         .irq_clear              = sil24_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = sil24_scr_read,
         .scr_write              = sil24_scr_write,
 
+        .pmp_attach             = sil24_pmp_attach,
+        .pmp_detach             = sil24_pmp_detach,
+
         .freeze                 = sil24_freeze,
         .thaw                   = sil24_thaw,
         .error_handler          = sil24_error_handler,
         .post_internal_cmd      = sil24_post_internal_cmd,
 
         .port_start             = sil24_port_start,
+
+#ifdef CONFIG_PM
+        .port_resume            = sil24_port_resume,
+#endif
 };
 
 /*
@@ -424,6 +434,7 @@ static const struct ata_port_info sil24_port_info[] = {
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(4) |
                                   SIL24_FLAG_PCIX_IRQ_WOC,
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -432,6 +443,7 @@ static const struct ata_port_info sil24_port_info[] = {
         /* sil_3132 */
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(2),
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -440,6 +452,7 @@ static const struct ata_port_info sil24_port_info[] = {
         /* sil_3131/sil_3531 */
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(1),
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -456,7 +469,7 @@ static int sil24_tag(int tag)
 
 static void sil24_dev_config(struct ata_device *dev)
 {
-        void __iomem *port = dev->ap->ioaddr.cmd_addr;
+        void __iomem *port = dev->link->ap->ioaddr.cmd_addr;
 
         if (dev->cdb_len == 16)
                 writel(PORT_CS_CDB16, port + PORT_CTRL_STAT);
@@ -520,19 +533,78 @@ static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
         *tf = pp->tf;
 }
 
+static void sil24_config_port(struct ata_port *ap)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+
+        /* configure IRQ WoC */
+        if (ap->flags & SIL24_FLAG_PCIX_IRQ_WOC)
+                writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_STAT);
+        else
+                writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
+
+        /* zero error counters. */
+        writel(0x8000, port + PORT_DECODE_ERR_THRESH);
+        writel(0x8000, port + PORT_CRC_ERR_THRESH);
+        writel(0x8000, port + PORT_HSHK_ERR_THRESH);
+        writel(0x0000, port + PORT_DECODE_ERR_CNT);
+        writel(0x0000, port + PORT_CRC_ERR_CNT);
+        writel(0x0000, port + PORT_HSHK_ERR_CNT);
+
+        /* always use 64bit activation */
+        writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
+
+        /* clear port multiplier enable and resume bits */
+        writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
+}
+
+static void sil24_config_pmp(struct ata_port *ap, int attached)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+
+        if (attached)
+                writel(PORT_CS_PMP_EN, port + PORT_CTRL_STAT);
+        else
+                writel(PORT_CS_PMP_EN, port + PORT_CTRL_CLR);
+}
+
+static void sil24_clear_pmp(struct ata_port *ap)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+        int i;
+
+        writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
+
+        for (i = 0; i < SATA_PMP_MAX_PORTS; i++) {
+                void __iomem *pmp_base = port + PORT_PMP + i * PORT_PMP_SIZE;
+
+                writel(0, pmp_base + PORT_PMP_STATUS);
+                writel(0, pmp_base + PORT_PMP_QACTIVE);
+        }
+}
+
 static int sil24_init_port(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
         u32 tmp;
 
+        /* clear PMP error status */
+        if (ap->nr_pmp_links)
+                sil24_clear_pmp(ap);
+
         writel(PORT_CS_INIT, port + PORT_CTRL_STAT);
         ata_wait_register(port + PORT_CTRL_STAT,
                           PORT_CS_INIT, PORT_CS_INIT, 10, 100);
         tmp = ata_wait_register(port + PORT_CTRL_STAT,
                                 PORT_CS_RDY, 0, 10, 100);
 
-        if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY)
+        if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY) {
+                pp->do_port_rst = 1;
+                ap->link.eh_context.i.action |= ATA_EH_HARDRESET;
                 return -EIO;
+        }
+
         return 0;
 }
 
@@ -583,9 +655,10 @@ static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
         return rc;
 }
 
-static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_do_softreset(struct ata_link *link, unsigned int *class,
                               int pmp, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned long timeout_msec = 0;
         struct ata_taskfile tf;
         const char *reason;
@@ -593,7 +666,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 DPRINTK("PHY reports no device\n");
                 *class = ATA_DEV_NONE;
                 goto out;
@@ -609,7 +682,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
         if (time_after(deadline, jiffies))
                 timeout_msec = jiffies_to_msecs(deadline - jiffies);
 
-        ata_tf_init(ap->device, &tf);   /* doesn't really matter */
+        ata_tf_init(link->device, &tf); /* doesn't really matter */
         rc = sil24_exec_polled_cmd(ap, pmp, &tf, 0, PRB_CTRL_SRST,
                                    timeout_msec);
         if (rc == -EBUSY) {
@@ -631,29 +704,54 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
         return 0;
 
  err:
-        ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+        ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
         return -EIO;
 }
 
-static int sil24_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_softreset(struct ata_link *link, unsigned int *class,
                            unsigned long deadline)
 {
-        return sil24_do_softreset(ap, class, 0, deadline);
+        return sil24_do_softreset(link, class, SATA_PMP_CTRL_PORT, deadline);
 }
 
-static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
+static int sil24_hardreset(struct ata_link *link, unsigned int *class,
                            unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port = ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
+        int did_port_rst = 0;
         const char *reason;
         int tout_msec, rc;
         u32 tmp;
 
+ retry:
+        /* Sometimes, DEV_RST is not enough to recover the controller.
+         * This happens often after PM DMA CS errata.
+         */
+        if (pp->do_port_rst) {
+                ata_port_printk(ap, KERN_WARNING, "controller in dubious "
+                                "state, performing PORT_RST\n");
+
+                writel(PORT_CS_PORT_RST, port + PORT_CTRL_STAT);
+                msleep(10);
+                writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
+                ata_wait_register(port + PORT_CTRL_STAT, PORT_CS_RDY, 0,
+                                  10, 5000);
+
+                /* restore port configuration */
+                sil24_config_port(ap);
+                sil24_config_pmp(ap, ap->nr_pmp_links);
+
+                pp->do_port_rst = 0;
+                did_port_rst = 1;
+        }
+
         /* sil24 does the right thing(tm) without any protection */
-        sata_set_spd(ap);
+        sata_set_spd(link);
 
         tout_msec = 100;
-        if (ata_port_online(ap))
+        if (ata_link_online(link))
                 tout_msec = 5000;
 
         writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
@@ -663,14 +761,14 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
         /* SStatus oscillates between zero and valid status after
          * DEV_RST, debounce it.
          */
-        rc = sata_phy_debounce(ap, sata_deb_timing_long, deadline);
+        rc = sata_link_debounce(link, sata_deb_timing_long, deadline);
         if (rc) {
                 reason = "PHY debouncing failed";
                 goto err;
         }
 
         if (tmp & PORT_CS_DEV_RST) {
-                if (ata_port_offline(ap))
+                if (ata_link_offline(link))
                         return 0;
                 reason = "link not ready";
                 goto err;
@@ -685,7 +783,12 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
         return -EAGAIN;
 
  err:
-        ata_port_printk(ap, KERN_ERR, "hardreset failed (%s)\n", reason);
+        if (!did_port_rst) {
+                pp->do_port_rst = 1;
+                goto retry;
+        }
+
+        ata_link_printk(link, KERN_ERR, "hardreset failed (%s)\n", reason);
         return -EIO;
 }
 
@@ -705,6 +808,38 @@ static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
         }
 }
 
+static int sil24_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+        struct ata_port *ap = link->ap;
+        u8 prot = qc->tf.protocol;
+        int is_atapi = (prot == ATA_PROT_ATAPI ||
+                        prot == ATA_PROT_ATAPI_NODATA ||
+                        prot == ATA_PROT_ATAPI_DMA);
+
+        /* ATAPI commands completing with CHECK_SENSE cause various
+         * weird problems if other commands are active.  PMP DMA CS
+         * errata doesn't cover all and HSM violation occurs even with
+         * only one other device active.  Always run an ATAPI command
+         * by itself.
+         */
+        if (unlikely(ap->excl_link)) {
+                if (link == ap->excl_link) {
+                        if (ap->nr_active_links)
+                                return ATA_DEFER_PORT;
+                        qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+                } else
+                        return ATA_DEFER_PORT;
+        } else if (unlikely(is_atapi)) {
+                ap->excl_link = link;
+                if (ap->nr_active_links)
+                        return ATA_DEFER_PORT;
+                qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+        }
+
+        return ata_std_qc_defer(qc);
+}
+
 static void sil24_qc_prep(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
@@ -748,7 +883,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
         }
 
         prb->ctrl = cpu_to_le16(ctrl);
-        ata_tf_to_fis(&qc->tf, 0, 1, prb->fis);
+        ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, prb->fis);
 
         if (qc->flags & ATA_QCFLAG_DMAMAP)
                 sil24_fill_sg(qc, sge);
@@ -777,6 +912,39 @@ static void sil24_irq_clear(struct ata_port *ap)
         /* unused */
 }
 
+static void sil24_pmp_attach(struct ata_port *ap)
+{
+        sil24_config_pmp(ap, 1);
+        sil24_init_port(ap);
+}
+
+static void sil24_pmp_detach(struct ata_port *ap)
+{
+        sil24_init_port(ap);
+        sil24_config_pmp(ap, 0);
+}
+
+static int sil24_pmp_softreset(struct ata_link *link, unsigned int *class,
+                               unsigned long deadline)
+{
+        return sil24_do_softreset(link, class, link->pmp, deadline);
+}
+
+static int sil24_pmp_hardreset(struct ata_link *link, unsigned int *class,
+                               unsigned long deadline)
+{
+        int rc;
+
+        rc = sil24_init_port(link->ap);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "hardreset failed (port not ready)\n");
+                return rc;
+        }
+
+        return sata_pmp_std_hardreset(link, class, deadline);
+}
+
 static void sil24_freeze(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
@@ -804,8 +972,10 @@ static void sil24_error_intr(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
         struct sil24_port_priv *pp = ap->private_data;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        int freeze = 0;
+        struct ata_queued_cmd *qc = NULL;
+        struct ata_link *link;
+        struct ata_eh_info *ehi;
+        int abort = 0, freeze = 0;
         u32 irq_stat;
 
         /* on error, we need to clear IRQ explicitly */
@@ -813,10 +983,17 @@ static void sil24_error_intr(struct ata_port *ap)
         writel(irq_stat, port + PORT_IRQ_STAT);
 
         /* first, analyze and record host port events */
+        link = &ap->link;
+        ehi = &link->eh_info;
         ata_ehi_clear_desc(ehi);
 
         ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
 
+        if (irq_stat & PORT_IRQ_SDB_NOTIFY) {
+                ata_ehi_push_desc(ehi, "SDB notify");
+                sata_async_notification(ap);
+        }
+
         if (irq_stat & (PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG)) {
                 ata_ehi_hotplugged(ehi);
                 ata_ehi_push_desc(ehi, "%s",
@@ -836,8 +1013,44 @@ static void sil24_error_intr(struct ata_port *ap)
         if (irq_stat & PORT_IRQ_ERROR) {
                 struct sil24_cerr_info *ci = NULL;
                 unsigned int err_mask = 0, action = 0;
-                struct ata_queued_cmd *qc;
-                u32 cerr;
+                u32 context, cerr;
+                int pmp;
+
+                abort = 1;
+
+                /* DMA Context Switch Failure in Port Multiplier Mode
+                 * errata.  If we have active commands to 3 or more
+                 * devices, any error condition on active devices can
+                 * corrupt DMA context switching.
+                 */
+                if (ap->nr_active_links >= 3) {
+                        ehi->err_mask |= AC_ERR_OTHER;
+                        ehi->action |= ATA_EH_HARDRESET;
+                        ata_ehi_push_desc(ehi, "PMP DMA CS errata");
+                        pp->do_port_rst = 1;
+                        freeze = 1;
+                }
+
+                /* find out the offending link and qc */
+                if (ap->nr_pmp_links) {
+                        context = readl(port + PORT_CONTEXT);
+                        pmp = (context >> 5) & 0xf;
+
+                        if (pmp < ap->nr_pmp_links) {
+                                link = &ap->pmp_link[pmp];
+                                ehi = &link->eh_info;
+                                qc = ata_qc_from_tag(ap, link->active_tag);
+
+                                ata_ehi_clear_desc(ehi);
+                                ata_ehi_push_desc(ehi, "irq_stat 0x%08x",
+                                                  irq_stat);
+                        } else {
+                                err_mask |= AC_ERR_HSM;
+                                action |= ATA_EH_HARDRESET;
+                                freeze = 1;
+                        }
+                } else
+                        qc = ata_qc_from_tag(ap, link->active_tag);
 
                 /* analyze CMD_ERR */
                 cerr = readl(port + PORT_CMD_ERR);
@@ -856,7 +1069,6 @@ static void sil24_error_intr(struct ata_port *ap)
                 }
 
                 /* record error info */
-                qc = ata_qc_from_tag(ap, ap->active_tag);
                 if (qc) {
                         sil24_read_tf(ap, qc->tag, &pp->tf);
                         qc->err_mask |= err_mask;
@@ -864,13 +1076,21 @@ static void sil24_error_intr(struct ata_port *ap)
                         ehi->err_mask |= err_mask;
 
                 ehi->action |= action;
+
+                /* if PMP, resume */
+                if (ap->nr_pmp_links)
+                        writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_STAT);
         }
 
         /* freeze or abort */
         if (freeze)
                 ata_port_freeze(ap);
-        else
-                ata_port_abort(ap);
+        else if (abort) {
+                if (qc)
+                        ata_link_abort(qc->dev->link);
+                else
+                        ata_port_abort(ap);
+        }
 }
 
 static void sil24_finish_qc(struct ata_queued_cmd *qc)
@@ -910,7 +1130,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
         if (rc > 0)
                 return;
         if (rc < 0) {
-                struct ata_eh_info *ehi = &ap->eh_info;
+                struct ata_eh_info *ehi = &ap->link.eh_info;
                 ehi->err_mask |= AC_ERR_HSM;
                 ehi->action |= ATA_EH_SOFTRESET;
                 ata_port_freeze(ap);
@@ -921,7 +1141,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
         if (!(ap->flags & SIL24_FLAG_PCIX_IRQ_WOC) && ata_ratelimit())
                 ata_port_printk(ap, KERN_INFO, "spurious interrupt "
                         "(slot_stat 0x%x active_tag %d sactive 0x%x)\n",
-                        slot_stat, ap->active_tag, ap->sactive);
+                        slot_stat, ap->link.active_tag, ap->link.sactive);
 }
 
 static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
@@ -963,16 +1183,18 @@ static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
 
 static void sil24_error_handler(struct ata_port *ap)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct sil24_port_priv *pp = ap->private_data;
 
-        if (sil24_init_port(ap)) {
+        if (sil24_init_port(ap))
                 ata_eh_freeze_port(ap);
-                ehc->i.action |= ATA_EH_HARDRESET;
-        }
 
         /* perform recovery */
-        ata_do_eh(ap, ata_std_prereset, sil24_softreset, sil24_hardreset,
-                  ata_std_postreset);
+        sata_pmp_do_eh(ap, ata_std_prereset, sil24_softreset, sil24_hardreset,
+                       ata_std_postreset, sata_pmp_std_prereset,
+                       sil24_pmp_softreset, sil24_pmp_hardreset,
+                       sata_pmp_std_postreset);
+
+        pp->do_port_rst = 0;
 }
 
 static void sil24_post_internal_cmd(struct ata_queued_cmd *qc)
@@ -980,8 +1202,8 @@ static void sil24_post_internal_cmd(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
 
         /* make DMA engine forget about the failed command */
-        if (qc->flags & ATA_QCFLAG_FAILED)
-                sil24_init_port(ap);
+        if ((qc->flags & ATA_QCFLAG_FAILED) && sil24_init_port(ap))
+                ata_eh_freeze_port(ap);
 }
 
 static int sil24_port_start(struct ata_port *ap)
@@ -1019,7 +1241,6 @@ static int sil24_port_start(struct ata_port *ap)
 static void sil24_init_controller(struct ata_host *host)
 {
         void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
-        void __iomem *port_base = host->iomap[SIL24_PORT_BAR];
         u32 tmp;
         int i;
 
@@ -1031,7 +1252,8 @@ static void sil24_init_controller(struct ata_host *host)
 
         /* init ports */
         for (i = 0; i < host->n_ports; i++) {
-                void __iomem *port = port_base + i * PORT_REGS_SIZE;
+                struct ata_port *ap = host->ports[i];
+                void __iomem *port = ap->ioaddr.cmd_addr;
 
                 /* Initial PHY setting */
                 writel(0x20c, port + PORT_PHY_CFG);
@@ -1048,26 +1270,8 @@ static void sil24_init_controller(struct ata_host *host)
                                            "failed to clear port RST\n");
                 }
 
-                /* Configure IRQ WoC */
-                if (host->ports[0]->flags & SIL24_FLAG_PCIX_IRQ_WOC)
-                        writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_STAT);
-                else
-                        writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
-
-                /* Zero error counters. */
-                writel(0x8000, port + PORT_DECODE_ERR_THRESH);
-                writel(0x8000, port + PORT_CRC_ERR_THRESH);
-                writel(0x8000, port + PORT_HSHK_ERR_THRESH);
-                writel(0x0000, port + PORT_DECODE_ERR_CNT);
-                writel(0x0000, port + PORT_CRC_ERR_CNT);
-                writel(0x0000, port + PORT_HSHK_ERR_CNT);
-
-                /* Always use 64bit activation */
-                writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
-
-                /* Clear port multiplier enable and resume bits */
-                writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME,
-                       port + PORT_CTRL_CLR);
+                /* configure port */
+                sil24_config_port(ap);
         }
 
         /* Turn on interrupts */
@@ -1118,12 +1322,15 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         host->iomap = iomap;
 
         for (i = 0; i < host->n_ports; i++) {
-                void __iomem *port = iomap[SIL24_PORT_BAR] + i * PORT_REGS_SIZE;
+                struct ata_port *ap = host->ports[i];
+                size_t offset = ap->port_no * PORT_REGS_SIZE;
+                void __iomem *port = iomap[SIL24_PORT_BAR] + offset;
 
                 host->ports[i]->ioaddr.cmd_addr = port;
                 host->ports[i]->ioaddr.scr_addr = port + PORT_SCONTROL;
 
-                ata_std_ports(&host->ports[i]->ioaddr);
+                ata_port_pbar_desc(ap, SIL24_HOST_BAR, -1, "host");
+                ata_port_pbar_desc(ap, SIL24_PORT_BAR, offset, "port");
         }
 
         /* configure and activate the device */
@@ -1179,6 +1386,12 @@ static int sil24_pci_device_resume(struct pci_dev *pdev)
 
         return 0;
 }
+
+static int sil24_port_resume(struct ata_port *ap)
+{
+        sil24_config_pmp(ap, ap->nr_pmp_links);
+        return 0;
+}
 #endif
 
 static int __init sil24_init(void)
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 41c1d6e8f1..8d98a9fb0a 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -104,7 +104,6 @@ static struct scsi_host_template sis_sht = {
 };
 
 static const struct ata_port_operations sis_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -123,7 +122,6 @@ static const struct ata_port_operations sis_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = sis_scr_read,
         .scr_write              = sis_scr_write,
         .port_start             = ata_port_start,
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index d9678e7bc3..12d613c48c 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -329,7 +329,6 @@ static struct scsi_host_template k2_sata_sht = {
 
 
 static const struct ata_port_operations k2_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = k2_sata_tf_load,
         .tf_read                = k2_sata_tf_read,
         .check_status           = k2_stat_check_status,
@@ -349,7 +348,6 @@ static const struct ata_port_operations k2_sata_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = k2_sata_scr_read,
         .scr_write              = k2_sata_scr_write,
         .port_start             = ata_port_start,
@@ -445,9 +443,15 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         /* different controllers have different number of ports - currently 4 or 8 */
         /* All ports are on the same function. Multi-function device is no
          * longer available. This should not be seen in any system. */
-        for (i = 0; i < host->n_ports; i++)
-                k2_sata_setup_port(&host->ports[i]->ioaddr,
-                                   mmio_base + i * K2_SATA_PORT_OFFSET);
+        for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
+                unsigned int offset = i * K2_SATA_PORT_OFFSET;
+
+                k2_sata_setup_port(&ap->ioaddr, mmio_base + offset);
+
+                ata_port_pbar_desc(ap, 5, -1, "mmio");
+                ata_port_pbar_desc(ap, 5, offset, "port");
+        }
 
         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
         if (rc)
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 97aefdd87b..9f9f7b3065 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -254,7 +254,6 @@ static struct scsi_host_template pdc_sata_sht = {
 };
 
 static const struct ata_port_operations pdc_20621_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -267,7 +266,6 @@ static const struct ata_port_operations pdc_20621_ops = {
         .eng_timeout            = pdc_eng_timeout,
         .irq_clear              = pdc20621_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = pdc_port_start,
 };
 
@@ -854,7 +852,7 @@ static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += pdc20621_host_intr(ap, qc, (i > 4),
                                                               mmio_base);
@@ -881,7 +879,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
 
         spin_lock_irqsave(&host->lock, flags);
 
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
 
         switch (qc->tf.protocol) {
         case ATA_PROT_DMA:
@@ -1383,9 +1381,8 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         const struct ata_port_info *ppi[] =
                 { &pdc_port_info[ent->driver_data], NULL };
         struct ata_host *host;
-        void __iomem *base;
         struct pdc_host_priv *hpriv;
-        int rc;
+        int i, rc;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -1411,11 +1408,17 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
                 return rc;
         host->iomap = pcim_iomap_table(pdev);
 
-        base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
-        pdc_sata_setup_port(&host->ports[0]->ioaddr, base + 0x200);
-        pdc_sata_setup_port(&host->ports[1]->ioaddr, base + 0x280);
-        pdc_sata_setup_port(&host->ports[2]->ioaddr, base + 0x300);
-        pdc_sata_setup_port(&host->ports[3]->ioaddr, base + 0x380);
+        for (i = 0; i < 4; i++) {
+                struct ata_port *ap = host->ports[i];
+                void __iomem *base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
+                unsigned int offset = 0x200 + i * 0x80;
+
+                pdc_sata_setup_port(&ap->ioaddr, base + offset);
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_DIMM_BAR, -1, "dimm");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, offset, "port");
+        }
 
         /* configure and activate */
         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index e6b8b45279..d394da085a 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -94,8 +94,6 @@ static struct scsi_host_template uli_sht = {
 };
 
 static const struct ata_port_operations uli_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -117,7 +115,6 @@ static const struct ata_port_operations uli_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = uli_scr_read,
         .scr_write              = uli_scr_write,
@@ -242,6 +239,12 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 hpriv->scr_cfg_addr[2] = ULI5287_BASE + ULI5287_OFFS*4;
                 ata_std_ports(ioaddr);
 
+                ata_port_desc(host->ports[2],
+                        "cmd 0x%llx ctl 0x%llx bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 0) + 8,
+                        ((unsigned long long)pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS) + 4,
+                        (unsigned long long)pci_resource_start(pdev, 4) + 16);
+
                 ioaddr = &host->ports[3]->ioaddr;
                 ioaddr->cmd_addr = iomap[2] + 8;
                 ioaddr->altstatus_addr =
@@ -250,6 +253,13 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 ioaddr->bmdma_addr = iomap[4] + 24;
                 hpriv->scr_cfg_addr[3] = ULI5287_BASE + ULI5287_OFFS*5;
                 ata_std_ports(ioaddr);
+
+                ata_port_desc(host->ports[2],
+                        "cmd 0x%llx ctl 0x%llx bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 2) + 9,
+                        ((unsigned long long)pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS) + 4,
+                        (unsigned long long)pci_resource_start(pdev, 4) + 24);
+
                 break;
 
         case uli_5289:
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 57fd30de8f..1dc9b4f2b2 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -57,7 +57,6 @@ enum {
         SATA_CHAN_ENAB          = 0x40, /* SATA channel enable */
         SATA_INT_GATE           = 0x41, /* SATA interrupt gating */
         SATA_NATIVE_MODE        = 0x42, /* Native mode enable */
-        SATA_PATA_SHARING       = 0x49, /* PATA/SATA sharing func ctrl */
         PATA_UDMA_TIMING        = 0xB3, /* PATA timing for DMA/ cable detect */
         PATA_PIO_TIMING         = 0xAB, /* PATA timing register */
 
@@ -68,7 +67,6 @@ enum {
         NATIVE_MODE_ALL         = (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
 
         SATA_EXT_PHY            = (1 << 6), /* 0==use PATA, 1==ext phy */
-        SATA_2DEV               = (1 << 5), /* SATA is master/slave */
 };
 
 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
@@ -122,8 +120,6 @@ static struct scsi_host_template svia_sht = {
 };
 
 static const struct ata_port_operations vt6420_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -146,14 +142,11 @@ static const struct ata_port_operations vt6420_sata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations vt6421_pata_ops = {
-        .port_disable           = ata_port_disable,
-
         .set_piomode            = vt6421_set_pio_mode,
         .set_dmamode            = vt6421_set_dma_mode,
 
@@ -180,14 +173,11 @@ static const struct ata_port_operations vt6421_pata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations vt6421_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -211,7 +201,6 @@ static const struct ata_port_operations vt6421_sata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = svia_scr_read,
         .scr_write              = svia_scr_write,
@@ -276,7 +265,7 @@ static void svia_noop_freeze(struct ata_port *ap)
 
 /**
  *      vt6420_prereset - prereset for vt6420
- *      @ap: target ATA port
+ *      @link: target ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      SCR registers on vt6420 are pieces of shit and may hang the
@@ -294,9 +283,10 @@ static void svia_noop_freeze(struct ata_port *ap)
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-static int vt6420_prereset(struct ata_port *ap, unsigned long deadline)
+static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &ap->link.eh_context;
         unsigned long timeout = jiffies + (HZ * 5);
         u32 sstatus, scontrol;
         int online;
@@ -407,6 +397,9 @@ static void vt6421_init_addrs(struct ata_port *ap)
         ioaddr->scr_addr = vt6421_scr_addr(iomap[5], ap->port_no);
 
         ata_std_ports(ioaddr);
+
+        ata_port_pbar_desc(ap, ap->port_no, -1, "port");
+        ata_port_pbar_desc(ap, 4, ap->port_no * 8, "bmdma");
 }
 
 static int vt6420_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
@@ -513,7 +506,6 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         struct ata_host *host;
         int board_id = (int) ent->driver_data;
         const int *bar_sizes;
-        u8 tmp8;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -522,19 +514,10 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        if (board_id == vt6420) {
-                pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
-                if (tmp8 & SATA_2DEV) {
-                        dev_printk(KERN_ERR, &pdev->dev,
-                                   "SATA master/slave not supported (0x%x)\n",
-                                   (int) tmp8);
-                        return -EIO;
-                }
-
+        if (board_id == vt6420)
                 bar_sizes = &svia_bar_sizes[0];
-        } else {
+        else
                 bar_sizes = &vt6421_bar_sizes[0];
-        }
 
         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
                 if ((pci_resource_start(pdev, i) == 0) ||
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 1920915dfa..0d9be16848 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -240,7 +240,7 @@ static void vsc_port_intr(u8 port_status, struct ata_port *ap)
                 return;
         }
 
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc && likely(!(qc->tf.flags & ATA_TFLAG_POLLING)))
                 handled = ata_host_intr(ap, qc);
 
@@ -317,7 +317,6 @@ static struct scsi_host_template vsc_sata_sht = {
 
 
 static const struct ata_port_operations vsc_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = vsc_sata_tf_load,
         .tf_read                = vsc_sata_tf_read,
         .exec_command           = ata_exec_command,
@@ -336,7 +335,6 @@ static const struct ata_port_operations vsc_sata_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = vsc_sata_scr_read,
         .scr_write              = vsc_sata_scr_write,
         .port_start             = ata_port_start,
@@ -408,9 +406,15 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
 
         mmio_base = host->iomap[VSC_MMIO_BAR];
 
-        for (i = 0; i < host->n_ports; i++)
-                vsc_sata_setup_port(&host->ports[i]->ioaddr,
-                                    mmio_base + (i + 1) * VSC_SATA_PORT_OFFSET);
+        for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
+                unsigned int offset = (i + 1) * VSC_SATA_PORT_OFFSET;
+
+                vsc_sata_setup_port(&ap->ioaddr, mmio_base + offset);
+
+                ata_port_pbar_desc(ap, VSC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, VSC_MMIO_BAR, offset, "port");
+        }
 
         /*
          * Use 32 bit DMA mask, because 64 bit address support is poor.
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 5d6312e334..d7da109c24 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -1,5 +1,13 @@
 menu "Generic Driver Options"
 
+config UEVENT_HELPER_PATH
+        string "path to uevent helper"
+        depends on HOTPLUG
+        default "/sbin/hotplug"
+        help
+          Path to uevent helper program forked by the kernel for
+          every uevent.
+
 config STANDALONE
         bool "Select only drivers that don't need compile-time external firmware" if EXPERIMENTAL
         default y
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 47eb02d9f1..10b2fb6c9c 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -18,8 +18,6 @@ extern int attribute_container_init(void);
 extern int bus_add_device(struct device * dev);
 extern void bus_attach_device(struct device * dev);
 extern void bus_remove_device(struct device * dev);
-extern struct bus_type *get_bus(struct bus_type * bus);
-extern void put_bus(struct bus_type * bus);
 
 extern int bus_add_driver(struct device_driver *);
 extern void bus_remove_driver(struct device_driver *);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 61c67526a6..9a19b071c5 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -30,6 +30,17 @@
 static int __must_check bus_rescan_devices_helper(struct device *dev,
                                                 void *data);
 
+static struct bus_type *bus_get(struct bus_type *bus)
+{
+        return bus ? container_of(kset_get(&bus->subsys),
+                                struct bus_type, subsys) : NULL;
+}
+
+static void bus_put(struct bus_type *bus)
+{
+        kset_put(&bus->subsys);
+}
+
 static ssize_t
 drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 {
@@ -78,7 +89,7 @@ static void driver_release(struct kobject * kobj)
          */
 }
 
-static struct kobj_type ktype_driver = {
+static struct kobj_type driver_ktype = {
         .sysfs_ops      = &driver_sysfs_ops,
         .release        = driver_release,
 };
@@ -122,9 +133,9 @@ static struct sysfs_ops bus_sysfs_ops = {
 int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
 {
         int error;
-        if (get_bus(bus)) {
+        if (bus_get(bus)) {
                 error = sysfs_create_file(&bus->subsys.kobj, &attr->attr);
-                put_bus(bus);
+                bus_put(bus);
         } else
                 error = -EINVAL;
         return error;
@@ -132,9 +143,9 @@ int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
 
 void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
 {
-        if (get_bus(bus)) {
+        if (bus_get(bus)) {
                 sysfs_remove_file(&bus->subsys.kobj, &attr->attr);
-                put_bus(bus);
+                bus_put(bus);
         }
 }
 
@@ -172,7 +183,7 @@ static int driver_helper(struct device *dev, void *data)
 static ssize_t driver_unbind(struct device_driver *drv,
                              const char *buf, size_t count)
 {
-        struct bus_type *bus = get_bus(drv->bus);
+        struct bus_type *bus = bus_get(drv->bus);
         struct device *dev;
         int err = -ENODEV;
 
@@ -186,7 +197,7 @@ static ssize_t driver_unbind(struct device_driver *drv,
                 err = count;
         }
         put_device(dev);
-        put_bus(bus);
+        bus_put(bus);
         return err;
 }
 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
@@ -199,7 +210,7 @@ static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
 static ssize_t driver_bind(struct device_driver *drv,
                            const char *buf, size_t count)
 {
-        struct bus_type *bus = get_bus(drv->bus);
+        struct bus_type *bus = bus_get(drv->bus);
         struct device *dev;
         int err = -ENODEV;
 
@@ -219,7 +230,7 @@ static ssize_t driver_bind(struct device_driver *drv,
                         err = -ENODEV;
         }
         put_device(dev);
-        put_bus(bus);
+        bus_put(bus);
         return err;
 }
 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
@@ -430,7 +441,7 @@ static inline void remove_deprecated_bus_links(struct device *dev) { }
  */
 int bus_add_device(struct device * dev)
 {
-        struct bus_type * bus = get_bus(dev->bus);
+        struct bus_type * bus = bus_get(dev->bus);
         int error = 0;
 
         if (bus) {
@@ -459,7 +470,7 @@ out_subsys:
 out_id:
         device_remove_attrs(bus, dev);
 out_put:
-        put_bus(dev->bus);
+        bus_put(dev->bus);
         return error;
 }
 
@@ -509,7 +520,7 @@ void bus_remove_device(struct device * dev)
                 }
                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
                 device_release_driver(dev);
-                put_bus(dev->bus);
+                bus_put(dev->bus);
         }
 }
 
@@ -568,32 +579,29 @@ static void remove_bind_files(struct device_driver *drv)
         driver_remove_file(drv, &driver_attr_unbind);
 }
 
+static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
+static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
+                show_drivers_autoprobe, store_drivers_autoprobe);
+
 static int add_probe_files(struct bus_type *bus)
 {
         int retval;
 
-        bus->drivers_probe_attr.attr.name = "drivers_probe";
-        bus->drivers_probe_attr.attr.mode = S_IWUSR;
-        bus->drivers_probe_attr.store = store_drivers_probe;
-        retval = bus_create_file(bus, &bus->drivers_probe_attr);
+        retval = bus_create_file(bus, &bus_attr_drivers_probe);
         if (retval)
                 goto out;
 
-        bus->drivers_autoprobe_attr.attr.name = "drivers_autoprobe";
-        bus->drivers_autoprobe_attr.attr.mode = S_IWUSR | S_IRUGO;
-        bus->drivers_autoprobe_attr.show = show_drivers_autoprobe;
-        bus->drivers_autoprobe_attr.store = store_drivers_autoprobe;
-        retval = bus_create_file(bus, &bus->drivers_autoprobe_attr);
+        retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
         if (retval)
-                bus_remove_file(bus, &bus->drivers_probe_attr);
+                bus_remove_file(bus, &bus_attr_drivers_probe);
 out:
         return retval;
 }
 
 static void remove_probe_files(struct bus_type *bus)
 {
-        bus_remove_file(bus, &bus->drivers_autoprobe_attr);
-        bus_remove_file(bus, &bus->drivers_probe_attr);
+        bus_remove_file(bus, &bus_attr_drivers_autoprobe);
+        bus_remove_file(bus, &bus_attr_drivers_probe);
 }
 #else
 static inline int add_bind_files(struct device_driver *drv) { return 0; }
@@ -602,6 +610,17 @@ static inline int add_probe_files(struct bus_type *bus) { return 0; }
 static inline void remove_probe_files(struct bus_type *bus) {}
 #endif
 
+static ssize_t driver_uevent_store(struct device_driver *drv,
+                                   const char *buf, size_t count)
+{
+        enum kobject_action action;
+
+        if (kobject_action_type(buf, count, &action) == 0)
+                kobject_uevent(&drv->kobj, action);
+        return count;
+}
+static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
+
 /**
  *      bus_add_driver - Add a driver to the bus.
  *      @drv:   driver.
@@ -609,7 +628,7 @@ static inline void remove_probe_files(struct bus_type *bus) {}
  */
 int bus_add_driver(struct device_driver *drv)
 {
-        struct bus_type * bus = get_bus(drv->bus);
+        struct bus_type * bus = bus_get(drv->bus);
         int error = 0;
 
         if (!bus)
@@ -632,6 +651,11 @@ int bus_add_driver(struct device_driver *drv)
         klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
         module_add_driver(drv->owner, drv);
 
+        error = driver_create_file(drv, &driver_attr_uevent);
+        if (error) {
+                printk(KERN_ERR "%s: uevent attr (%s) failed\n",
+                        __FUNCTION__, drv->name);
+        }
         error = driver_add_attrs(bus, drv);
         if (error) {
                 /* How the hell do we get out of this pickle? Give up */
@@ -649,7 +673,7 @@ int bus_add_driver(struct device_driver *drv)
 out_unregister:
         kobject_unregister(&drv->kobj);
 out_put_bus:
-        put_bus(bus);
+        bus_put(bus);
         return error;
 }
 
@@ -669,12 +693,13 @@ void bus_remove_driver(struct device_driver * drv)
 
         remove_bind_files(drv);
         driver_remove_attrs(drv->bus, drv);
+        driver_remove_file(drv, &driver_attr_uevent);
         klist_remove(&drv->knode_bus);
         pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
         driver_detach(drv);
         module_remove_driver(drv);
         kobject_unregister(&drv->kobj);
-        put_bus(drv->bus);
+        bus_put(drv->bus);
 }
 
 
@@ -729,18 +754,6 @@ int device_reprobe(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(device_reprobe);
 
-struct bus_type *get_bus(struct bus_type *bus)
-{
-        return bus ? container_of(subsys_get(&bus->subsys),
-                                struct bus_type, subsys) : NULL;
-}
-
-void put_bus(struct bus_type * bus)
-{
-        subsys_put(&bus->subsys);
-}
-
-
 /**
  *      find_bus - locate bus by name.
  *      @name:  name of bus.
@@ -808,6 +821,17 @@ static void klist_devices_put(struct klist_node *n)
         put_device(dev);
 }
 
+static ssize_t bus_uevent_store(struct bus_type *bus,
+                                const char *buf, size_t count)
+{
+        enum kobject_action action;
+
+        if (kobject_action_type(buf, count, &action) == 0)
+                kobject_uevent(&bus->subsys.kobj, action);
+        return count;
+}
+static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
+
 /**
  *      bus_register - register a bus with the system.
  *      @bus:   bus.
@@ -826,11 +850,16 @@ int bus_register(struct bus_type * bus)
         if (retval)
                 goto out;
 
-        subsys_set_kset(bus, bus_subsys);
+        bus->subsys.kobj.kset = &bus_subsys;
+
         retval = subsystem_register(&bus->subsys);
         if (retval)
                 goto out;
 
+        retval = bus_create_file(bus, &bus_attr_uevent);
+        if (retval)
+                goto bus_uevent_fail;
+
         kobject_set_name(&bus->devices.kobj, "devices");
         bus->devices.kobj.parent = &bus->subsys.kobj;
         retval = kset_register(&bus->devices);
@@ -839,7 +868,7 @@ int bus_register(struct bus_type * bus)
 
         kobject_set_name(&bus->drivers.kobj, "drivers");
         bus->drivers.kobj.parent = &bus->subsys.kobj;
-        bus->drivers.ktype = &ktype_driver;
+        bus->drivers.ktype = &driver_ktype;
         retval = kset_register(&bus->drivers);
         if (retval)
                 goto bus_drivers_fail;
@@ -866,6 +895,8 @@ bus_probe_files_fail:
 bus_drivers_fail:
         kset_unregister(&bus->devices);
 bus_devices_fail:
+        bus_remove_file(bus, &bus_attr_uevent);
+bus_uevent_fail:
         subsystem_unregister(&bus->subsys);
 out:
         return retval;
@@ -876,7 +907,7 @@ out:
  *      @bus:   bus.
  *
  *      Unregister the child subsystems and the bus itself.
- *      Finally, we call put_bus() to release the refcount
+ *      Finally, we call bus_put() to release the refcount
  */
 void bus_unregister(struct bus_type * bus)
 {
@@ -885,6 +916,7 @@ void bus_unregister(struct bus_type * bus)
         remove_probe_files(bus);
         kset_unregister(&bus->drivers);
         kset_unregister(&bus->devices);
+        bus_remove_file(bus, &bus_attr_uevent);
         subsystem_unregister(&bus->subsys);
 }
 
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 4d2222618b..a863bb091e 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -65,13 +65,13 @@ static struct sysfs_ops class_sysfs_ops = {
         .store  = class_attr_store,
 };
 
-static struct kobj_type ktype_class = {
+static struct kobj_type class_ktype = {
         .sysfs_ops      = &class_sysfs_ops,
         .release        = class_release,
 };
 
 /* Hotplug events for classes go to the class_obj subsys */
-static decl_subsys(class, &ktype_class, NULL);
+static decl_subsys(class, &class_ktype, NULL);
 
 
 int class_create_file(struct class * cls, const struct class_attribute * attr)
@@ -93,14 +93,14 @@ void class_remove_file(struct class * cls, const struct class_attribute * attr)
 static struct class *class_get(struct class *cls)
 {
         if (cls)
-                return container_of(subsys_get(&cls->subsys), struct class, subsys);
+                return container_of(kset_get(&cls->subsys), struct class, subsys);
         return NULL;
 }
 
 static void class_put(struct class * cls)
 {
         if (cls)
-                subsys_put(&cls->subsys);
+                kset_put(&cls->subsys);
 }
 
 
@@ -149,7 +149,7 @@ int class_register(struct class * cls)
         if (error)
                 return error;
 
-        subsys_set_kset(cls, class_subsys);
+        cls->subsys.kobj.kset = &class_subsys;
 
         error = subsystem_register(&cls->subsys);
         if (!error) {
@@ -180,8 +180,7 @@ static void class_device_create_release(struct class_device *class_dev)
 
 /* needed to allow these devices to have parent class devices */
 static int class_device_create_uevent(struct class_device *class_dev,
-                                       char **envp, int num_envp,
-                                       char *buffer, int buffer_size)
+                                      struct kobj_uevent_env *env)
 {
         pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
         return 0;
@@ -324,7 +323,7 @@ static void class_dev_release(struct kobject * kobj)
         }
 }
 
-static struct kobj_type ktype_class_device = {
+static struct kobj_type class_device_ktype = {
         .sysfs_ops      = &class_dev_sysfs_ops,
         .release        = class_dev_release,
 };
@@ -333,7 +332,7 @@ static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
-        if (ktype == &ktype_class_device) {
+        if (ktype == &class_device_ktype) {
                 struct class_device *class_dev = to_class_dev(kobj);
                 if (class_dev->class)
                         return 1;
@@ -403,64 +402,43 @@ static void remove_deprecated_class_device_links(struct class_device *cd)
 { }
 #endif
 
-static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                         int num_envp, char *buffer, int buffer_size)
+static int class_uevent(struct kset *kset, struct kobject *kobj,
+                        struct kobj_uevent_env *env)
 {
         struct class_device *class_dev = to_class_dev(kobj);
         struct device *dev = class_dev->dev;
-        int i = 0;
-        int length = 0;
         int retval = 0;
 
         pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
 
         if (MAJOR(class_dev->devt)) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MAJOR=%u", MAJOR(class_dev->devt));
+                add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
 
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MINOR=%u", MINOR(class_dev->devt));
+                add_uevent_var(env, "MINOR=%u", MINOR(class_dev->devt));
         }
 
         if (dev) {
                 const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
                 if (path) {
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVPATH=%s", path);
+                        add_uevent_var(env, "PHYSDEVPATH=%s", path);
                         kfree(path);
                 }
 
                 if (dev->bus)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVBUS=%s", dev->bus->name);
+                        add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
 
                 if (dev->driver)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVDRIVER=%s", dev->driver->name);
+                        add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
         }
 
-        /* terminate, set to next free slot, shrink available space */
-        envp[i] = NULL;
-        envp = &envp[i];
-        num_envp -= i;
-        buffer = &buffer[length];
-        buffer_size -= length;
-
         if (class_dev->uevent) {
                 /* have the class device specific function add its stuff */
-                retval = class_dev->uevent(class_dev, envp, num_envp,
-                                            buffer, buffer_size);
+                retval = class_dev->uevent(class_dev, env);
                 if (retval)
                         pr_debug("class_dev->uevent() returned %d\n", retval);
         } else if (class_dev->class->uevent) {
                 /* have the class specific function add its stuff */
-                retval = class_dev->class->uevent(class_dev, envp, num_envp,
-                                                   buffer, buffer_size);
+                retval = class_dev->class->uevent(class_dev, env);
                 if (retval)
                         pr_debug("class->uevent() returned %d\n", retval);
         }
@@ -474,7 +452,7 @@ static struct kset_uevent_ops class_uevent_ops = {
         .uevent =       class_uevent,
 };
 
-static decl_subsys(class_obj, &ktype_class_device, &class_uevent_ops);
+static decl_subsys(class_obj, &class_device_ktype, &class_uevent_ops);
 
 
 static int class_device_add_attrs(struct class_device * cd)
@@ -883,7 +861,7 @@ int __init classes_init(void)
 
         /* ick, this is ugly, the things we go through to keep from showing up
          * in sysfs... */
-        subsystem_init(&class_obj_subsys);
+        kset_init(&class_obj_subsys);
         if (!class_obj_subsys.kobj.parent)
                 class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
         return 0;
diff --git a/drivers/base/core.c b/drivers/base/core.c
index ec86d6fc23..c1343414d2 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -108,7 +108,7 @@ static void device_release(struct kobject * kobj)
         }
 }
 
-static struct kobj_type ktype_device = {
+static struct kobj_type device_ktype = {
         .release        = device_release,
         .sysfs_ops      = &dev_sysfs_ops,
 };
@@ -118,7 +118,7 @@ static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
-        if (ktype == &ktype_device) {
+        if (ktype == &device_ktype) {
                 struct device *dev = to_dev(kobj);
                 if (dev->uevent_suppress)
                         return 0;
@@ -141,33 +141,23 @@ static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
         return NULL;
 }
 
-static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                        int num_envp, char *buffer, int buffer_size)
+static int dev_uevent(struct kset *kset, struct kobject *kobj,
+                      struct kobj_uevent_env *env)
 {
         struct device *dev = to_dev(kobj);
-        int i = 0;
-        int length = 0;
         int retval = 0;
 
         /* add the major/minor if present */
         if (MAJOR(dev->devt)) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MAJOR=%u", MAJOR(dev->devt));
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "MINOR=%u", MINOR(dev->devt));
+                add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
+                add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
         }
 
         if (dev->type && dev->type->name)
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "DEVTYPE=%s", dev->type->name);
+                add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
 
         if (dev->driver)
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "DRIVER=%s", dev->driver->name);
+                add_uevent_var(env, "DRIVER=%s", dev->driver->name);
 
 #ifdef CONFIG_SYSFS_DEPRECATED
         if (dev->class) {
@@ -181,59 +171,43 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
 
                         path = kobject_get_path(&parent->kobj, GFP_KERNEL);
                         if (path) {
-                                add_uevent_var(envp, num_envp, &i,
-                                               buffer, buffer_size, &length,
-                                               "PHYSDEVPATH=%s", path);
+                                add_uevent_var(env, "PHYSDEVPATH=%s", path);
                                 kfree(path);
                         }
 
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVBUS=%s", parent->bus->name);
+                        add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);
 
                         if (parent->driver)
-                                add_uevent_var(envp, num_envp, &i,
-                                               buffer, buffer_size, &length,
-                                               "PHYSDEVDRIVER=%s", parent->driver->name);
+                                add_uevent_var(env, "PHYSDEVDRIVER=%s",
+                                               parent->driver->name);
                 }
         } else if (dev->bus) {
-                add_uevent_var(envp, num_envp, &i,
-                               buffer, buffer_size, &length,
-                               "PHYSDEVBUS=%s", dev->bus->name);
+                add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
 
                 if (dev->driver)
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVDRIVER=%s", dev->driver->name);
+                        add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
         }
 #endif
 
-        /* terminate, set to next free slot, shrink available space */
-        envp[i] = NULL;
-        envp = &envp[i];
-        num_envp -= i;
-        buffer = &buffer[length];
-        buffer_size -= length;
-
+        /* have the bus specific function add its stuff */
         if (dev->bus && dev->bus->uevent) {
-                /* have the bus specific function add its stuff */
-                retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->bus->uevent(dev, env);
                 if (retval)
                         pr_debug ("%s: bus uevent() returned %d\n",
                                   __FUNCTION__, retval);
         }
 
+        /* have the class specific function add its stuff */
         if (dev->class && dev->class->dev_uevent) {
-                /* have the class specific function add its stuff */
-                retval = dev->class->dev_uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->class->dev_uevent(dev, env);
                 if (retval)
                         pr_debug("%s: class uevent() returned %d\n",
                                  __FUNCTION__, retval);
         }
 
+        /* have the device type specific fuction add its stuff */
         if (dev->type && dev->type->uevent) {
-                /* have the device type specific fuction add its stuff */
-                retval = dev->type->uevent(dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->type->uevent(dev, env);
                 if (retval)
                         pr_debug("%s: dev_type uevent() returned %d\n",
                                  __FUNCTION__, retval);
@@ -253,22 +227,18 @@ static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
 {
         struct kobject *top_kobj;
         struct kset *kset;
-        char *envp[32];
-        char *data = NULL;
-        char *pos;
+        struct kobj_uevent_env *env = NULL;
         int i;
         size_t count = 0;
         int retval;
 
         /* search the kset, the device belongs to */
         top_kobj = &dev->kobj;
-        if (!top_kobj->kset && top_kobj->parent) {
-                do {
-                        top_kobj = top_kobj->parent;
-                } while (!top_kobj->kset && top_kobj->parent);
-        }
+        while (!top_kobj->kset && top_kobj->parent)
+                top_kobj = top_kobj->parent;
         if (!top_kobj->kset)
                 goto out;
+
         kset = top_kobj->kset;
         if (!kset->uevent_ops || !kset->uevent_ops->uevent)
                 goto out;
@@ -278,43 +248,29 @@ static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
                 if (!kset->uevent_ops->filter(kset, &dev->kobj))
                         goto out;
 
-        data = (char *)get_zeroed_page(GFP_KERNEL);
-        if (!data)
+        env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
+        if (!env)
                 return -ENOMEM;
 
         /* let the kset specific function add its keys */
-        pos = data;
-        memset(envp, 0, sizeof(envp));
-        retval = kset->uevent_ops->uevent(kset, &dev->kobj,
-                                          envp, ARRAY_SIZE(envp),
-                                          pos, PAGE_SIZE);
+        retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
         if (retval)
                 goto out;
 
         /* copy keys to file */
-        for (i = 0; envp[i]; i++) {
-                pos = &buf[count];
-                count += sprintf(pos, "%s\n", envp[i]);
-        }
+        for (i = 0; i < env->envp_idx; i++)
+                count += sprintf(&buf[count], "%s\n", env->envp[i]);
 out:
-        free_page((unsigned long)data);
+        kfree(env);
         return count;
 }
 
 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
 {
-        size_t len = count;
         enum kobject_action action;
 
-        if (len && buf[len-1] == '\n')
-                len--;
-
-        for (action = 0; action < KOBJ_MAX; action++) {
-                if (strncmp(kobject_actions[action], buf, len) != 0)
-                        continue;
-                if (kobject_actions[action][len] != '\0')
-                        continue;
+        if (kobject_action_type(buf, count, &action) == 0) {
                 kobject_uevent(&dev->kobj, action);
                 goto out;
         }
@@ -449,7 +405,7 @@ static struct device_attribute devt_attr =
  *      devices_subsys - structure to be registered with kobject core.
  */
 
-decl_subsys(devices, &ktype_device, &device_uevent_ops);
+decl_subsys(devices, &device_ktype, &device_uevent_ops);
 
 
 /**
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index b24efd4e3e..0295855a3e 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -88,19 +88,14 @@ static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
 
 static void fw_dev_release(struct device *dev);
 
-static int firmware_uevent(struct device *dev, char **envp, int num_envp,
-                           char *buffer, int buffer_size)
+static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
-        int i = 0, len = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                           "FIRMWARE=%s", fw_priv->fw_id))
+        if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
                 return -ENOMEM;
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                           "TIMEOUT=%i", loading_timeout))
+        if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
                 return -ENOMEM;
-        envp[i] = NULL;
 
         return 0;
 }
@@ -297,8 +292,7 @@ firmware_class_timeout(u_long data)
 
 static inline void fw_setup_device_id(struct device *f_dev, struct device *dev)
 {
-        /* XXX warning we should watch out for name collisions */
-        strlcpy(f_dev->bus_id, dev->bus_id, BUS_ID_SIZE);
+        snprintf(f_dev->bus_id, BUS_ID_SIZE, "firmware-%s", dev->bus_id);
 }
 
 static int fw_register_device(struct device **dev_p, const char *fw_name,
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 74b96795d2..cb99daeae9 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -34,8 +34,7 @@ static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
         return MEMORY_CLASS_NAME;
 }
 
-static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp,
-                        int num_envp, char *buffer, int buffer_size)
+static int memory_uevent(struct kset *kset, struct kobj_uevent_env *env)
 {
         int retval = 0;
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 869ff8c001..fb56092414 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -160,13 +160,8 @@ static void platform_device_release(struct device *dev)
  *
  *      Create a platform device object which can have other objects attached
  *      to it, and which will have attached objects freed when it is released.
- *
- *      This device will be marked as not supporting hotpluggable drivers; no
- *      device add/remove uevents will be generated.  In the unusual case that
- *      the device isn't being dynamically allocated as a legacy "probe the
- *      hardware" driver, infrastructure code should reverse this marking.
  */
-struct platform_device *platform_device_alloc(const char *name, unsigned int id)
+struct platform_device *platform_device_alloc(const char *name, int id)
 {
         struct platform_object *pa;
 
@@ -177,12 +172,6 @@ struct platform_device *platform_device_alloc(const char *name, unsigned int id)
                 pa->pdev.id = id;
                 device_initialize(&pa->pdev.dev);
                 pa->pdev.dev.release = platform_device_release;
-
-                /* prevent hotplug "modprobe $(MODALIAS)" from causing trouble in
-                 * legacy probe-the-hardware drivers, which don't properly split
-                 * out device enumeration logic from drivers.
-                 */
-                pa->pdev.dev.uevent_suppress = 1;
         }
 
         return pa ? &pa->pdev : NULL;
@@ -256,7 +245,8 @@ int platform_device_add(struct platform_device *pdev)
         pdev->dev.bus = &platform_bus_type;
 
         if (pdev->id != -1)
-                snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id);
+                snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,
+                         pdev->id);
         else
                 strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
 
@@ -370,7 +360,7 @@ EXPORT_SYMBOL_GPL(platform_device_unregister);
  *      the Linux driver model.  In particular, when such drivers are built
  *      as modules, they can't be "hotplugged".
  */
-struct platform_device *platform_device_register_simple(char *name, unsigned int id,
+struct platform_device *platform_device_register_simple(char *name, int id,
                                                         struct resource *res, unsigned int num)
 {
         struct platform_device *pdev;
@@ -530,7 +520,7 @@ static ssize_t
 modalias_show(struct device *dev, struct device_attribute *a, char *buf)
 {
         struct platform_device  *pdev = to_platform_device(dev);
-        int len = snprintf(buf, PAGE_SIZE, "%s\n", pdev->name);
+        int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
 
         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 }
@@ -540,13 +530,11 @@ static struct device_attribute platform_dev_attrs[] = {
         __ATTR_NULL,
 };
 
-static int platform_uevent(struct device *dev, char **envp, int num_envp,
-                char *buffer, int buffer_size)
+static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct platform_device  *pdev = to_platform_device(dev);
 
-        envp[0] = buffer;
-        snprintf(buffer, buffer_size, "MODALIAS=%s", pdev->name);
+        add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
         return 0;
 }
 
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 9caeaea753..a803733c83 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,5 +1,5 @@
 obj-y                   := shutdown.o
-obj-$(CONFIG_PM_SLEEP)  += main.o suspend.o resume.o sysfs.o
+obj-$(CONFIG_PM_SLEEP)  += main.o sysfs.o
 obj-$(CONFIG_PM_TRACE)  += trace.o
 
 ifeq ($(CONFIG_DEBUG_DRIVER),y)
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index eb9f38d0aa..0ab4ab21f5 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -20,19 +20,24 @@
  */
 
 #include <linux/device.h>
+#include <linux/kallsyms.h>
 #include <linux/mutex.h>
+#include <linux/pm.h>
+#include <linux/resume-trace.h>
 
+#include "../base.h"
 #include "power.h"
 
 LIST_HEAD(dpm_active);
-LIST_HEAD(dpm_off);
-LIST_HEAD(dpm_off_irq);
+static LIST_HEAD(dpm_off);
+static LIST_HEAD(dpm_off_irq);
 
-DEFINE_MUTEX(dpm_mtx);
-DEFINE_MUTEX(dpm_list_mtx);
+static DEFINE_MUTEX(dpm_mtx);
+static DEFINE_MUTEX(dpm_list_mtx);
 
 int (*platform_enable_wakeup)(struct device *dev, int is_on);
 
+
 int device_pm_add(struct device *dev)
 {
         int error;
@@ -61,3 +66,334 @@ void device_pm_remove(struct device *dev)
 }
 
 
+/*------------------------- Resume routines -------------------------*/
+
+/**
+ *      resume_device - Restore state for one device.
+ *      @dev:   Device.
+ *
+ */
+
+static int resume_device(struct device * dev)
+{
+        int error = 0;
+
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+
+        down(&dev->sem);
+
+        if (dev->bus && dev->bus->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->bus->resume(dev);
+        }
+
+        if (!error && dev->type && dev->type->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->type->resume(dev);
+        }
+
+        if (!error && dev->class && dev->class->resume) {
+                dev_dbg(dev,"class resume\n");
+                error = dev->class->resume(dev);
+        }
+
+        up(&dev->sem);
+
+        TRACE_RESUME(error);
+        return error;
+}
+
+
+static int resume_device_early(struct device * dev)
+{
+        int error = 0;
+
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+        if (dev->bus && dev->bus->resume_early) {
+                dev_dbg(dev,"EARLY resume\n");
+                error = dev->bus->resume_early(dev);
+        }
+        TRACE_RESUME(error);
+        return error;
+}
+
+/*
+ * Resume the devices that have either not gone through
+ * the late suspend, or that did go through it but also
+ * went through the early resume
+ */
+static void dpm_resume(void)
+{
+        mutex_lock(&dpm_list_mtx);
+        while(!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.next;
+                struct device * dev = to_device(entry);
+
+                get_device(dev);
+                list_move_tail(entry, &dpm_active);
+
+                mutex_unlock(&dpm_list_mtx);
+                resume_device(dev);
+                mutex_lock(&dpm_list_mtx);
+                put_device(dev);
+        }
+        mutex_unlock(&dpm_list_mtx);
+}
+
+
+/**
+ *      device_resume - Restore state of each device in system.
+ *
+ *      Walk the dpm_off list, remove each entry, resume the device,
+ *      then add it to the dpm_active list.
+ */
+
+void device_resume(void)
+{
+        might_sleep();
+        mutex_lock(&dpm_mtx);
+        dpm_resume();
+        mutex_unlock(&dpm_mtx);
+}
+
+EXPORT_SYMBOL_GPL(device_resume);
+
+
+/**
+ *      dpm_power_up - Power on some devices.
+ *
+ *      Walk the dpm_off_irq list and power each device up. This
+ *      is used for devices that required they be powered down with
+ *      interrupts disabled. As devices are powered on, they are moved
+ *      to the dpm_active list.
+ *
+ *      Interrupts must be disabled when calling this.
+ */
+
+static void dpm_power_up(void)
+{
+        while(!list_empty(&dpm_off_irq)) {
+                struct list_head * entry = dpm_off_irq.next;
+                struct device * dev = to_device(entry);
+
+                list_move_tail(entry, &dpm_off);
+                resume_device_early(dev);
+        }
+}
+
+
+/**
+ *      device_power_up - Turn on all devices that need special attention.
+ *
+ *      Power on system devices then devices that required we shut them down
+ *      with interrupts disabled.
+ *      Called with interrupts disabled.
+ */
+
+void device_power_up(void)
+{
+        sysdev_resume();
+        dpm_power_up();
+}
+
+EXPORT_SYMBOL_GPL(device_power_up);
+
+
+/*------------------------- Suspend routines -------------------------*/
+
+/*
+ * The entries in the dpm_active list are in a depth first order, simply
+ * because children are guaranteed to be discovered after parents, and
+ * are inserted at the back of the list on discovery.
+ *
+ * All list on the suspend path are done in reverse order, so we operate
+ * on the leaves of the device tree (or forests, depending on how you want
+ * to look at it ;) first. As nodes are removed from the back of the list,
+ * they are inserted into the front of their destintation lists.
+ *
+ * Things are the reverse on the resume path - iterations are done in
+ * forward order, and nodes are inserted at the back of their destination
+ * lists. This way, the ancestors will be accessed before their descendents.
+ */
+
+static inline char *suspend_verb(u32 event)
+{
+        switch (event) {
+        case PM_EVENT_SUSPEND:  return "suspend";
+        case PM_EVENT_FREEZE:   return "freeze";
+        case PM_EVENT_PRETHAW:  return "prethaw";
+        default:                return "(unknown suspend event)";
+        }
+}
+
+
+static void
+suspend_device_dbg(struct device *dev, pm_message_t state, char *info)
+{
+        dev_dbg(dev, "%s%s%s\n", info, suspend_verb(state.event),
+                ((state.event == PM_EVENT_SUSPEND) && device_may_wakeup(dev)) ?
+                ", may wakeup" : "");
+}
+
+/**
+ *      suspend_device - Save state of one device.
+ *      @dev:   Device.
+ *      @state: Power state device is entering.
+ */
+
+static int suspend_device(struct device * dev, pm_message_t state)
+{
+        int error = 0;
+
+        down(&dev->sem);
+        if (dev->power.power_state.event) {
+                dev_dbg(dev, "PM: suspend %d-->%d\n",
+                        dev->power.power_state.event, state.event);
+        }
+
+        if (dev->class && dev->class->suspend) {
+                suspend_device_dbg(dev, state, "class ");
+                error = dev->class->suspend(dev, state);
+                suspend_report_result(dev->class->suspend, error);
+        }
+
+        if (!error && dev->type && dev->type->suspend) {
+                suspend_device_dbg(dev, state, "type ");
+                error = dev->type->suspend(dev, state);
+                suspend_report_result(dev->type->suspend, error);
+        }
+
+        if (!error && dev->bus && dev->bus->suspend) {
+                suspend_device_dbg(dev, state, "");
+                error = dev->bus->suspend(dev, state);
+                suspend_report_result(dev->bus->suspend, error);
+        }
+        up(&dev->sem);
+        return error;
+}
+
+
+/*
+ * This is called with interrupts off, only a single CPU
+ * running. We can't acquire a mutex or semaphore (and we don't
+ * need the protection)
+ */
+static int suspend_device_late(struct device *dev, pm_message_t state)
+{
+        int error = 0;
+
+        if (dev->bus && dev->bus->suspend_late) {
+                suspend_device_dbg(dev, state, "LATE ");
+                error = dev->bus->suspend_late(dev, state);
+                suspend_report_result(dev->bus->suspend_late, error);
+        }
+        return error;
+}
+
+/**
+ *      device_suspend - Save state and stop all devices in system.
+ *      @state:         Power state to put each device in.
+ *
+ *      Walk the dpm_active list, call ->suspend() for each device, and move
+ *      it to the dpm_off list.
+ *
+ *      (For historical reasons, if it returns -EAGAIN, that used to mean
+ *      that the device would be called again with interrupts disabled.
+ *      These days, we use the "suspend_late()" callback for that, so we
+ *      print a warning and consider it an error).
+ *
+ *      If we get a different error, try and back out.
+ *
+ *      If we hit a failure with any of the devices, call device_resume()
+ *      above to bring the suspended devices back to life.
+ *
+ */
+
+int device_suspend(pm_message_t state)
+{
+        int error = 0;
+
+        might_sleep();
+        mutex_lock(&dpm_mtx);
+        mutex_lock(&dpm_list_mtx);
+        while (!list_empty(&dpm_active) && error == 0) {
+                struct list_head * entry = dpm_active.prev;
+                struct device * dev = to_device(entry);
+
+                get_device(dev);
+                mutex_unlock(&dpm_list_mtx);
+
+                error = suspend_device(dev, state);
+
+                mutex_lock(&dpm_list_mtx);
+
+                /* Check if the device got removed */
+                if (!list_empty(&dev->power.entry)) {
+                        /* Move it to the dpm_off list */
+                        if (!error)
+                                list_move(&dev->power.entry, &dpm_off);
+                }
+                if (error)
+                        printk(KERN_ERR "Could not suspend device %s: "
+                                "error %d%s\n",
+                                kobject_name(&dev->kobj), error,
+                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
+                put_device(dev);
+        }
+        mutex_unlock(&dpm_list_mtx);
+        if (error)
+                dpm_resume();
+
+        mutex_unlock(&dpm_mtx);
+        return error;
+}
+
+EXPORT_SYMBOL_GPL(device_suspend);
+
+/**
+ *      device_power_down - Shut down special devices.
+ *      @state:         Power state to enter.
+ *
+ *      Walk the dpm_off_irq list, calling ->power_down() for each device that
+ *      couldn't power down the device with interrupts enabled. When we're
+ *      done, power down system devices.
+ */
+
+int device_power_down(pm_message_t state)
+{
+        int error = 0;
+        struct device * dev;
+
+        while (!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.prev;
+
+                dev = to_device(entry);
+                error = suspend_device_late(dev, state);
+                if (error)
+                        goto Error;
+                list_move(&dev->power.entry, &dpm_off_irq);
+        }
+
+        error = sysdev_suspend(state);
+ Done:
+        return error;
+ Error:
+        printk(KERN_ERR "Could not power down device %s: "
+                "error %d\n", kobject_name(&dev->kobj), error);
+        dpm_power_up();
+        goto Done;
+}
+
+EXPORT_SYMBOL_GPL(device_power_down);
+
+void __suspend_report_result(const char *function, void *fn, int ret)
+{
+        if (ret) {
+                printk(KERN_ERR "%s(): ", function);
+                print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
+                printk("%d\n", ret);
+        }
+}
+EXPORT_SYMBOL_GPL(__suspend_report_result);
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 8ba0830cbc..5c4efd493f 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -11,32 +11,11 @@ extern void device_shutdown(void);
  * main.c
  */
 
-/*
- * Used to synchronize global power management operations.
- */
-extern struct mutex dpm_mtx;
-
-/*
- * Used to serialize changes to the dpm_* lists.
- */
-extern struct mutex dpm_list_mtx;
-
-/*
- * The PM lists.
- */
-extern struct list_head dpm_active;
-extern struct list_head dpm_off;
-extern struct list_head dpm_off_irq;
-
-
-static inline struct dev_pm_info * to_pm_info(struct list_head * entry)
-{
-        return container_of(entry, struct dev_pm_info, entry);
-}
+extern struct list_head dpm_active;     /* The active device list */
 
 static inline struct device * to_device(struct list_head * entry)
 {
-        return container_of(to_pm_info(entry), struct device, power);
+        return container_of(entry, struct device, power.entry);
 }
 
 extern int device_pm_add(struct device *);
@@ -49,19 +28,6 @@ extern void device_pm_remove(struct device *);
 extern int dpm_sysfs_add(struct device *);
 extern void dpm_sysfs_remove(struct device *);
 
-/*
- * resume.c
- */
-
-extern void dpm_resume(void);
-extern void dpm_power_up(void);
-extern int resume_device(struct device *);
-
-/*
- * suspend.c
- */
-extern int suspend_device(struct device *, pm_message_t);
-
 #else /* CONFIG_PM_SLEEP */
 
 
diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
deleted file mode 100644
index 00fd84ae6e..0000000000
--- a/drivers/base/power/resume.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * resume.c - Functions for waking devices up.
- *
- * Copyright (c) 2003 Patrick Mochel
- * Copyright (c) 2003 Open Source Development Labs
- *
- * This file is released under the GPLv2
- *
- */
-
-#include <linux/device.h>
-#include <linux/resume-trace.h>
-#include "../base.h"
-#include "power.h"
-
-
-/**
- *      resume_device - Restore state for one device.
- *      @dev:   Device.
- *
- */
-
-int resume_device(struct device * dev)
-{
-        int error = 0;
-
-        TRACE_DEVICE(dev);
-        TRACE_RESUME(0);
-
-        down(&dev->sem);
-
-        if (dev->bus && dev->bus->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->bus->resume(dev);
-        }
-
-        if (!error && dev->type && dev->type->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->type->resume(dev);
-        }
-
-        if (!error && dev->class && dev->class->resume) {
-                dev_dbg(dev,"class resume\n");
-                error = dev->class->resume(dev);
-        }
-
-        up(&dev->sem);
-
-        TRACE_RESUME(error);
-        return error;
-}
-
-
-static int resume_device_early(struct device * dev)
-{
-        int error = 0;
-
-        TRACE_DEVICE(dev);
-        TRACE_RESUME(0);
-        if (dev->bus && dev->bus->resume_early) {
-                dev_dbg(dev,"EARLY resume\n");
-                error = dev->bus->resume_early(dev);
-        }
-        TRACE_RESUME(error);
-        return error;
-}
-
-/*
- * Resume the devices that have either not gone through
- * the late suspend, or that did go through it but also
- * went through the early resume
- */
-void dpm_resume(void)
-{
-        mutex_lock(&dpm_list_mtx);
-        while(!list_empty(&dpm_off)) {
-                struct list_head * entry = dpm_off.next;
-                struct device * dev = to_device(entry);
-
-                get_device(dev);
-                list_move_tail(entry, &dpm_active);
-
-                mutex_unlock(&dpm_list_mtx);
-                resume_device(dev);
-                mutex_lock(&dpm_list_mtx);
-                put_device(dev);
-        }
-        mutex_unlock(&dpm_list_mtx);
-}
-
-
-/**
- *      device_resume - Restore state of each device in system.
- *
- *      Walk the dpm_off list, remove each entry, resume the device,
- *      then add it to the dpm_active list.
- */
-
-void device_resume(void)
-{
-        might_sleep();
-        mutex_lock(&dpm_mtx);
-        dpm_resume();
-        mutex_unlock(&dpm_mtx);
-}
-
-EXPORT_SYMBOL_GPL(device_resume);
-
-
-/**
- *      dpm_power_up - Power on some devices.
- *
- *      Walk the dpm_off_irq list and power each device up. This
- *      is used for devices that required they be powered down with
- *      interrupts disabled. As devices are powered on, they are moved
- *      to the dpm_active list.
- *
- *      Interrupts must be disabled when calling this.
- */
-
-void dpm_power_up(void)
-{
-        while(!list_empty(&dpm_off_irq)) {
-                struct list_head * entry = dpm_off_irq.next;
-                struct device * dev = to_device(entry);
-
-                list_move_tail(entry, &dpm_off);
-                resume_device_early(dev);
-        }
-}
-
-
-/**
- *      device_power_up - Turn on all devices that need special attention.
- *
- *      Power on system devices then devices that required we shut them down
- *      with interrupts disabled.
- *      Called with interrupts disabled.
- */
-
-void device_power_up(void)
-{
-        sysdev_resume();
-        dpm_power_up();
-}
-
-EXPORT_SYMBOL_GPL(device_power_up);
-
-
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
deleted file mode 100644
index 26df9b2317..0000000000
--- a/drivers/base/power/suspend.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * suspend.c - Functions for putting devices to sleep.
- *
- * Copyright (c) 2003 Patrick Mochel
- * Copyright (c) 2003 Open Source Development Labs
- *
- * This file is released under the GPLv2
- *
- */
-
-#include <linux/device.h>
-#include <linux/kallsyms.h>
-#include <linux/pm.h>
-#include "../base.h"
-#include "power.h"
-
-/*
- * The entries in the dpm_active list are in a depth first order, simply
- * because children are guaranteed to be discovered after parents, and
- * are inserted at the back of the list on discovery.
- *
- * All list on the suspend path are done in reverse order, so we operate
- * on the leaves of the device tree (or forests, depending on how you want
- * to look at it ;) first. As nodes are removed from the back of the list,
- * they are inserted into the front of their destintation lists.
- *
- * Things are the reverse on the resume path - iterations are done in
- * forward order, and nodes are inserted at the back of their destination
- * lists. This way, the ancestors will be accessed before their descendents.
- */
-
-static inline char *suspend_verb(u32 event)
-{
-        switch (event) {
-        case PM_EVENT_SUSPEND:  return "suspend";
-        case PM_EVENT_FREEZE:   return "freeze";
-        case PM_EVENT_PRETHAW:  return "prethaw";
-        default:                return "(unknown suspend event)";
-        }
-}
-
-
-static void
-suspend_device_dbg(struct device *dev, pm_message_t state, char *info)
-{
-        dev_dbg(dev, "%s%s%s\n", info, suspend_verb(state.event),
-                ((state.event == PM_EVENT_SUSPEND) && device_may_wakeup(dev)) ?
-                ", may wakeup" : "");
-}
-
-/**
- *      suspend_device - Save state of one device.
- *      @dev:   Device.
- *      @state: Power state device is entering.
- */
-
-int suspend_device(struct device * dev, pm_message_t state)
-{
-        int error = 0;
-
-        down(&dev->sem);
-        if (dev->power.power_state.event) {
-                dev_dbg(dev, "PM: suspend %d-->%d\n",
-                        dev->power.power_state.event, state.event);
-        }
-
-        if (dev->class && dev->class->suspend) {
-                suspend_device_dbg(dev, state, "class ");
-                error = dev->class->suspend(dev, state);
-                suspend_report_result(dev->class->suspend, error);
-        }
-
-        if (!error && dev->type && dev->type->suspend) {
-                suspend_device_dbg(dev, state, "type ");
-                error = dev->type->suspend(dev, state);
-                suspend_report_result(dev->type->suspend, error);
-        }
-
-        if (!error && dev->bus && dev->bus->suspend) {
-                suspend_device_dbg(dev, state, "");
-                error = dev->bus->suspend(dev, state);
-                suspend_report_result(dev->bus->suspend, error);
-        }
-        up(&dev->sem);
-        return error;
-}
-
-
-/*
- * This is called with interrupts off, only a single CPU
- * running. We can't acquire a mutex or semaphore (and we don't
- * need the protection)
- */
-static int suspend_device_late(struct device *dev, pm_message_t state)
-{
-        int error = 0;
-
-        if (dev->bus && dev->bus->suspend_late) {
-                suspend_device_dbg(dev, state, "LATE ");
-                error = dev->bus->suspend_late(dev, state);
-                suspend_report_result(dev->bus->suspend_late, error);
-        }
-        return error;
-}
-
-/**
- *      device_suspend - Save state and stop all devices in system.
- *      @state:         Power state to put each device in.
- *
- *      Walk the dpm_active list, call ->suspend() for each device, and move
- *      it to the dpm_off list.
- *
- *      (For historical reasons, if it returns -EAGAIN, that used to mean
- *      that the device would be called again with interrupts disabled.
- *      These days, we use the "suspend_late()" callback for that, so we
- *      print a warning and consider it an error).
- *
- *      If we get a different error, try and back out.
- *
- *      If we hit a failure with any of the devices, call device_resume()
- *      above to bring the suspended devices back to life.
- *
- */
-
-int device_suspend(pm_message_t state)
-{
-        int error = 0;
-
-        might_sleep();
-        mutex_lock(&dpm_mtx);
-        mutex_lock(&dpm_list_mtx);
-        while (!list_empty(&dpm_active) && error == 0) {
-                struct list_head * entry = dpm_active.prev;
-                struct device * dev = to_device(entry);
-
-                get_device(dev);
-                mutex_unlock(&dpm_list_mtx);
-
-                error = suspend_device(dev, state);
-
-                mutex_lock(&dpm_list_mtx);
-
-                /* Check if the device got removed */
-                if (!list_empty(&dev->power.entry)) {
-                        /* Move it to the dpm_off list */
-                        if (!error)
-                                list_move(&dev->power.entry, &dpm_off);
-                }
-                if (error)
-                        printk(KERN_ERR "Could not suspend device %s: "
-                                "error %d%s\n",
-                                kobject_name(&dev->kobj), error,
-                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
-                put_device(dev);
-        }
-        mutex_unlock(&dpm_list_mtx);
-        if (error)
-                dpm_resume();
-
-        mutex_unlock(&dpm_mtx);
-        return error;
-}
-
-EXPORT_SYMBOL_GPL(device_suspend);
-
-/**
- *      device_power_down - Shut down special devices.
- *      @state:         Power state to enter.
- *
- *      Walk the dpm_off_irq list, calling ->power_down() for each device that
- *      couldn't power down the device with interrupts enabled. When we're
- *      done, power down system devices.
- */
-
-int device_power_down(pm_message_t state)
-{
-        int error = 0;
-        struct device * dev;
-
-        while (!list_empty(&dpm_off)) {
-                struct list_head * entry = dpm_off.prev;
-
-                dev = to_device(entry);
-                error = suspend_device_late(dev, state);
-                if (error)
-                        goto Error;
-                list_move(&dev->power.entry, &dpm_off_irq);
-        }
-
-        error = sysdev_suspend(state);
- Done:
-        return error;
- Error:
-        printk(KERN_ERR "Could not power down device %s: "
-                "error %d\n", kobject_name(&dev->kobj), error);
-        dpm_power_up();
-        goto Done;
-}
-
-EXPORT_SYMBOL_GPL(device_power_down);
-
-void __suspend_report_result(const char *function, void *fn, int ret)
-{
-        if (ret) {
-                printk(KERN_ERR "%s(): ", function);
-                print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
-                printk("%d\n", ret);
-        }
-}
-EXPORT_SYMBOL_GPL(__suspend_report_result);
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 18febe26ca..ac7ff6d0c6 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -139,7 +139,7 @@ int sysdev_class_register(struct sysdev_class * cls)
                  kobject_name(&cls->kset.kobj));
         INIT_LIST_HEAD(&cls->drivers);
         cls->kset.kobj.parent = &system_subsys.kobj;
-        kset_set_kset_s(cls, system_subsys);
+        cls->kset.kobj.kset = &system_subsys;
         return kset_register(&cls->kset);
 }
 
@@ -153,25 +153,22 @@ void sysdev_class_unregister(struct sysdev_class * cls)
 EXPORT_SYMBOL_GPL(sysdev_class_register);
 EXPORT_SYMBOL_GPL(sysdev_class_unregister);
 
-
-static LIST_HEAD(sysdev_drivers);
 static DEFINE_MUTEX(sysdev_drivers_lock);
 
 /**
  *      sysdev_driver_register - Register auxillary driver
- *      @cls:   Device class driver belongs to.
+ *      @cls:   Device class driver belongs to.
  *      @drv:   Driver.
  *
- *      If @cls is valid, then @drv is inserted into @cls->drivers to be
+ *      @drv is inserted into @cls->drivers to be
  *      called on each operation on devices of that class. The refcount
  *      of @cls is incremented.
- *      Otherwise, @drv is inserted into sysdev_drivers, and called for
- *      each device.
  */
 
-int sysdev_driver_register(struct sysdev_class * cls,
-                           struct sysdev_driver * drv)
+int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 {
+        int err = 0;
+
         mutex_lock(&sysdev_drivers_lock);
         if (cls && kset_get(&cls->kset)) {
                 list_add_tail(&drv->entry, &cls->drivers);
@@ -182,10 +179,13 @@ int sysdev_driver_register(struct sysdev_class * cls,
                         list_for_each_entry(dev, &cls->kset.list, kobj.entry)
                                 drv->add(dev);
                 }
-        } else
-                list_add_tail(&drv->entry, &sysdev_drivers);
+        } else {
+                err = -EINVAL;
+                printk(KERN_ERR "%s: invalid device class\n", __FUNCTION__);
+                WARN_ON(1);
+        }
         mutex_unlock(&sysdev_drivers_lock);
-        return 0;
+        return err;
 }
 
 
@@ -251,12 +251,6 @@ int sysdev_register(struct sys_device * sysdev)
                  * code that should have called us.
                  */
 
-                /* Notify global drivers */
-                list_for_each_entry(drv, &sysdev_drivers, entry) {
-                        if (drv->add)
-                                drv->add(sysdev);
-                }
-
                 /* Notify class auxillary drivers */
                 list_for_each_entry(drv, &cls->drivers, entry) {
                         if (drv->add)
@@ -272,11 +266,6 @@ void sysdev_unregister(struct sys_device * sysdev)
         struct sysdev_driver * drv;
 
         mutex_lock(&sysdev_drivers_lock);
-        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                if (drv->remove)
-                        drv->remove(sysdev);
-        }
-
         list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
                 if (drv->remove)
                         drv->remove(sysdev);
@@ -293,7 +282,7 @@ void sysdev_unregister(struct sys_device * sysdev)
  *
  *      Loop over each class of system devices, and the devices in each
  *      of those classes. For each device, we call the shutdown method for
- *      each driver registered for the device - the globals, the auxillaries,
+ *      each driver registered for the device - the auxillaries,
  *      and the class driver.
  *
  *      Note: The list is iterated in reverse order, so that we shut down
@@ -320,13 +309,7 @@ void sysdev_shutdown(void)
                         struct sysdev_driver * drv;
                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
 
-                        /* Call global drivers first. */
-                        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                                if (drv->shutdown)
-                                        drv->shutdown(sysdev);
-                        }
-
-                        /* Call auxillary drivers next. */
+                        /* Call auxillary drivers first */
                         list_for_each_entry(drv, &cls->drivers, entry) {
                                 if (drv->shutdown)
                                         drv->shutdown(sysdev);
@@ -354,12 +337,6 @@ static void __sysdev_resume(struct sys_device *dev)
                 if (drv->resume)
                         drv->resume(dev);
         }
-
-        /* Call global drivers. */
-        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                if (drv->resume)
-                        drv->resume(dev);
-        }
 }
 
 /**
@@ -393,16 +370,7 @@ int sysdev_suspend(pm_message_t state)
                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
 
-                        /* Call global drivers first. */
-                        list_for_each_entry(drv, &sysdev_drivers, entry) {
-                                if (drv->suspend) {
-                                        ret = drv->suspend(sysdev, state);
-                                        if (ret)
-                                                goto gbl_driver;
-                                }
-                        }
-
-                        /* Call auxillary drivers next. */
+                        /* Call auxillary drivers first */
                         list_for_each_entry(drv, &cls->drivers, entry) {
                                 if (drv->suspend) {
                                         ret = drv->suspend(sysdev, state);
@@ -436,18 +404,7 @@ aux_driver:
                 if (err_drv->resume)
                         err_drv->resume(sysdev);
         }
-        drv = NULL;
 
-gbl_driver:
-        if (drv)
-                printk(KERN_ERR "sysdev driver suspend failed for %s\n",
-                                kobject_name(&sysdev->kobj));
-        list_for_each_entry(err_drv, &sysdev_drivers, entry) {
-                if (err_drv == drv)
-                        break;
-                if (err_drv->resume)
-                        err_drv->resume(sysdev);
-        }
         /* resume other sysdevs in current class */
         list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
                 if (err_dev == sysdev)
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 4245b7f80a..ca4d7f0d09 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -361,8 +361,7 @@ config BLK_DEV_RAM_SIZE
         default "4096"
         help
           The default value is 4096 kilobytes. Only change this if you know
-          what are you doing. If you are using IBM S/390, then set this to
-          8192.
+          what are you doing.
 
 config BLK_DEV_RAM_BLOCKSIZE
         int "Default RAM disk block size (bytes)"
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index 9b8278e1f4..acbfe1c49b 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -513,7 +513,7 @@ static int __init dsp56k_init_driver(void)
                 err = PTR_ERR(dsp56k_class);
                 goto out_chrdev;
         }
-        class_device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
+        device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), "dsp56k");
 
         printk(banner);
         goto out;
@@ -527,7 +527,7 @@ module_init(dsp56k_init_driver);
 
 static void __exit dsp56k_cleanup_driver(void)
 {
-        class_device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
+        device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
         class_destroy(dsp56k_class);
         unregister_chrdev(DSP56K_MAJOR, "dsp56k");
 }
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 8d74b8745e..bd94d5f9e6 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -411,8 +411,8 @@ cleanup_module(void)
                         iiResetDelay( i2BoardPtrTable[i] );
                         /* free io addresses and Tibet */
                         release_region( ip2config.addr[i], 8 );
-                        class_device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i));
-                        class_device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i + 1));
+                        device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i));
+                        device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i + 1));
                 }
                 /* Disable and remove interrupt handler. */
                 if ( (ip2config.irq[i] > 0) && have_requested_irq(ip2config.irq[i]) ) { 
@@ -718,12 +718,12 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                         }
 
                         if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
-                                class_device_create(ip2_class, NULL,
+                                device_create(ip2_class, NULL,
                                                 MKDEV(IP2_IPL_MAJOR, 4 * i),
-                                                NULL, "ipl%d", i);
-                                class_device_create(ip2_class, NULL,
+                                                "ipl%d", i);
+                                device_create(ip2_class, NULL,
                                                 MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
-                                                NULL, "stat%d", i);
+                                                "stat%d", i);
 
                             for ( box = 0; box < ABS_MAX_BOXES; ++box )
                             {
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index c2aa44ee6e..0246a2b8ce 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -865,7 +865,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
         entry->dev = dev;
 
         mutex_lock(&reg_list_mutex);
-        class_device_create(ipmi_class, NULL, dev, device, "ipmi%d", if_num);
+        device_create(ipmi_class, device, dev, "ipmi%d", if_num);
         list_add(&entry->link, &reg_list);
         mutex_unlock(&reg_list_mutex);
 }
@@ -883,7 +883,7 @@ static void ipmi_smi_gone(int if_num)
                         break;
                 }
         }
-        class_device_destroy(ipmi_class, dev);
+        device_destroy(ipmi_class, dev);
         mutex_unlock(&reg_list_mutex);
 }
 
@@ -938,7 +938,7 @@ static __exit void cleanup_ipmi(void)
         mutex_lock(&reg_list_mutex);
         list_for_each_entry_safe(entry, entry2, &reg_list, link) {
                 list_del(&entry->link);
-                class_device_destroy(ipmi_class, entry->dev);
+                device_destroy(ipmi_class, entry->dev);
                 kfree(entry);
         }
         mutex_unlock(&reg_list_mutex);
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 3c66f402f9..1f27be1ec3 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -4624,9 +4624,8 @@ static int __init istallion_module_init(void)
 
         istallion_class = class_create(THIS_MODULE, "staliomem");
         for (i = 0; i < 4; i++)
-                class_device_create(istallion_class, NULL,
-                                MKDEV(STL_SIOMEMMAJOR, i),
-                                NULL, "staliomem%d", i);
+                device_create(istallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
+                              "staliomem%d", i);
 
         return 0;
 err_deinit:
@@ -4659,8 +4658,7 @@ static void __exit istallion_module_exit(void)
         unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
 
         for (j = 0; j < 4; j++)
-                class_device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR,
-                                        j));
+                device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, j));
         class_destroy(istallion_class);
 
         pci_unregister_driver(&stli_pcidriver);
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 62051f8b09..c59e2a0996 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -799,8 +799,7 @@ static int lp_register(int nr, struct parport *port)
         if (reset)
                 lp_reset(nr);
 
-        class_device_create(lp_class, NULL, MKDEV(LP_MAJOR, nr), port->dev,
-                                "lp%d", nr);
+        device_create(lp_class, port->dev, MKDEV(LP_MAJOR, nr), "lp%d", nr);
 
         printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name, 
                (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");
@@ -971,7 +970,7 @@ static void lp_cleanup_module (void)
                 if (lp_table[offset].dev == NULL)
                         continue;
                 parport_unregister_device(lp_table[offset].dev);
-                class_device_destroy(lp_class, MKDEV(LP_MAJOR, offset));
+                device_destroy(lp_class, MKDEV(LP_MAJOR, offset));
         }
         class_destroy(lp_class);
 }
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index 4177f6db83..cc5d77797d 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1863,8 +1863,7 @@ static int cm4000_probe(struct pcmcia_device *link)
                 return ret;
         }
 
-        class_device_create(cmm_class, NULL, MKDEV(major, i), NULL,
-                            "cmm%d", i);
+        device_create(cmm_class, NULL, MKDEV(major, i), "cmm%d", i);
 
         return 0;
 }
@@ -1888,7 +1887,7 @@ static void cm4000_detach(struct pcmcia_device *link)
         dev_table[devno] = NULL;
         kfree(dev);
 
-        class_device_destroy(cmm_class, MKDEV(major, devno));
+        device_destroy(cmm_class, MKDEV(major, devno));
 
         return;
 }
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index b24a3e7bbb..a0b9c8728d 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -642,8 +642,7 @@ static int reader_probe(struct pcmcia_device *link)
                 return ret;
         }
 
-        class_device_create(cmx_class, NULL, MKDEV(major, i), NULL,
-                            "cmx%d", i);
+        device_create(cmx_class, NULL, MKDEV(major, i), "cmx%d", i);
 
         return 0;
 }
@@ -666,7 +665,7 @@ static void reader_detach(struct pcmcia_device *link)
         dev_table[devno] = NULL;
         kfree(dev);
 
-        class_device_destroy(cmx_class, MKDEV(major, devno));
+        device_destroy(cmx_class, MKDEV(major, devno));
 
         return;
 }
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index de14aea34e..73de77105f 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -248,14 +248,19 @@ static int pty_bsd_ioctl(struct tty_struct *tty, struct file *file,
         return -ENOIOCTLCMD;
 }
 
+static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
+module_param(legacy_count, int, 0);
+
 static void __init legacy_pty_init(void)
 {
+        if (legacy_count <= 0)
+                return;
 
-        pty_driver = alloc_tty_driver(NR_PTYS);
+        pty_driver = alloc_tty_driver(legacy_count);
         if (!pty_driver)
                 panic("Couldn't allocate pty driver");
 
-        pty_slave_driver = alloc_tty_driver(NR_PTYS);
+        pty_slave_driver = alloc_tty_driver(legacy_count);
         if (!pty_slave_driver)
                 panic("Couldn't allocate pty slave driver");
 
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 1f0d7c60c9..bbfa0e241c 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -255,10 +255,7 @@ static const struct file_operations raw_ctl_fops = {
         .owner  =       THIS_MODULE,
 };
 
-static struct cdev raw_cdev = {
-        .kobj   =       {.name = "raw", },
-        .owner  =       THIS_MODULE,
-};
+static struct cdev raw_cdev;
 
 static int __init raw_init(void)
 {
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 52753e723e..b9c1dba6bd 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -441,8 +441,7 @@ scdrv_init(void)
                                 continue;
                         }
 
-                        class_device_create(snsc_class, NULL, dev, NULL,
-                                                "%s", devname);
+                        device_create(snsc_class, NULL, dev, "%s", devname);
 
                         ia64_sn_irtr_intr_enable(scd->scd_nasid,
                                                  0 /*ignored */ ,
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 4a80b2f864..45758d5b56 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -4778,9 +4778,8 @@ static int __init stallion_module_init(void)
         if (IS_ERR(stallion_class))
                 printk("STALLION: failed to create class\n");
         for (i = 0; i < 4; i++)
-                class_device_create(stallion_class, NULL,
-                                    MKDEV(STL_SIOMEMMAJOR, i), NULL,
-                                    "staliomem%d", i);
+                device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
+                              "staliomem%d", i);
 
         return 0;
 err_unrtty:
@@ -4816,7 +4815,7 @@ static void __exit stallion_module_exit(void)
         }
 
         for (i = 0; i < 4; i++)
-                class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
+                device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
         unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
         class_destroy(stallion_class);
 
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index 35b40b9965..cef55c4065 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -441,8 +441,8 @@ tipar_register(int nr, struct parport *port)
                 goto out;
         }
 
-        class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
-                        TIPAR_MINOR + nr), port->dev, "par%d", nr);
+        device_create(tipar_class, port->dev, MKDEV(TIPAR_MAJOR,
+                        TIPAR_MINOR + nr), "par%d", nr);
 
         /* Display informations */
         pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq ==
@@ -534,7 +534,7 @@ tipar_cleanup_module(void)
                 if (table[i].dev == NULL)
                         continue;
                 parport_unregister_device(table[i].dev);
-                class_device_destroy(tipar_class, MKDEV(TIPAR_MAJOR, i));
+                device_destroy(tipar_class, MKDEV(TIPAR_MAJOR, i));
         }
         class_destroy(tipar_class);
 
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index f1d60f0cef..db7a731e23 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -871,10 +871,10 @@ static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         state[i].cur_part = 0;
         for (j = 0; j < MAX_PARTITIONS; ++j)
                 state[i].part_stat_rwi[j] = VIOT_IDLE;
-        class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i), NULL,
+        device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i),
                         "iseries!vt%d", i);
-        class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
-                        NULL, "iseries!nvt%d", i);
+        device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
+                        "iseries!nvt%d", i);
         printk(VIOTAPE_KERN_INFO "tape iseries/vt%d is iSeries "
                         "resource %10.10s type %4.4s, model %3.3s\n",
                         i, viotape_unitinfo[i].rsrcname,
@@ -886,8 +886,8 @@ static int viotape_remove(struct vio_dev *vdev)
 {
         int i = vdev->unit_address;
 
-        class_device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80));
-        class_device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i));
+        device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80));
+        device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i));
         return 0;
 }
 
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index 993fa7b892..721f86f4f0 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -56,10 +56,6 @@ config CPU_FREQ_STAT_DETAILS
 
           If in doubt, say N.
 
-# Note that it is not currently possible to set the other governors (such as ondemand)
-# as the default, since if they fail to initialise, cpufreq will be
-# left in an undefined state.
-
 choice
         prompt "Default CPUFreq governor"
         default CPU_FREQ_DEFAULT_GOV_USERSPACE if CPU_FREQ_SA1100 || CPU_FREQ_SA1110
@@ -85,6 +81,29 @@ config CPU_FREQ_DEFAULT_GOV_USERSPACE
           program shall be able to set the CPU dynamically without having
           to enable the userspace governor manually.
 
+config CPU_FREQ_DEFAULT_GOV_ONDEMAND
+        bool "ondemand"
+        select CPU_FREQ_GOV_ONDEMAND
+        select CPU_FREQ_GOV_PERFORMANCE
+        help
+          Use the CPUFreq governor 'ondemand' as default. This allows
+          you to get a full dynamic frequency capable system by simply
+          loading your cpufreq low-level hardware driver.
+          Be aware that not all cpufreq drivers support the ondemand
+          governor. If unsure have a look at the help section of the
+          driver. Fallback governor will be the performance governor.
+
+config CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
+        bool "conservative"
+        select CPU_FREQ_GOV_CONSERVATIVE
+        select CPU_FREQ_GOV_PERFORMANCE
+        help
+          Use the CPUFreq governor 'conservative' as default. This allows
+          you to get a full dynamic frequency capable system by simply
+          loading your cpufreq low-level hardware driver.
+          Be aware that not all cpufreq drivers support the conservative
+          governor. If unsure have a look at the help section of the
+          driver. Fallback governor will be the performance governor.
 endchoice
 
 config CPU_FREQ_GOV_PERFORMANCE
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 2f6a73c01b..5e626b12b9 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -763,6 +763,8 @@ static int cpufreq_add_dev (struct sys_device * sys_dev)
         init_completion(&policy->kobj_unregister);
         INIT_WORK(&policy->update, handle_update);
 
+        /* Set governor before ->init, so that driver could check it */
+        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
         /* call driver. From then on the cpufreq must be able
          * to accept all calls to ->verify and ->setpolicy for this CPU
          */
@@ -828,7 +830,7 @@ static int cpufreq_add_dev (struct sys_device * sys_dev)
         /* prepare interface data */
         policy->kobj.parent = &sys_dev->kobj;
         policy->kobj.ktype = &ktype_cpufreq;
-        strlcpy(policy->kobj.name, "cpufreq", KOBJ_NAME_LEN);
+        kobject_set_name(&policy->kobj, "cpufreq");
 
         ret = kobject_register(&policy->kobj);
         if (ret) {
@@ -1109,12 +1111,7 @@ unsigned int cpufreq_quick_get(unsigned int cpu)
         unsigned int ret_freq = 0;
 
         if (policy) {
-                if (unlikely(lock_policy_rwsem_read(cpu)))
-                        return ret_freq;
-
                 ret_freq = policy->cur;
-
-                unlock_policy_rwsem_read(cpu);
                 cpufreq_cpu_put(policy);
         }
 
@@ -1483,6 +1480,31 @@ static int __cpufreq_governor(struct cpufreq_policy *policy,
 {
         int ret;
 
+        /* Only must be defined when default governor is known to have latency
+           restrictions, like e.g. conservative or ondemand.
+           That this is the case is already ensured in Kconfig
+        */
+#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
+        struct cpufreq_governor *gov = &cpufreq_gov_performance;
+#else
+        struct cpufreq_governor *gov = NULL;
+#endif
+
+        if (policy->governor->max_transition_latency &&
+            policy->cpuinfo.transition_latency >
+            policy->governor->max_transition_latency) {
+                if (!gov)
+                        return -EINVAL;
+                else {
+                        printk(KERN_WARNING "%s governor failed, too long"
+                               " transition latency of HW, fallback"
+                               " to %s governor\n",
+                               policy->governor->name,
+                               gov->name);
+                        policy->governor = gov;
+                }
+        }
+
         if (!try_module_get(policy->governor->owner))
                 return -EINVAL;
 
@@ -1703,7 +1725,7 @@ int cpufreq_update_policy(unsigned int cpu)
 }
 EXPORT_SYMBOL(cpufreq_update_policy);
 
-static int cpufreq_cpu_callback(struct notifier_block *nfb,
+static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
                                         unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 26f440ccc3..4bd33ce8a6 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -58,7 +58,7 @@ static unsigned int 				def_sampling_rate;
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
 #define DEF_SAMPLING_DOWN_FACTOR                (1)
 #define MAX_SAMPLING_DOWN_FACTOR                (10)
-#define TRANSITION_LATENCY_LIMIT                (10 * 1000)
+#define TRANSITION_LATENCY_LIMIT                (10 * 1000 * 1000)
 
 static void do_dbs_timer(struct work_struct *work);
 
@@ -466,9 +466,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                     (!policy->cur))
                         return -EINVAL;
 
-                if (policy->cpuinfo.transition_latency >
-                                (TRANSITION_LATENCY_LIMIT * 1000))
-                        return -EINVAL;
                 if (this_dbs_info->enable) /* Already enabled */
                         break;
                  
@@ -551,15 +548,17 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
         return 0;
 }
 
-static struct cpufreq_governor cpufreq_gov_dbs = {
-        .name           = "conservative",
-        .governor       = cpufreq_governor_dbs,
-        .owner          = THIS_MODULE,
+struct cpufreq_governor cpufreq_gov_conservative = {
+        .name                   = "conservative",
+        .governor               = cpufreq_governor_dbs,
+        .max_transition_latency = TRANSITION_LATENCY_LIMIT,
+        .owner                  = THIS_MODULE,
 };
+EXPORT_SYMBOL(cpufreq_gov_conservative);
 
 static int __init cpufreq_gov_dbs_init(void)
 {
-        return cpufreq_register_governor(&cpufreq_gov_dbs);
+        return cpufreq_register_governor(&cpufreq_gov_conservative);
 }
 
 static void __exit cpufreq_gov_dbs_exit(void)
@@ -567,7 +566,7 @@ 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_dbs);
+        cpufreq_unregister_governor(&cpufreq_gov_conservative);
 }
 
 
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index e794527e49..369f445951 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -47,7 +47,7 @@ static unsigned int def_sampling_rate;
                         (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
-#define TRANSITION_LATENCY_LIMIT                (10 * 1000)
+#define TRANSITION_LATENCY_LIMIT                (10 * 1000 * 1000)
 
 static void do_dbs_timer(struct work_struct *work);
 
@@ -508,12 +508,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 if ((!cpu_online(cpu)) || (!policy->cur))
                         return -EINVAL;
 
-                if (policy->cpuinfo.transition_latency >
-                                (TRANSITION_LATENCY_LIMIT * 1000)) {
-                        printk(KERN_WARNING "ondemand governor failed to load "
-                               "due to too long transition latency\n");
-                        return -EINVAL;
-                }
                 if (this_dbs_info->enable) /* Already enabled */
                         break;
 
@@ -585,11 +579,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
         return 0;
 }
 
-static struct cpufreq_governor cpufreq_gov_dbs = {
-        .name = "ondemand",
-        .governor = cpufreq_governor_dbs,
-        .owner = THIS_MODULE,
+struct cpufreq_governor cpufreq_gov_ondemand = {
+        .name                   = "ondemand",
+        .governor               = cpufreq_governor_dbs,
+        .max_transition_latency = TRANSITION_LATENCY_LIMIT,
+        .owner                  = THIS_MODULE,
 };
+EXPORT_SYMBOL(cpufreq_gov_ondemand);
 
 static int __init cpufreq_gov_dbs_init(void)
 {
@@ -598,12 +594,12 @@ static int __init cpufreq_gov_dbs_init(void)
                 printk(KERN_ERR "Creation of kondemand failed\n");
                 return -EFAULT;
         }
-        return cpufreq_register_governor(&cpufreq_gov_dbs);
+        return cpufreq_register_governor(&cpufreq_gov_ondemand);
 }
 
 static void __exit cpufreq_gov_dbs_exit(void)
 {
-        cpufreq_unregister_governor(&cpufreq_gov_dbs);
+        cpufreq_unregister_governor(&cpufreq_gov_ondemand);
         destroy_workqueue(kondemand_wq);
 }
 
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index 917b9bab9c..8a45d0f93e 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -164,8 +164,7 @@ freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
         return -1;
 }
 
-static void
-cpufreq_stats_free_table (unsigned int cpu)
+static void __cpuexit cpufreq_stats_free_table(unsigned int cpu)
 {
         struct cpufreq_stats *stat = cpufreq_stats_table[cpu];
         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
@@ -305,8 +304,9 @@ cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val,
         return 0;
 }
 
-static int cpufreq_stat_cpu_callback(struct notifier_block *nfb,
-                                        unsigned long action, void *hcpu)
+static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb,
+                                               unsigned long action,
+                                               void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
 
@@ -323,7 +323,7 @@ static int cpufreq_stat_cpu_callback(struct notifier_block *nfb,
         return NOTIFY_OK;
 }
 
-static struct notifier_block cpufreq_stat_cpu_notifier =
+static struct notifier_block cpufreq_stat_cpu_notifier __cpuinitdata =
 {
         .notifier_call = cpufreq_stat_cpu_callback,
 };
@@ -356,8 +356,7 @@ __init cpufreq_stats_init(void)
 
         register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
         for_each_online_cpu(cpu) {
-                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier,
-                                CPU_ONLINE, (void *)(long)cpu);
+                cpufreq_update_policy(cpu);
         }
         return 0;
 }
@@ -372,13 +371,12 @@ __exit cpufreq_stats_exit(void)
                         CPUFREQ_TRANSITION_NOTIFIER);
         unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
         for_each_online_cpu(cpu) {
-                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier,
-                                                CPU_DEAD, (void *)(long)cpu);
+                cpufreq_stats_free_table(cpu);
         }
 }
 
 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");
 
diff --git a/drivers/edac/edac_mc_sysfs.c b/drivers/edac/edac_mc_sysfs.c
index 4a0576bd06..3706b2bc09 100644
--- a/drivers/edac/edac_mc_sysfs.c
+++ b/drivers/edac/edac_mc_sysfs.c
@@ -743,7 +743,7 @@ static struct kobj_type ktype_mc_set_attribs = {
  *      /sys/devices/system/edac/mc
  */
 static struct kset mc_kset = {
-        .kobj = {.name = "mc", .ktype = &ktype_mc_set_attribs },
+        .kobj = {.ktype = &ktype_mc_set_attribs },
         .ktype = &ktype_mci,
 };
 
@@ -1010,6 +1010,7 @@ int edac_sysfs_setup_mc_kset(void)
         }
 
         /* Init the MC's kobject */
+        kobject_set_name(&mc_kset.kobj, "mc");
         mc_kset.kobj.parent = &edac_class->kset.kobj;
 
         /* register the mc_kset */
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index d944647c82..4d4a473939 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -128,16 +128,11 @@ static int eisa_bus_match (struct device *dev, struct device_driver *drv)
         return 0;
 }
 
-static int eisa_bus_uevent(struct device *dev, char **envp, int num_envp,
-                           char *buffer, int buffer_size)
+static int eisa_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct eisa_device *edev = to_eisa_device(dev);
-        int i = 0;
-        int length = 0;
 
-        add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                       "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig);
-        envp[i] = NULL;
+        add_uevent_var(env, "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig);
         return 0;
 }
 
diff --git a/drivers/firewire/fw-device.c b/drivers/firewire/fw-device.c
index 2b65863416..56681b3b29 100644
--- a/drivers/firewire/fw-device.c
+++ b/drivers/firewire/fw-device.c
@@ -130,23 +130,16 @@ static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size)
 }
 
 static int
-fw_unit_uevent(struct device *dev, char **envp, int num_envp,
-               char *buffer, int buffer_size)
+fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct fw_unit *unit = fw_unit(dev);
         char modalias[64];
-        int length = 0;
-        int i = 0;
 
         get_modalias(unit, modalias, sizeof(modalias));
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "MODALIAS=%s", modalias))
+        if (add_uevent_var(env, "MODALIAS=%s", modalias))
                 return -ENOMEM;
 
-        envp[i] = NULL;
-
         return 0;
 }
 
diff --git a/drivers/firmware/dmi-id.c b/drivers/firmware/dmi-id.c
index 59c3b5aa89..b6e1eb77d1 100644
--- a/drivers/firmware/dmi-id.c
+++ b/drivers/firmware/dmi-id.c
@@ -13,21 +13,31 @@
 #include <linux/device.h>
 #include <linux/autoconf.h>
 
-#define DEFINE_DMI_ATTR(_name, _mode, _show)            \
-static struct device_attribute sys_dmi_##_name##_attr = \
-        __ATTR(_name, _mode, _show, NULL);
-
-#define DEFINE_DMI_ATTR_WITH_SHOW(_name, _mode, _field)                 \
-static ssize_t sys_dmi_##_name##_show(struct device *dev,               \
-                                      struct device_attribute *attr,    \
-                                      char *page)                       \
-{                                                                       \
-        ssize_t len;                                                    \
-        len = scnprintf(page, PAGE_SIZE, "%s\n", dmi_get_system_info(_field)); \
-        page[len-1] = '\n';                                             \
-        return len;                                                     \
-}                                                                       \
-DEFINE_DMI_ATTR(_name, _mode, sys_dmi_##_name##_show);
+struct dmi_device_attribute{
+        struct device_attribute dev_attr;
+        int field;
+};
+#define to_dmi_dev_attr(_dev_attr) \
+        container_of(_dev_attr, struct dmi_device_attribute, dev_attr)
+
+static ssize_t sys_dmi_field_show(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *page)
+{
+        int field = to_dmi_dev_attr(attr)->field;
+        ssize_t len;
+        len = scnprintf(page, PAGE_SIZE, "%s\n", dmi_get_system_info(field));
+        page[len-1] = '\n';
+        return len;
+}
+
+#define DMI_ATTR(_name, _mode, _show, _field)                   \
+        { .dev_attr = __ATTR(_name, _mode, _show, NULL),        \
+          .field = _field }
+
+#define DEFINE_DMI_ATTR_WITH_SHOW(_name, _mode, _field)         \
+static struct dmi_device_attribute sys_dmi_##_name##_attr =     \
+        DMI_ATTR(_name, _mode, sys_dmi_field_show, _field);
 
 DEFINE_DMI_ATTR_WITH_SHOW(bios_vendor,          0444, DMI_BIOS_VENDOR);
 DEFINE_DMI_ATTR_WITH_SHOW(bios_version,         0444, DMI_BIOS_VERSION);
@@ -121,7 +131,8 @@ static ssize_t sys_dmi_modalias_show(struct device *dev,
         return r+1;
 }
 
-DEFINE_DMI_ATTR(modalias, 0444, sys_dmi_modalias_show);
+static struct device_attribute sys_dmi_modalias_attr =
+        __ATTR(modalias, 0444, sys_dmi_modalias_show, NULL);
 
 static struct attribute *sys_dmi_attributes[DMI_STRING_MAX+2];
 
@@ -134,14 +145,17 @@ static struct attribute_group* sys_dmi_attribute_groups[] = {
         NULL
 };
 
-static int dmi_dev_uevent(struct device *dev, char **envp,
-                            int num_envp, char *buffer, int buffer_size)
+static int dmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        strcpy(buffer, "MODALIAS=");
-        get_modalias(buffer+9, buffer_size-9);
-        envp[0] = buffer;
-        envp[1] = NULL;
-
+        ssize_t len;
+
+        if (add_uevent_var(env, "MODALIAS="))
+                return -ENOMEM;
+        len = get_modalias(&env->buf[env->buflen - 1],
+                           sizeof(env->buf) - env->buflen);
+        if (len >= (sizeof(env->buf) - env->buflen))
+                return -ENOMEM;
+        env->buflen += len;
         return 0;
 }
 
@@ -157,7 +171,7 @@ static struct device *dmi_dev;
 
 #define ADD_DMI_ATTR(_name, _field) \
         if (dmi_get_system_info(_field)) \
-                sys_dmi_attributes[i++] = & sys_dmi_##_name##_attr.attr;
+                sys_dmi_attributes[i++] = &sys_dmi_##_name##_attr.dev_attr.attr;
 
 extern int dmi_available;
 
diff --git a/drivers/firmware/edd.c b/drivers/firmware/edd.c
index 0fb730ee1d..6942e065e6 100644
--- a/drivers/firmware/edd.c
+++ b/drivers/firmware/edd.c
@@ -625,13 +625,13 @@ static void edd_release(struct kobject * kobj)
         kfree(dev);
 }
 
-static struct kobj_type ktype_edd = {
+static struct kobj_type edd_ktype = {
         .release        = edd_release,
         .sysfs_ops      = &edd_attr_ops,
         .default_attrs  = def_attrs,
 };
 
-static decl_subsys(edd,&ktype_edd,NULL);
+static decl_subsys(edd, &edd_ktype, NULL);
 
 
 /**
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index bfd2d67df6..858a7b9593 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -402,7 +402,7 @@ static struct attribute *def_attrs[] = {
         NULL,
 };
 
-static struct kobj_type ktype_efivar = {
+static struct kobj_type efivar_ktype = {
         .release = efivar_release,
         .sysfs_ops = &efivar_attr_ops,
         .default_attrs = def_attrs,
@@ -583,7 +583,7 @@ static struct subsys_attribute *efi_subsys_attrs[] = {
         NULL,   /* maybe more in the future? */
 };
 
-static decl_subsys(vars, &ktype_efivar, NULL);
+static decl_subsys(vars, &efivar_ktype, NULL);
 static decl_subsys(efi, NULL, NULL);
 
 /*
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 9f3a4cd0b0..de95c75efb 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -75,11 +75,19 @@ config I2C_AMD8111
 
 config I2C_AT91
         tristate "Atmel AT91 I2C Two-Wire interface (TWI)"
-        depends on ARCH_AT91 && EXPERIMENTAL
+        depends on ARCH_AT91 && EXPERIMENTAL && BROKEN
         help
           This supports the use of the I2C interface on Atmel AT91
           processors.
 
+          This driver is BROKEN because the controller which it uses
+          will easily trigger RX overrun and TX underrun errors.  Using
+          low I2C clock rates may partially work around those issues
+          on some systems.  Another serious problem is that there is no
+          documented way to issue repeated START conditions, as needed
+          to support combined I2C messages.  Use the i2c-gpio driver
+          unless your system can cope with those limitations.
+
 config I2C_AU1550
         tristate "Au1550/Au1200 SMBus interface"
         depends on SOC_AU1550 || SOC_AU1200
@@ -106,6 +114,19 @@ config I2C_BLACKFIN_TWI_CLK_KHZ
         help
           The unit of the TWI clock is kHz.
 
+config I2C_DAVINCI
+        tristate "DaVinci I2C driver"
+        depends on ARCH_DAVINCI
+        help
+          Support for TI DaVinci I2C controller driver.
+
+          This driver can also be built as a module.  If so, the module
+          will be called i2c-davinci.
+
+          Please note that this driver might be needed to bring up other
+          devices such as DaVinci NIC.
+          For details please see http://www.ti.com/davinci
+
 config I2C_ELEKTOR
         tristate "Elektor ISA card"
         depends on ISA && BROKEN_ON_SMP
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 5b752e4e19..81d43c27cf 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_I2C_AMD8111)	+= i2c-amd8111.o
 obj-$(CONFIG_I2C_AT91)          += i2c-at91.o
 obj-$(CONFIG_I2C_AU1550)        += i2c-au1550.o
 obj-$(CONFIG_I2C_BLACKFIN_TWI)  += i2c-bfin-twi.o
+obj-$(CONFIG_I2C_DAVINCI)       += i2c-davinci.o
 obj-$(CONFIG_I2C_ELEKTOR)       += i2c-elektor.o
 obj-$(CONFIG_I2C_GPIO)          += i2c-gpio.o
 obj-$(CONFIG_I2C_HYDRA)         += i2c-hydra.o
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
index c9fca7b492..5d1a27ef25 100644
--- a/drivers/i2c/busses/i2c-amd8111.c
+++ b/drivers/i2c/busses/i2c-amd8111.c
@@ -326,7 +326,7 @@ static u32 amd8111_func(struct i2c_adapter *adapter)
                 I2C_FUNC_SMBUS_BYTE_DATA |
                 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA |
                 I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
-                I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_HWPEC_CALC;
+                I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_PEC;
 }
 
 static const struct i2c_algorithm smbus_algorithm = {
diff --git a/drivers/i2c/busses/i2c-au1550.c b/drivers/i2c/busses/i2c-au1550.c
index d7e7c359fc..2f684166c4 100644
--- a/drivers/i2c/busses/i2c-au1550.c
+++ b/drivers/i2c/busses/i2c-au1550.c
@@ -48,17 +48,14 @@ wait_xfer_done(struct i2c_au1550_data *adap)
 
         sp = (volatile psc_smb_t *)(adap->psc_base);
 
-        /* Wait for Tx FIFO Underflow.
+        /* Wait for Tx Buffer Empty
         */
         for (i = 0; i < adap->xfer_timeout; i++) {
-                stat = sp->psc_smbevnt;
+                stat = sp->psc_smbstat;
                 au_sync();
-                if ((stat & PSC_SMBEVNT_TU) != 0) {
-                        /* Clear it.  */
-                        sp->psc_smbevnt = PSC_SMBEVNT_TU;
-                        au_sync();
+                if ((stat & PSC_SMBSTAT_TE) != 0)
                         return 0;
-                }
+
                 udelay(1);
         }
 
diff --git a/drivers/i2c/busses/i2c-bfin-twi.c b/drivers/i2c/busses/i2c-bfin-twi.c
index 6311039dfe..67224a424a 100644
--- a/drivers/i2c/busses/i2c-bfin-twi.c
+++ b/drivers/i2c/busses/i2c-bfin-twi.c
@@ -44,7 +44,6 @@
 #define TWI_I2C_MODE_COMBINED           0x04
 
 struct bfin_twi_iface {
-        struct mutex            twi_lock;
         int                     irq;
         spinlock_t              lock;
         char                    read_write;
@@ -228,12 +227,8 @@ static int bfin_twi_master_xfer(struct i2c_adapter *adap,
         if (!(bfin_read_TWI_CONTROL() & TWI_ENA))
                 return -ENXIO;
 
-        mutex_lock(&iface->twi_lock);
-
         while (bfin_read_TWI_MASTER_STAT() & BUSBUSY) {
-                mutex_unlock(&iface->twi_lock);
                 yield();
-                mutex_lock(&iface->twi_lock);
         }
 
         ret = 0;
@@ -310,9 +305,6 @@ static int bfin_twi_master_xfer(struct i2c_adapter *adap,
                         break;
         }
 
-        /* Release mutex */
-        mutex_unlock(&iface->twi_lock);
-
         return ret;
 }
 
@@ -330,12 +322,8 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr,
         if (!(bfin_read_TWI_CONTROL() & TWI_ENA))
                 return -ENXIO;
 
-        mutex_lock(&iface->twi_lock);
-
         while (bfin_read_TWI_MASTER_STAT() & BUSBUSY) {
-                mutex_unlock(&iface->twi_lock);
                 yield();
-                mutex_lock(&iface->twi_lock);
         }
 
         iface->writeNum = 0;
@@ -502,9 +490,6 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr,
 
         rc = (iface->result >= 0) ? 0 : -1;
 
-        /* Release mutex */
-        mutex_unlock(&iface->twi_lock);
-
         return rc;
 }
 
@@ -555,7 +540,6 @@ static int i2c_bfin_twi_probe(struct platform_device *dev)
         struct i2c_adapter *p_adap;
         int rc;
 
-        mutex_init(&(iface->twi_lock));
         spin_lock_init(&(iface->lock));
         init_completion(&(iface->complete));
         iface->irq = IRQ_TWI;
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
new file mode 100644
index 0000000000..bd7aaff352
--- /dev/null
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -0,0 +1,586 @@
+/*
+ * TI DAVINCI I2C adapter driver.
+ *
+ * Copyright (C) 2006 Texas Instruments.
+ * Copyright (C) 2007 MontaVista Software Inc.
+ *
+ * Updated by Vinod & Sudhakar Feb 2005
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * ----------------------------------------------------------------------------
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/clk.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#include <asm/hardware.h>
+#include <asm/mach-types.h>
+
+#include <asm/arch/i2c.h>
+
+/* ----- global defines ----------------------------------------------- */
+
+#define DAVINCI_I2C_TIMEOUT     (1*HZ)
+#define I2C_DAVINCI_INTR_ALL    (DAVINCI_I2C_IMR_AAS | \
+                                 DAVINCI_I2C_IMR_SCD | \
+                                 DAVINCI_I2C_IMR_ARDY | \
+                                 DAVINCI_I2C_IMR_NACK | \
+                                 DAVINCI_I2C_IMR_AL)
+
+#define DAVINCI_I2C_OAR_REG     0x00
+#define DAVINCI_I2C_IMR_REG     0x04
+#define DAVINCI_I2C_STR_REG     0x08
+#define DAVINCI_I2C_CLKL_REG    0x0c
+#define DAVINCI_I2C_CLKH_REG    0x10
+#define DAVINCI_I2C_CNT_REG     0x14
+#define DAVINCI_I2C_DRR_REG     0x18
+#define DAVINCI_I2C_SAR_REG     0x1c
+#define DAVINCI_I2C_DXR_REG     0x20
+#define DAVINCI_I2C_MDR_REG     0x24
+#define DAVINCI_I2C_IVR_REG     0x28
+#define DAVINCI_I2C_EMDR_REG    0x2c
+#define DAVINCI_I2C_PSC_REG     0x30
+
+#define DAVINCI_I2C_IVR_AAS     0x07
+#define DAVINCI_I2C_IVR_SCD     0x06
+#define DAVINCI_I2C_IVR_XRDY    0x05
+#define DAVINCI_I2C_IVR_RDR     0x04
+#define DAVINCI_I2C_IVR_ARDY    0x03
+#define DAVINCI_I2C_IVR_NACK    0x02
+#define DAVINCI_I2C_IVR_AL      0x01
+
+#define DAVINCI_I2C_STR_BB      (1 << 12)
+#define DAVINCI_I2C_STR_RSFULL  (1 << 11)
+#define DAVINCI_I2C_STR_SCD     (1 << 5)
+#define DAVINCI_I2C_STR_ARDY    (1 << 2)
+#define DAVINCI_I2C_STR_NACK    (1 << 1)
+#define DAVINCI_I2C_STR_AL      (1 << 0)
+
+#define DAVINCI_I2C_MDR_NACK    (1 << 15)
+#define DAVINCI_I2C_MDR_STT     (1 << 13)
+#define DAVINCI_I2C_MDR_STP     (1 << 11)
+#define DAVINCI_I2C_MDR_MST     (1 << 10)
+#define DAVINCI_I2C_MDR_TRX     (1 << 9)
+#define DAVINCI_I2C_MDR_XA      (1 << 8)
+#define DAVINCI_I2C_MDR_IRS     (1 << 5)
+
+#define DAVINCI_I2C_IMR_AAS     (1 << 6)
+#define DAVINCI_I2C_IMR_SCD     (1 << 5)
+#define DAVINCI_I2C_IMR_XRDY    (1 << 4)
+#define DAVINCI_I2C_IMR_RRDY    (1 << 3)
+#define DAVINCI_I2C_IMR_ARDY    (1 << 2)
+#define DAVINCI_I2C_IMR_NACK    (1 << 1)
+#define DAVINCI_I2C_IMR_AL      (1 << 0)
+
+#define MOD_REG_BIT(val, mask, set) do { \
+        if (set) { \
+                val |= mask; \
+        } else { \
+                val &= ~mask; \
+        } \
+} while (0)
+
+struct davinci_i2c_dev {
+        struct device           *dev;
+        void __iomem            *base;
+        struct completion       cmd_complete;
+        struct clk              *clk;
+        int                     cmd_err;
+        u8                      *buf;
+        size_t                  buf_len;
+        int                     irq;
+        struct i2c_adapter      adapter;
+};
+
+/* default platform data to use if not supplied in the platform_device */
+static struct davinci_i2c_platform_data davinci_i2c_platform_data_default = {
+        .bus_freq       = 100,
+        .bus_delay      = 0,
+};
+
+static inline void davinci_i2c_write_reg(struct davinci_i2c_dev *i2c_dev,
+                                         int reg, u16 val)
+{
+        __raw_writew(val, i2c_dev->base + reg);
+}
+
+static inline u16 davinci_i2c_read_reg(struct davinci_i2c_dev *i2c_dev, int reg)
+{
+        return __raw_readw(i2c_dev->base + reg);
+}
+
+/*
+ * This functions configures I2C and brings I2C out of reset.
+ * This function is called during I2C init function. This function
+ * also gets called if I2C encounters any errors.
+ */
+static int i2c_davinci_init(struct davinci_i2c_dev *dev)
+{
+        struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
+        u16 psc;
+        u32 clk;
+        u32 clkh;
+        u32 clkl;
+        u32 input_clock = clk_get_rate(dev->clk);
+        u16 w;
+
+        if (!pdata)
+                pdata = &davinci_i2c_platform_data_default;
+
+        /* put I2C into reset */
+        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+        MOD_REG_BIT(w, DAVINCI_I2C_MDR_IRS, 0);
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
+
+        /* NOTE: I2C Clock divider programming info
+         * As per I2C specs the following formulas provide prescaler
+         * and low/high divider values
+         * input clk --> PSC Div -----------> ICCL/H Div --> output clock
+         *                       module clk
+         *
+         * output clk = module clk / (PSC + 1) [ (ICCL + d) + (ICCH + d) ]
+         *
+         * Thus,
+         * (ICCL + ICCH) = clk = (input clk / ((psc +1) * output clk)) - 2d;
+         *
+         * where if PSC == 0, d = 7,
+         *       if PSC == 1, d = 6
+         *       if PSC > 1 , d = 5
+         */
+
+        psc = 26; /* To get 1MHz clock */
+
+        clk = ((input_clock / (psc + 1)) / (pdata->bus_freq * 1000)) - 10;
+        clkh = (50 * clk) / 100;
+        clkl = clk - clkh;
+
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_PSC_REG, psc);
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKH_REG, clkh);
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKL_REG, clkl);
+
+        dev_dbg(dev->dev, "CLK  = %d\n", clk);
+        dev_dbg(dev->dev, "PSC  = %d\n",
+                davinci_i2c_read_reg(dev, DAVINCI_I2C_PSC_REG));
+        dev_dbg(dev->dev, "CLKL = %d\n",
+                davinci_i2c_read_reg(dev, DAVINCI_I2C_CLKL_REG));
+        dev_dbg(dev->dev, "CLKH = %d\n",
+                davinci_i2c_read_reg(dev, DAVINCI_I2C_CLKH_REG));
+
+        /* Take the I2C module out of reset: */
+        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+        MOD_REG_BIT(w, DAVINCI_I2C_MDR_IRS, 1);
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
+
+        /* Enable interrupts */
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, I2C_DAVINCI_INTR_ALL);
+
+        return 0;
+}
+
+/*
+ * Waiting for bus not busy
+ */
+static int i2c_davinci_wait_bus_not_busy(struct davinci_i2c_dev *dev,
+                                         char allow_sleep)
+{
+        unsigned long timeout;
+
+        timeout = jiffies + DAVINCI_I2C_TIMEOUT;
+        while (davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG)
+               & DAVINCI_I2C_STR_BB) {
+                if (time_after(jiffies, timeout)) {
+                        dev_warn(dev->dev,
+                                 "timeout waiting for bus ready\n");
+                        return -ETIMEDOUT;
+                }
+                if (allow_sleep)
+                        schedule_timeout(1);
+        }
+
+        return 0;
+}
+
+/*
+ * Low level master read/write transaction. This function is called
+ * from i2c_davinci_xfer.
+ */
+static int
+i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
+{
+        struct davinci_i2c_dev *dev = i2c_get_adapdata(adap);
+        struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
+        u32 flag;
+        u32 stat;
+        u16 w;
+        int r;
+
+        if (msg->len == 0)
+                return -EINVAL;
+
+        if (!pdata)
+                pdata = &davinci_i2c_platform_data_default;
+        /* Introduce a delay, required for some boards (e.g Davinci EVM) */
+        if (pdata->bus_delay)
+                udelay(pdata->bus_delay);
+
+        /* set the slave address */
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_SAR_REG, msg->addr);
+
+        dev->buf = msg->buf;
+        dev->buf_len = msg->len;
+
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_CNT_REG, dev->buf_len);
+
+        init_completion(&dev->cmd_complete);
+        dev->cmd_err = 0;
+
+        /* Clear any pending interrupts by reading the IVR */
+        stat = davinci_i2c_read_reg(dev, DAVINCI_I2C_IVR_REG);
+
+        /* Take I2C out of reset, configure it as master and set the
+         * start bit */
+        flag = DAVINCI_I2C_MDR_IRS | DAVINCI_I2C_MDR_MST | DAVINCI_I2C_MDR_STT;
+
+        /* if the slave address is ten bit address, enable XA bit */
+        if (msg->flags & I2C_M_TEN)
+                flag |= DAVINCI_I2C_MDR_XA;
+        if (!(msg->flags & I2C_M_RD))
+                flag |= DAVINCI_I2C_MDR_TRX;
+        if (stop)
+                flag |= DAVINCI_I2C_MDR_STP;
+
+        /* Enable receive or transmit interrupts */
+        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_IMR_REG);
+        if (msg->flags & I2C_M_RD)
+                MOD_REG_BIT(w, DAVINCI_I2C_IMR_RRDY, 1);
+        else
+                MOD_REG_BIT(w, DAVINCI_I2C_IMR_XRDY, 1);
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, w);
+
+        /* write the data into mode register */
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
+
+        r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
+                                                      DAVINCI_I2C_TIMEOUT);
+        dev->buf_len = 0;
+        if (r < 0)
+                return r;
+
+        if (r == 0) {
+                dev_err(dev->dev, "controller timed out\n");
+                i2c_davinci_init(dev);
+                return -ETIMEDOUT;
+        }
+
+        /* no error */
+        if (likely(!dev->cmd_err))
+                return msg->len;
+
+        /* We have an error */
+        if (dev->cmd_err & DAVINCI_I2C_STR_AL) {
+                i2c_davinci_init(dev);
+                return -EIO;
+        }
+
+        if (dev->cmd_err & DAVINCI_I2C_STR_NACK) {
+                if (msg->flags & I2C_M_IGNORE_NAK)
+                        return msg->len;
+                if (stop) {
+                        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+                        MOD_REG_BIT(w, DAVINCI_I2C_MDR_STP, 1);
+                        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
+                }
+                return -EREMOTEIO;
+        }
+        return -EIO;
+}
+
+/*
+ * Prepare controller for a transaction and call i2c_davinci_xfer_msg
+ */
+static int
+i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
+{
+        struct davinci_i2c_dev *dev = i2c_get_adapdata(adap);
+        int i;
+        int ret;
+
+        dev_dbg(dev->dev, "%s: msgs: %d\n", __FUNCTION__, num);
+
+        ret = i2c_davinci_wait_bus_not_busy(dev, 1);
+        if (ret < 0) {
+                dev_warn(dev->dev, "timeout waiting for bus ready\n");
+                return ret;
+        }
+
+        for (i = 0; i < num; i++) {
+                ret = i2c_davinci_xfer_msg(adap, &msgs[i], (i == (num - 1)));
+                if (ret < 0)
+                        return ret;
+        }
+
+        dev_dbg(dev->dev, "%s:%d ret: %d\n", __FUNCTION__, __LINE__, ret);
+
+        return num;
+}
+
+static u32 i2c_davinci_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK);
+}
+
+/*
+ * Interrupt service routine. This gets called whenever an I2C interrupt
+ * occurs.
+ */
+static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id)
+{
+        struct davinci_i2c_dev *dev = dev_id;
+        u32 stat;
+        int count = 0;
+        u16 w;
+
+        while ((stat = davinci_i2c_read_reg(dev, DAVINCI_I2C_IVR_REG))) {
+                dev_dbg(dev->dev, "%s: stat=0x%x\n", __FUNCTION__, stat);
+                if (count++ == 100) {
+                        dev_warn(dev->dev, "Too much work in one IRQ\n");
+                        break;
+                }
+
+                switch (stat) {
+                case DAVINCI_I2C_IVR_AL:
+                        dev->cmd_err |= DAVINCI_I2C_STR_AL;
+                        complete(&dev->cmd_complete);
+                        break;
+
+                case DAVINCI_I2C_IVR_NACK:
+                        dev->cmd_err |= DAVINCI_I2C_STR_NACK;
+                        complete(&dev->cmd_complete);
+                        break;
+
+                case DAVINCI_I2C_IVR_ARDY:
+                        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG);
+                        MOD_REG_BIT(w, DAVINCI_I2C_STR_ARDY, 1);
+                        davinci_i2c_write_reg(dev, DAVINCI_I2C_STR_REG, w);
+                        complete(&dev->cmd_complete);
+                        break;
+
+                case DAVINCI_I2C_IVR_RDR:
+                        if (dev->buf_len) {
+                                *dev->buf++ =
+                                    davinci_i2c_read_reg(dev,
+                                                         DAVINCI_I2C_DRR_REG);
+                                dev->buf_len--;
+                                if (dev->buf_len)
+                                        continue;
+
+                                w = davinci_i2c_read_reg(dev,
+                                                         DAVINCI_I2C_STR_REG);
+                                MOD_REG_BIT(w, DAVINCI_I2C_IMR_RRDY, 0);
+                                davinci_i2c_write_reg(dev,
+                                                      DAVINCI_I2C_STR_REG,
+                                                      w);
+                        } else
+                                dev_err(dev->dev, "RDR IRQ while no"
+                                        "data requested\n");
+                        break;
+
+                case DAVINCI_I2C_IVR_XRDY:
+                        if (dev->buf_len) {
+                                davinci_i2c_write_reg(dev, DAVINCI_I2C_DXR_REG,
+                                                      *dev->buf++);
+                                dev->buf_len--;
+                                if (dev->buf_len)
+                                        continue;
+
+                                w = davinci_i2c_read_reg(dev,
+                                                         DAVINCI_I2C_IMR_REG);
+                                MOD_REG_BIT(w, DAVINCI_I2C_IMR_XRDY, 0);
+                                davinci_i2c_write_reg(dev,
+                                                      DAVINCI_I2C_IMR_REG,
+                                                      w);
+                        } else
+                                dev_err(dev->dev, "TDR IRQ while no data to"
+                                        "send\n");
+                        break;
+
+                case DAVINCI_I2C_IVR_SCD:
+                        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG);
+                        MOD_REG_BIT(w, DAVINCI_I2C_STR_SCD, 1);
+                        davinci_i2c_write_reg(dev, DAVINCI_I2C_STR_REG, w);
+                        complete(&dev->cmd_complete);
+                        break;
+
+                case DAVINCI_I2C_IVR_AAS:
+                        dev_warn(dev->dev, "Address as slave interrupt\n");
+                }/* switch */
+        }/* while */
+
+        return count ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static struct i2c_algorithm i2c_davinci_algo = {
+        .master_xfer    = i2c_davinci_xfer,
+        .functionality  = i2c_davinci_func,
+};
+
+static int davinci_i2c_probe(struct platform_device *pdev)
+{
+        struct davinci_i2c_dev *dev;
+        struct i2c_adapter *adap;
+        struct resource *mem, *irq, *ioarea;
+        int r;
+
+        /* NOTE: driver uses the static register mapping */
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                dev_err(&pdev->dev, "no mem resource?\n");
+                return -ENODEV;
+        }
+
+        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "no irq resource?\n");
+                return -ENODEV;
+        }
+
+        ioarea = request_mem_region(mem->start, (mem->end - mem->start) + 1,
+                                    pdev->name);
+        if (!ioarea) {
+                dev_err(&pdev->dev, "I2C region already claimed\n");
+                return -EBUSY;
+        }
+
+        dev = kzalloc(sizeof(struct davinci_i2c_dev), GFP_KERNEL);
+        if (!dev) {
+                r = -ENOMEM;
+                goto err_release_region;
+        }
+
+        dev->dev = get_device(&pdev->dev);
+        dev->irq = irq->start;
+        platform_set_drvdata(pdev, dev);
+
+        dev->clk = clk_get(&pdev->dev, "I2CCLK");
+        if (IS_ERR(dev->clk)) {
+                r = -ENODEV;
+                goto err_free_mem;
+        }
+        clk_enable(dev->clk);
+
+        dev->base = (void __iomem *)IO_ADDRESS(mem->start);
+        i2c_davinci_init(dev);
+
+        r = request_irq(dev->irq, i2c_davinci_isr, 0, pdev->name, dev);
+        if (r) {
+                dev_err(&pdev->dev, "failure requesting irq %i\n", dev->irq);
+                goto err_unuse_clocks;
+        }
+
+        adap = &dev->adapter;
+        i2c_set_adapdata(adap, dev);
+        adap->owner = THIS_MODULE;
+        adap->class = I2C_CLASS_HWMON;
+        strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
+        adap->algo = &i2c_davinci_algo;
+        adap->dev.parent = &pdev->dev;
+
+        /* FIXME */
+        adap->timeout = 1;
+        adap->retries = 1;
+
+        adap->nr = pdev->id;
+        r = i2c_add_numbered_adapter(adap);
+        if (r) {
+                dev_err(&pdev->dev, "failure adding adapter\n");
+                goto err_free_irq;
+        }
+
+        return 0;
+
+err_free_irq:
+        free_irq(dev->irq, dev);
+err_unuse_clocks:
+        clk_disable(dev->clk);
+        clk_put(dev->clk);
+        dev->clk = NULL;
+err_free_mem:
+        platform_set_drvdata(pdev, NULL);
+        put_device(&pdev->dev);
+        kfree(dev);
+err_release_region:
+        release_mem_region(mem->start, (mem->end - mem->start) + 1);
+
+        return r;
+}
+
+static int davinci_i2c_remove(struct platform_device *pdev)
+{
+        struct davinci_i2c_dev *dev = platform_get_drvdata(pdev);
+        struct resource *mem;
+
+        platform_set_drvdata(pdev, NULL);
+        i2c_del_adapter(&dev->adapter);
+        put_device(&pdev->dev);
+
+        clk_disable(dev->clk);
+        clk_put(dev->clk);
+        dev->clk = NULL;
+
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, 0);
+        free_irq(IRQ_I2C, dev);
+        kfree(dev);
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(mem->start, (mem->end - mem->start) + 1);
+        return 0;
+}
+
+static struct platform_driver davinci_i2c_driver = {
+        .probe          = davinci_i2c_probe,
+        .remove         = davinci_i2c_remove,
+        .driver         = {
+                .name   = "i2c_davinci",
+                .owner  = THIS_MODULE,
+        },
+};
+
+/* I2C may be needed to bring up other drivers */
+static int __init davinci_i2c_init_driver(void)
+{
+        return platform_driver_register(&davinci_i2c_driver);
+}
+subsys_initcall(davinci_i2c_init_driver);
+
+static void __exit davinci_i2c_exit_driver(void)
+{
+        platform_driver_unregister(&davinci_i2c_driver);
+}
+module_exit(davinci_i2c_exit_driver);
+
+MODULE_AUTHOR("Texas Instruments India");
+MODULE_DESCRIPTION("TI DaVinci I2C bus adapter");
+MODULE_LICENSE("GPL");
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index 289816db52..ac27e5f84e 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -34,6 +34,7 @@
     ESB2                269B
     ICH8                283E
     ICH9                2930
+    Tolapai             5032
     This driver supports several versions of Intel's I/O Controller Hubs (ICH).
     For SMBus support, they are similar to the PIIX4 and are part
     of Intel's '810' and other chipsets.
@@ -515,7 +516,7 @@ static u32 i801_func(struct i2c_adapter *adapter)
         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
             I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
             I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
-             | (isich4 ? I2C_FUNC_SMBUS_HWPEC_CALC : 0);
+             | (isich4 ? I2C_FUNC_SMBUS_PEC : 0);
 }
 
 static const struct i2c_algorithm smbus_algorithm = {
@@ -543,6 +544,7 @@ static struct pci_device_id i801_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_6) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TOLAPAI_1) },
         { 0, }
 };
 
@@ -563,6 +565,7 @@ static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id
         case PCI_DEVICE_ID_INTEL_ESB2_17:
         case PCI_DEVICE_ID_INTEL_ICH8_5:
         case PCI_DEVICE_ID_INTEL_ICH9_6:
+        case PCI_DEVICE_ID_INTEL_TOLAPAI_1:
                 isich4 = 1;
                 break;
         default:
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 8b14d14e60..e08bacadd6 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -738,7 +738,14 @@ static int __devinit iic_probe(struct ocp_device *ocp){
         adap->timeout = 1;
         adap->retries = 1;
 
-        if ((ret = i2c_add_adapter(adap)) != 0){
+        /*
+         * If "dev->idx" is negative we consider it as zero.
+         * The reason to do so is to avoid sysfs names that only make
+         * sense when there are multiple adapters.
+         */
+        adap->nr = dev->idx >= 0 ? dev->idx : 0;
+
+        if ((ret = i2c_add_numbered_adapter(adap)) < 0) {
                 printk(KERN_CRIT "ibm-iic%d: failed to register i2c adapter\n",
                         dev->idx);
                 goto fail;
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index ace644e21b..c70146e4c2 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -389,13 +389,6 @@ iop3xx_i2c_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs,
         return im;   
 }
 
-static int 
-iop3xx_i2c_algo_control(struct i2c_adapter *adapter, unsigned int cmd,
-                        unsigned long arg)
-{
-        return 0;
-}
-
 static u32 
 iop3xx_i2c_func(struct i2c_adapter *adap)
 {
@@ -404,7 +397,6 @@ iop3xx_i2c_func(struct i2c_adapter *adap)
 
 static const struct i2c_algorithm iop3xx_i2c_algo = {
         .master_xfer    = iop3xx_i2c_master_xfer,
-        .algo_control   = iop3xx_i2c_algo_control,
         .functionality  = iop3xx_i2c_func,
 };
 
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index c48140f782..1bf590c741 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -62,6 +62,7 @@ struct nforce2_smbus {
         int base;
         int size;
         int blockops;
+        int can_abort;
 };
 
 
@@ -83,7 +84,14 @@ struct nforce2_smbus {
 #define NVIDIA_SMB_DATA         (smbus->base + 0x04)    /* 32 data registers */
 #define NVIDIA_SMB_BCNT         (smbus->base + 0x24)    /* number of data
                                                            bytes */
-
+#define NVIDIA_SMB_STATUS_ABRT  (smbus->base + 0x3c)    /* register used to
+                                                           check the status of
+                                                           the abort command */
+#define NVIDIA_SMB_CTRL         (smbus->base + 0x3e)    /* control register */
+
+#define NVIDIA_SMB_STATUS_ABRT_STS      0x01            /* Bit to notify that
+                                                           abort succeeded */
+#define NVIDIA_SMB_CTRL_ABORT   0x20
 #define NVIDIA_SMB_STS_DONE     0x80
 #define NVIDIA_SMB_STS_ALRM     0x40
 #define NVIDIA_SMB_STS_RES      0x20
@@ -98,15 +106,61 @@ struct nforce2_smbus {
 #define NVIDIA_SMB_PRTCL_BLOCK_DATA             0x0a
 #define NVIDIA_SMB_PRTCL_PEC                    0x80
 
+/* Misc definitions */
+#define MAX_TIMEOUT     100
+
 static struct pci_driver nforce2_driver;
 
+static void nforce2_abort(struct i2c_adapter *adap)
+{
+        struct nforce2_smbus *smbus = adap->algo_data;
+        int timeout = 0;
+        unsigned char temp;
+
+        dev_dbg(&adap->dev, "Aborting current transaction\n");
+
+        outb_p(NVIDIA_SMB_CTRL_ABORT, NVIDIA_SMB_CTRL);
+        do {
+                msleep(1);
+                temp = inb_p(NVIDIA_SMB_STATUS_ABRT);
+        } while (!(temp & NVIDIA_SMB_STATUS_ABRT_STS) &&
+                        (timeout++ < MAX_TIMEOUT));
+        if (!(temp & NVIDIA_SMB_STATUS_ABRT_STS))
+                dev_err(&adap->dev, "Can't reset the smbus\n");
+        outb_p(NVIDIA_SMB_STATUS_ABRT_STS, NVIDIA_SMB_STATUS_ABRT);
+}
+
+static int nforce2_check_status(struct i2c_adapter *adap)
+{
+        struct nforce2_smbus *smbus = adap->algo_data;
+        int timeout = 0;
+        unsigned char temp;
+
+        do {
+                msleep(1);
+                temp = inb_p(NVIDIA_SMB_STS);
+        } while ((!temp) && (timeout++ < MAX_TIMEOUT));
+
+        if (timeout >= MAX_TIMEOUT) {
+                dev_dbg(&adap->dev, "SMBus Timeout!\n");
+                if (smbus->can_abort)
+                        nforce2_abort(adap);
+                return -1;
+        }
+        if (!(temp & NVIDIA_SMB_STS_DONE) || (temp & NVIDIA_SMB_STS_STATUS)) {
+                dev_dbg(&adap->dev, "Transaction failed (0x%02x)!\n", temp);
+                return -1;
+        }
+        return 0;
+}
+
 /* Return -1 on error */
 static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
                 unsigned short flags, char read_write,
                 u8 command, int size, union i2c_smbus_data * data)
 {
         struct nforce2_smbus *smbus = adap->algo_data;
-        unsigned char protocol, pec, temp;
+        unsigned char protocol, pec;
         u8 len;
         int i;
 
@@ -170,21 +224,8 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
         outb_p((addr & 0x7f) << 1, NVIDIA_SMB_ADDR);
         outb_p(protocol, NVIDIA_SMB_PRTCL);
 
-        temp = inb_p(NVIDIA_SMB_STS);
-
-        if (~temp & NVIDIA_SMB_STS_DONE) {
-                udelay(500);
-                temp = inb_p(NVIDIA_SMB_STS);
-        }
-        if (~temp & NVIDIA_SMB_STS_DONE) {
-                msleep(10);
-                temp = inb_p(NVIDIA_SMB_STS);
-        }
-
-        if ((~temp & NVIDIA_SMB_STS_DONE) || (temp & NVIDIA_SMB_STS_STATUS)) {
-                dev_dbg(&adap->dev, "SMBus Timeout! (0x%02x)\n", temp);
+        if (nforce2_check_status(adap))
                 return -1;
-        }
 
         if (read_write == I2C_SMBUS_WRITE)
                 return 0;
@@ -202,7 +243,12 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
 
                 case I2C_SMBUS_BLOCK_DATA:
                         len = inb_p(NVIDIA_SMB_BCNT);
-                        len = min_t(u8, len, I2C_SMBUS_BLOCK_MAX);
+                        if ((len <= 0) || (len > I2C_SMBUS_BLOCK_MAX)) {
+                                dev_err(&adap->dev, "Transaction failed "
+                                        "(received block size: 0x%02x)\n",
+                                        len);
+                                return -1;
+                        }
                         for (i = 0; i < len; i++)
                                 data->block[i+1] = inb_p(NVIDIA_SMB_DATA + i);
                         data->block[0] = len;
@@ -218,6 +264,7 @@ static u32 nforce2_func(struct i2c_adapter *adapter)
         /* other functionality might be possible, but is not tested */
         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
                I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+               I2C_FUNC_SMBUS_PEC |
                (((struct nforce2_smbus*)adapter->algo_data)->blockops ?
                 I2C_FUNC_SMBUS_BLOCK_DATA : 0);
 }
@@ -308,6 +355,8 @@ static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_
         case PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS:
                 smbuses[0].blockops = 1;
                 smbuses[1].blockops = 1;
+                smbuses[0].can_abort = 1;
+                smbuses[1].can_abort = 1;
         }
 
         /* SMBus adapter 1 */
diff --git a/drivers/i2c/busses/i2c-stub.c b/drivers/i2c/busses/i2c-stub.c
index a54adc50d1..84df29da1d 100644
--- a/drivers/i2c/busses/i2c-stub.c
+++ b/drivers/i2c/busses/i2c-stub.c
@@ -24,24 +24,41 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/i2c.h>
 
-static unsigned short chip_addr;
-module_param(chip_addr, ushort, S_IRUGO);
-MODULE_PARM_DESC(chip_addr, "Chip address (between 0x03 and 0x77)\n");
+#define MAX_CHIPS 10
 
-static u8  stub_pointer;
-static u8  stub_bytes[256];
-static u16 stub_words[256];
+static unsigned short chip_addr[MAX_CHIPS];
+module_param_array(chip_addr, ushort, NULL, S_IRUGO);
+MODULE_PARM_DESC(chip_addr,
+                 "Chip addresses (up to 10, between 0x03 and 0x77)\n");
+
+struct stub_chip {
+        u8 pointer;
+        u8 bytes[256];
+        u16 words[256];
+};
+
+static struct stub_chip *stub_chips;
 
 /* Return -1 on error. */
 static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
         char read_write, u8 command, int size, union i2c_smbus_data * data)
 {
         s32 ret;
-
-        if (addr != chip_addr)
+        int i;
+        struct stub_chip *chip = NULL;
+
+        /* Search for the right chip */
+        for (i = 0; i < MAX_CHIPS && chip_addr[i]; i++) {
+                if (addr == chip_addr[i]) {
+                        chip = stub_chips + i;
+                        break;
+                }
+        }
+        if (!chip)
                 return -ENODEV;
 
         switch (size) {
@@ -53,12 +70,12 @@ static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
 
         case I2C_SMBUS_BYTE:
                 if (read_write == I2C_SMBUS_WRITE) {
-                        stub_pointer = command;
+                        chip->pointer = command;
                         dev_dbg(&adap->dev, "smbus byte - addr 0x%02x, "
                                         "wrote 0x%02x.\n",
                                         addr, command);
                 } else {
-                        data->byte = stub_bytes[stub_pointer++];
+                        data->byte = chip->bytes[chip->pointer++];
                         dev_dbg(&adap->dev, "smbus byte - addr 0x%02x, "
                                         "read  0x%02x.\n",
                                         addr, data->byte);
@@ -69,29 +86,29 @@ static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
 
         case I2C_SMBUS_BYTE_DATA:
                 if (read_write == I2C_SMBUS_WRITE) {
-                        stub_bytes[command] = data->byte;
+                        chip->bytes[command] = data->byte;
                         dev_dbg(&adap->dev, "smbus byte data - addr 0x%02x, "
                                         "wrote 0x%02x at 0x%02x.\n",
                                         addr, data->byte, command);
                 } else {
-                        data->byte = stub_bytes[command];
+                        data->byte = chip->bytes[command];
                         dev_dbg(&adap->dev, "smbus byte data - addr 0x%02x, "
                                         "read  0x%02x at 0x%02x.\n",
                                         addr, data->byte, command);
                 }
-                stub_pointer = command + 1;
+                chip->pointer = command + 1;
 
                 ret = 0;
                 break;
 
         case I2C_SMBUS_WORD_DATA:
                 if (read_write == I2C_SMBUS_WRITE) {
-                        stub_words[command] = data->word;
+                        chip->words[command] = data->word;
                         dev_dbg(&adap->dev, "smbus word data - addr 0x%02x, "
                                         "wrote 0x%04x at 0x%02x.\n",
                                         addr, data->word, command);
                 } else {
-                        data->word = stub_words[command];
+                        data->word = chip->words[command];
                         dev_dbg(&adap->dev, "smbus word data - addr 0x%02x, "
                                         "read  0x%04x at 0x%02x.\n",
                                         addr, data->word, command);
@@ -129,23 +146,41 @@ static struct i2c_adapter stub_adapter = {
 
 static int __init i2c_stub_init(void)
 {
-        if (!chip_addr) {
+        int i, ret;
+
+        if (!chip_addr[0]) {
                 printk(KERN_ERR "i2c-stub: Please specify a chip address\n");
                 return -ENODEV;
         }
-        if (chip_addr < 0x03 || chip_addr > 0x77) {
-                printk(KERN_ERR "i2c-stub: Invalid chip address 0x%02x\n",
-                       chip_addr);
-                return -EINVAL;
+
+        for (i = 0; i < MAX_CHIPS && chip_addr[i]; i++) {
+                if (chip_addr[i] < 0x03 || chip_addr[i] > 0x77) {
+                        printk(KERN_ERR "i2c-stub: Invalid chip address "
+                               "0x%02x\n", chip_addr[i]);
+                        return -EINVAL;
+                }
+
+                printk(KERN_INFO "i2c-stub: Virtual chip at 0x%02x\n",
+                       chip_addr[i]);
         }
 
-        printk(KERN_INFO "i2c-stub: Virtual chip at 0x%02x\n", chip_addr);
-        return i2c_add_adapter(&stub_adapter);
+        /* Allocate memory for all chips at once */
+        stub_chips = kzalloc(i * sizeof(struct stub_chip), GFP_KERNEL);
+        if (!stub_chips) {
+                printk(KERN_ERR "i2c-stub: Out of memory\n");
+                return -ENOMEM;
+        }
+
+        ret = i2c_add_adapter(&stub_adapter);
+        if (ret)
+                kfree(stub_chips);
+        return ret;
 }
 
 static void __exit i2c_stub_exit(void)
 {
         i2c_del_adapter(&stub_adapter);
+        kfree(stub_chips);
 }
 
 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
diff --git a/drivers/i2c/chips/pcf8574.c b/drivers/i2c/chips/pcf8574.c
index 32b25427ea..21c6dd6919 100644
--- a/drivers/i2c/chips/pcf8574.c
+++ b/drivers/i2c/chips/pcf8574.c
@@ -48,14 +48,11 @@ static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
 /* Insmod parameters */
 I2C_CLIENT_INSMOD_2(pcf8574, pcf8574a);
 
-/* Initial values */
-#define PCF8574_INIT 255        /* All outputs on (input mode) */
-
 /* Each client has this additional data */
 struct pcf8574_data {
         struct i2c_client client;
 
-        u8 write;                       /* Remember last written value */
+        int write;                      /* Remember last written value */
 };
 
 static int pcf8574_attach_adapter(struct i2c_adapter *adapter);
@@ -85,7 +82,11 @@ static DEVICE_ATTR(read, S_IRUGO, show_read, NULL);
 static ssize_t show_write(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct pcf8574_data *data = i2c_get_clientdata(to_i2c_client(dev));
-        return sprintf(buf, "%u\n", data->write);
+
+        if (data->write < 0)
+                return data->write;
+
+        return sprintf(buf, "%d\n", data->write);
 }
 
 static ssize_t set_write(struct device *dev, struct device_attribute *attr, const char *buf,
@@ -206,8 +207,7 @@ static int pcf8574_detach_client(struct i2c_client *client)
 static void pcf8574_init_client(struct i2c_client *client)
 {
         struct pcf8574_data *data = i2c_get_clientdata(client);
-        data->write = PCF8574_INIT;
-        i2c_smbus_write_byte(client, data->write);
+        data->write = -EAGAIN;
 }
 
 static int __init pcf8574_init(void)
diff --git a/drivers/i2c/chips/tps65010.c b/drivers/i2c/chips/tps65010.c
index 503ffec2ce..e320994b98 100644
--- a/drivers/i2c/chips/tps65010.c
+++ b/drivers/i2c/chips/tps65010.c
@@ -24,20 +24,13 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
-#include <linux/device.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
-#include <linux/suspend.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
 
-#include <asm/irq.h>
-#include <asm/mach-types.h>
-
-#include <asm/arch/gpio.h>
-#include <asm/arch/mux.h>
 #include <asm/arch/tps65010.h>
 
 /*-------------------------------------------------------------------------*/
@@ -48,10 +41,6 @@
 MODULE_DESCRIPTION("TPS6501x Power Management Driver");
 MODULE_LICENSE("GPL");
 
-static unsigned short normal_i2c[] = { 0x48, /* 0x49, */ I2C_CLIENT_END };
-
-I2C_CLIENT_INSMOD;
-
 static struct i2c_driver tps65010_driver;
 
 /*-------------------------------------------------------------------------*/
@@ -79,9 +68,8 @@ enum tps_model {
 };
 
 struct tps65010 {
-        struct i2c_client       client;
+        struct i2c_client       *client;
         struct mutex            lock;
-        int                     irq;
         struct delayed_work     work;
         struct dentry           *file;
         unsigned                charging:1;
@@ -229,22 +217,22 @@ static int dbg_show(struct seq_file *s, void *_)
         /* registers for monitoring battery charging and status; note
          * that reading chgstat and regstat may ack IRQs...
          */
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_CHGCONFIG);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_CHGCONFIG);
         dbg_chgconf(tps->por, buf, sizeof buf, value);
         seq_printf(s, "chgconfig %s", buf);
 
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_CHGSTATUS);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_CHGSTATUS);
         dbg_chgstat(buf, sizeof buf, value);
         seq_printf(s, "chgstat   %s", buf);
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_MASK1);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_MASK1);
         dbg_chgstat(buf, sizeof buf, value);
         seq_printf(s, "mask1     %s", buf);
         /* ignore ackint1 */
 
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_REGSTATUS);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_REGSTATUS);
         dbg_regstat(buf, sizeof buf, value);
         seq_printf(s, "regstat   %s", buf);
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_MASK2);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_MASK2);
         dbg_regstat(buf, sizeof buf, value);
         seq_printf(s, "mask2     %s\n", buf);
         /* ignore ackint2 */
@@ -253,21 +241,21 @@ static int dbg_show(struct seq_file *s, void *_)
 
 
         /* VMAIN voltage, enable lowpower, etc */
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_VDCDC1);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_VDCDC1);
         seq_printf(s, "vdcdc1    %02x\n", value);
 
         /* VCORE voltage, vibrator on/off */
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_VDCDC2);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_VDCDC2);
         seq_printf(s, "vdcdc2    %02x\n", value);
 
         /* both LD0s, and their lowpower behavior */
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_VREGS1);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_VREGS1);
         seq_printf(s, "vregs1    %02x\n\n", value);
 
 
         /* LEDs and GPIOs */
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_LED1_ON);
-        v2 = i2c_smbus_read_byte_data(&tps->client, TPS_LED1_PER);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_LED1_ON);
+        v2 = i2c_smbus_read_byte_data(tps->client, TPS_LED1_PER);
         seq_printf(s, "led1 %s, on=%02x, per=%02x, %d/%d msec\n",
                 (value & 0x80)
                         ? ((v2 & 0x80) ? "on" : "off")
@@ -275,8 +263,8 @@ static int dbg_show(struct seq_file *s, void *_)
                 value, v2,
                 (value & 0x7f) * 10, (v2 & 0x7f) * 100);
 
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_LED2_ON);
-        v2 = i2c_smbus_read_byte_data(&tps->client, TPS_LED2_PER);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_LED2_ON);
+        v2 = i2c_smbus_read_byte_data(tps->client, TPS_LED2_PER);
         seq_printf(s, "led2 %s, on=%02x, per=%02x, %d/%d msec\n",
                 (value & 0x80)
                         ? ((v2 & 0x80) ? "on" : "off")
@@ -284,8 +272,8 @@ static int dbg_show(struct seq_file *s, void *_)
                 value, v2,
                 (value & 0x7f) * 10, (v2 & 0x7f) * 100);
 
-        value = i2c_smbus_read_byte_data(&tps->client, TPS_DEFGPIO);
-        v2 = i2c_smbus_read_byte_data(&tps->client, TPS_MASK3);
+        value = i2c_smbus_read_byte_data(tps->client, TPS_DEFGPIO);
+        v2 = i2c_smbus_read_byte_data(tps->client, TPS_MASK3);
         seq_printf(s, "defgpio %02x mask3 %02x\n", value, v2);
 
         for (i = 0; i < 4; i++) {
@@ -335,7 +323,7 @@ static void tps65010_interrupt(struct tps65010 *tps)
 
         /* regstatus irqs */
         if (tps->nmask2) {
-                tmp = i2c_smbus_read_byte_data(&tps->client, TPS_REGSTATUS);
+                tmp = i2c_smbus_read_byte_data(tps->client, TPS_REGSTATUS);
                 mask = tmp ^ tps->regstatus;
                 tps->regstatus = tmp;
                 mask &= tps->nmask2;
@@ -362,7 +350,7 @@ static void tps65010_interrupt(struct tps65010 *tps)
 
         /* chgstatus irqs */
         if (tps->nmask1) {
-                tmp = i2c_smbus_read_byte_data(&tps->client, TPS_CHGSTATUS);
+                tmp = i2c_smbus_read_byte_data(tps->client, TPS_CHGSTATUS);
                 mask = tmp ^ tps->chgstatus;
                 tps->chgstatus = tmp;
                 mask &= tps->nmask1;
@@ -426,7 +414,7 @@ static void tps65010_work(struct work_struct *work)
                 int     status;
                 u8      chgconfig, tmp;
 
-                chgconfig = i2c_smbus_read_byte_data(&tps->client,
+                chgconfig = i2c_smbus_read_byte_data(tps->client,
                                         TPS_CHGCONFIG);
                 chgconfig &= ~(TPS_VBUS_500MA | TPS_VBUS_CHARGING);
                 if (tps->vbus == 500)
@@ -434,17 +422,17 @@ static void tps65010_work(struct work_struct *work)
                 else if (tps->vbus >= 100)
                         chgconfig |= TPS_VBUS_CHARGING;
 
-                status = i2c_smbus_write_byte_data(&tps->client,
+                status = i2c_smbus_write_byte_data(tps->client,
                                 TPS_CHGCONFIG, chgconfig);
 
                 /* vbus update fails unless VBUS is connected! */
-                tmp = i2c_smbus_read_byte_data(&tps->client, TPS_CHGCONFIG);
+                tmp = i2c_smbus_read_byte_data(tps->client, TPS_CHGCONFIG);
                 tps->chgconf = tmp;
                 show_chgconfig(tps->por, "update vbus", tmp);
         }
 
         if (test_and_clear_bit(FLAG_IRQ_ENABLE, &tps->flags))
-                enable_irq(tps->irq);
+                enable_irq(tps->client->irq);
 
         mutex_unlock(&tps->lock);
 }
@@ -463,114 +451,75 @@ static irqreturn_t tps65010_irq(int irq, void *_tps)
 
 static struct tps65010 *the_tps;
 
-static int __exit tps65010_detach_client(struct i2c_client *client)
+static int __exit tps65010_remove(struct i2c_client *client)
 {
-        struct tps65010         *tps;
+        struct tps65010         *tps = i2c_get_clientdata(client);
 
-        tps = container_of(client, struct tps65010, client);
-        free_irq(tps->irq, tps);
-#ifdef  CONFIG_ARM
-        if (machine_is_omap_h2())
-                omap_free_gpio(58);
-        if (machine_is_omap_osk())
-                omap_free_gpio(OMAP_MPUIO(1));
-#endif
+        if (client->irq > 0)
+                free_irq(client->irq, tps);
         cancel_delayed_work(&tps->work);
         flush_scheduled_work();
         debugfs_remove(tps->file);
-        if (i2c_detach_client(client) == 0)
-                kfree(tps);
+        kfree(tps);
         the_tps = NULL;
         return 0;
 }
 
-static int tps65010_noscan(struct i2c_adapter *bus)
-{
-        /* pure paranoia, in case someone adds another i2c bus
-         * after our init section's gone...
-         */
-        return -ENODEV;
-}
-
-/* no error returns, they'd just make bus scanning stop */
-static int __init
-tps65010_probe(struct i2c_adapter *bus, int address, int kind)
+static int tps65010_probe(struct i2c_client *client)
 {
         struct tps65010         *tps;
         int                     status;
-        unsigned long           irqflags;
 
         if (the_tps) {
-                dev_dbg(&bus->dev, "only one %s for now\n", DRIVER_NAME);
-                return 0;
+                dev_dbg(&client->dev, "only one tps6501x chip allowed\n");
+                return -ENODEV;
         }
 
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -EINVAL;
+
         tps = kzalloc(sizeof *tps, GFP_KERNEL);
         if (!tps)
-                return 0;
+                return -ENOMEM;
 
         mutex_init(&tps->lock);
         INIT_DELAYED_WORK(&tps->work, tps65010_work);
-        tps->irq = -1;
-        tps->client.addr = address;
-        tps->client.adapter = bus;
-        tps->client.driver = &tps65010_driver;
-        strlcpy(tps->client.name, DRIVER_NAME, I2C_NAME_SIZE);
-
-        status = i2c_attach_client(&tps->client);
-        if (status < 0) {
-                dev_dbg(&bus->dev, "can't attach %s to device %d, err %d\n",
-                                DRIVER_NAME, address, status);
-                goto fail1;
-        }
+        tps->client = client;
 
-        /* the IRQ is active low, but many gpio lines can't support that
-         * so this driver can use falling-edge triggers instead.
-         */
-        irqflags = IRQF_SAMPLE_RANDOM;
-#ifdef  CONFIG_ARM
-        if (machine_is_omap_h2()) {
-                tps->model = TPS65010;
-                omap_cfg_reg(W4_GPIO58);
-                tps->irq = OMAP_GPIO_IRQ(58);
-                omap_request_gpio(58);
-                omap_set_gpio_direction(58, 1);
-                irqflags |= IRQF_TRIGGER_FALLING;
-        }
-        if (machine_is_omap_osk()) {
+        if (strcmp(client->name, "tps65010") == 0)
                 tps->model = TPS65010;
-                // omap_cfg_reg(U19_1610_MPUIO1);
-                tps->irq = OMAP_GPIO_IRQ(OMAP_MPUIO(1));
-                omap_request_gpio(OMAP_MPUIO(1));
-                omap_set_gpio_direction(OMAP_MPUIO(1), 1);
-                irqflags |= IRQF_TRIGGER_FALLING;
-        }
-        if (machine_is_omap_h3()) {
+        else if (strcmp(client->name, "tps65011") == 0)
+                tps->model = TPS65011;
+        else if (strcmp(client->name, "tps65012") == 0)
+                tps->model = TPS65012;
+        else if (strcmp(client->name, "tps65013") == 0)
                 tps->model = TPS65013;
-
-                // FIXME set up this board's IRQ ...
+        else {
+                dev_warn(&client->dev, "unknown chip '%s'\n", client->name);
+                status = -ENODEV;
+                goto fail1;
         }
-#endif
 
-        if (tps->irq > 0) {
-                status = request_irq(tps->irq, tps65010_irq,
-                        irqflags, DRIVER_NAME, tps);
+        /* the IRQ is active low, but many gpio lines can't support that
+         * so this driver uses falling-edge triggers instead.
+         */
+        if (client->irq > 0) {
+                status = request_irq(client->irq, tps65010_irq,
+                        IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_FALLING,
+                        DRIVER_NAME, tps);
                 if (status < 0) {
-                        dev_dbg(&tps->client.dev, "can't get IRQ %d, err %d\n",
-                                        tps->irq, status);
-                        i2c_detach_client(&tps->client);
+                        dev_dbg(&client->dev, "can't get IRQ %d, err %d\n",
+                                        client->irq, status);
                         goto fail1;
                 }
-#ifdef  CONFIG_ARM
                 /* annoying race here, ideally we'd have an option
                  * to claim the irq now and enable it later.
+                 * FIXME genirq IRQF_NOAUTOEN now solves that ...
                  */
-                disable_irq(tps->irq);
+                disable_irq(client->irq);
                 set_bit(FLAG_IRQ_ENABLE, &tps->flags);
-#endif
         } else
-                printk(KERN_WARNING "%s: IRQ not configured!\n",
-                                DRIVER_NAME);
+                dev_warn(&client->dev, "IRQ not configured!\n");
 
 
         switch (tps->model) {
@@ -583,23 +532,22 @@ tps65010_probe(struct i2c_adapter *bus, int address, int kind)
                 break;
         /* else CHGCONFIG.POR is replaced by AUA, enabling a WAIT mode */
         }
-        tps->chgconf = i2c_smbus_read_byte_data(&tps->client, TPS_CHGCONFIG);
+        tps->chgconf = i2c_smbus_read_byte_data(client, TPS_CHGCONFIG);
         show_chgconfig(tps->por, "conf/init", tps->chgconf);
 
         show_chgstatus("chg/init",
-                i2c_smbus_read_byte_data(&tps->client, TPS_CHGSTATUS));
+                i2c_smbus_read_byte_data(client, TPS_CHGSTATUS));
         show_regstatus("reg/init",
-                i2c_smbus_read_byte_data(&tps->client, TPS_REGSTATUS));
+                i2c_smbus_read_byte_data(client, TPS_REGSTATUS));
 
         pr_debug("%s: vdcdc1 0x%02x, vdcdc2 %02x, vregs1 %02x\n", DRIVER_NAME,
-                i2c_smbus_read_byte_data(&tps->client, TPS_VDCDC1),
-                i2c_smbus_read_byte_data(&tps->client, TPS_VDCDC2),
-                i2c_smbus_read_byte_data(&tps->client, TPS_VREGS1));
+                i2c_smbus_read_byte_data(client, TPS_VDCDC1),
+                i2c_smbus_read_byte_data(client, TPS_VDCDC2),
+                i2c_smbus_read_byte_data(client, TPS_VREGS1));
         pr_debug("%s: defgpio 0x%02x, mask3 0x%02x\n", DRIVER_NAME,
-                i2c_smbus_read_byte_data(&tps->client, TPS_DEFGPIO),
-                i2c_smbus_read_byte_data(&tps->client, TPS_MASK3));
+                i2c_smbus_read_byte_data(client, TPS_DEFGPIO),
+                i2c_smbus_read_byte_data(client, TPS_MASK3));
 
-        tps65010_driver.attach_adapter = tps65010_noscan;
         the_tps = tps;
 
 #if     defined(CONFIG_USB_GADGET) && !defined(CONFIG_USB_OTG)
@@ -615,15 +563,15 @@ tps65010_probe(struct i2c_adapter *bus, int address, int kind)
          * registers, and maybe disable VBUS draw.
          */
         tps->nmask1 = ~0;
-        (void) i2c_smbus_write_byte_data(&tps->client, TPS_MASK1, ~tps->nmask1);
+        (void) i2c_smbus_write_byte_data(client, TPS_MASK1, ~tps->nmask1);
 
         tps->nmask2 = TPS_REG_ONOFF;
         if (tps->model == TPS65013)
                 tps->nmask2 |= TPS_REG_NO_CHG;
-        (void) i2c_smbus_write_byte_data(&tps->client, TPS_MASK2, ~tps->nmask2);
+        (void) i2c_smbus_write_byte_data(client, TPS_MASK2, ~tps->nmask2);
 
-        (void) i2c_smbus_write_byte_data(&tps->client, TPS_MASK3, 0x0f
-                | i2c_smbus_read_byte_data(&tps->client, TPS_MASK3));
+        (void) i2c_smbus_write_byte_data(client, TPS_MASK3, 0x0f
+                | i2c_smbus_read_byte_data(client, TPS_MASK3));
 
         tps65010_work(&tps->work.work);
 
@@ -632,22 +580,15 @@ tps65010_probe(struct i2c_adapter *bus, int address, int kind)
         return 0;
 fail1:
         kfree(tps);
-        return 0;
-}
-
-static int __init tps65010_scan_bus(struct i2c_adapter *bus)
-{
-        if (!i2c_check_functionality(bus, I2C_FUNC_SMBUS_BYTE_DATA))
-                return -EINVAL;
-        return i2c_probe(bus, &addr_data, tps65010_probe);
+        return status;
 }
 
 static struct i2c_driver tps65010_driver = {
         .driver = {
                 .name   = "tps65010",
         },
-        .attach_adapter = tps65010_scan_bus,
-        .detach_client  = __exit_p(tps65010_detach_client),
+        .probe  = tps65010_probe,
+        .remove = __exit_p(tps65010_remove),
 };
 
 /*-------------------------------------------------------------------------*/
@@ -702,7 +643,7 @@ int tps65010_set_gpio_out_value(unsigned gpio, unsigned value)
 
         mutex_lock(&the_tps->lock);
 
-        defgpio = i2c_smbus_read_byte_data(&the_tps->client, TPS_DEFGPIO);
+        defgpio = i2c_smbus_read_byte_data(the_tps->client, TPS_DEFGPIO);
 
         /* Configure GPIO for output */
         defgpio |= 1 << (gpio + 3);
@@ -718,12 +659,12 @@ int tps65010_set_gpio_out_value(unsigned gpio, unsigned value)
                 break;
         }
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                 TPS_DEFGPIO, defgpio);
 
         pr_debug("%s: gpio%dout = %s, defgpio 0x%02x\n", DRIVER_NAME,
                 gpio, value ? "high" : "low",
-                i2c_smbus_read_byte_data(&the_tps->client, TPS_DEFGPIO));
+                i2c_smbus_read_byte_data(the_tps->client, TPS_DEFGPIO));
 
         mutex_unlock(&the_tps->lock);
         return status;
@@ -753,11 +694,11 @@ int tps65010_set_led(unsigned led, unsigned mode)
         mutex_lock(&the_tps->lock);
 
         pr_debug("%s: led%i_on   0x%02x\n", DRIVER_NAME, led,
-                i2c_smbus_read_byte_data(&the_tps->client,
+                i2c_smbus_read_byte_data(the_tps->client,
                                 TPS_LED1_ON + offs));
 
         pr_debug("%s: led%i_per  0x%02x\n", DRIVER_NAME, led,
-                i2c_smbus_read_byte_data(&the_tps->client,
+                i2c_smbus_read_byte_data(the_tps->client,
                                 TPS_LED1_PER + offs));
 
         switch (mode) {
@@ -780,7 +721,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
                 return -EINVAL;
         }
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_LED1_ON + offs, led_on);
 
         if (status != 0) {
@@ -791,9 +732,9 @@ int tps65010_set_led(unsigned led, unsigned mode)
         }
 
         pr_debug("%s: led%i_on   0x%02x\n", DRIVER_NAME, led,
-                i2c_smbus_read_byte_data(&the_tps->client, TPS_LED1_ON + offs));
+                i2c_smbus_read_byte_data(the_tps->client, TPS_LED1_ON + offs));
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_LED1_PER + offs, led_per);
 
         if (status != 0) {
@@ -804,7 +745,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
         }
 
         pr_debug("%s: led%i_per  0x%02x\n", DRIVER_NAME, led,
-                i2c_smbus_read_byte_data(&the_tps->client,
+                i2c_smbus_read_byte_data(the_tps->client,
                                 TPS_LED1_PER + offs));
 
         mutex_unlock(&the_tps->lock);
@@ -827,11 +768,11 @@ int tps65010_set_vib(unsigned value)
 
         mutex_lock(&the_tps->lock);
 
-        vdcdc2 = i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC2);
+        vdcdc2 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC2);
         vdcdc2 &= ~(1 << 1);
         if (value)
                 vdcdc2 |= (1 << 1);
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                 TPS_VDCDC2, vdcdc2);
 
         pr_debug("%s: vibrator %s\n", DRIVER_NAME, value ? "on" : "off");
@@ -857,9 +798,9 @@ int tps65010_set_low_pwr(unsigned mode)
 
         pr_debug("%s: %s low_pwr, vdcdc1 0x%02x\n", DRIVER_NAME,
                 mode ? "enable" : "disable",
-                i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
+                i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
 
-        vdcdc1 = i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1);
+        vdcdc1 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1);
 
         switch (mode) {
         case OFF:
@@ -871,7 +812,7 @@ int tps65010_set_low_pwr(unsigned mode)
                 break;
         }
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_VDCDC1, vdcdc1);
 
         if (status != 0)
@@ -879,7 +820,7 @@ int tps65010_set_low_pwr(unsigned mode)
                         DRIVER_NAME);
         else
                 pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
-                        i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
+                        i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
 
         mutex_unlock(&the_tps->lock);
 
@@ -902,9 +843,9 @@ int tps65010_config_vregs1(unsigned value)
         mutex_lock(&the_tps->lock);
 
         pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
-                        i2c_smbus_read_byte_data(&the_tps->client, TPS_VREGS1));
+                        i2c_smbus_read_byte_data(the_tps->client, TPS_VREGS1));
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_VREGS1, value);
 
         if (status != 0)
@@ -912,7 +853,7 @@ int tps65010_config_vregs1(unsigned value)
                         DRIVER_NAME);
         else
                 pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
-                        i2c_smbus_read_byte_data(&the_tps->client, TPS_VREGS1));
+                        i2c_smbus_read_byte_data(the_tps->client, TPS_VREGS1));
 
         mutex_unlock(&the_tps->lock);
 
@@ -941,11 +882,11 @@ int tps65013_set_low_pwr(unsigned mode)
         pr_debug("%s: %s low_pwr, chgconfig 0x%02x vdcdc1 0x%02x\n",
                 DRIVER_NAME,
                 mode ? "enable" : "disable",
-                i2c_smbus_read_byte_data(&the_tps->client, TPS_CHGCONFIG),
-                i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
+                i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG),
+                i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
 
-        chgconfig = i2c_smbus_read_byte_data(&the_tps->client, TPS_CHGCONFIG);
-        vdcdc1 = i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1);
+        chgconfig = i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG);
+        vdcdc1 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1);
 
         switch (mode) {
         case OFF:
@@ -959,7 +900,7 @@ int tps65013_set_low_pwr(unsigned mode)
                 break;
         }
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_CHGCONFIG, chgconfig);
         if (status != 0) {
                 printk(KERN_ERR "%s: Failed to write chconfig register\n",
@@ -968,11 +909,11 @@ int tps65013_set_low_pwr(unsigned mode)
                 return status;
         }
 
-        chgconfig = i2c_smbus_read_byte_data(&the_tps->client, TPS_CHGCONFIG);
+        chgconfig = i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG);
         the_tps->chgconf = chgconfig;
         show_chgconfig(0, "chgconf", chgconfig);
 
-        status = i2c_smbus_write_byte_data(&the_tps->client,
+        status = i2c_smbus_write_byte_data(the_tps->client,
                         TPS_VDCDC1, vdcdc1);
 
         if (status != 0)
@@ -980,7 +921,7 @@ int tps65013_set_low_pwr(unsigned mode)
          DRIVER_NAME);
         else
                 pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
-                        i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
+                        i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
 
         mutex_unlock(&the_tps->lock);
 
@@ -1011,52 +952,6 @@ static int __init tps_init(void)
                 msleep(10);
         }
 
-#ifdef  CONFIG_ARM
-        if (machine_is_omap_osk()) {
-
-                // FIXME: More should be placed in the initialization code
-                //        of the submodules (DSP, ethernet, power management,
-                //        board-osk.c). Careful: I2C is initialized "late".
-
-                /* Let LED1 (D9) blink */
-                tps65010_set_led(LED1, BLINK);
-
-                /* Disable LED 2 (D2) */
-                tps65010_set_led(LED2, OFF);
-
-                /* Set GPIO 1 HIGH to disable VBUS power supply;
-                 * OHCI driver powers it up/down as needed.
-                 */
-                tps65010_set_gpio_out_value(GPIO1, HIGH);
-
-                /* Set GPIO 2 low to turn on LED D3 */
-                tps65010_set_gpio_out_value(GPIO2, HIGH);
-
-                /* Set GPIO 3 low to take ethernet out of reset */
-                tps65010_set_gpio_out_value(GPIO3, LOW);
-
-                /* gpio4 for VDD_DSP */
-
-                /* Enable LOW_PWR */
-                tps65010_set_low_pwr(ON);
-
-                /* Switch VLDO2 to 3.0V for AIC23 */
-                tps65010_config_vregs1(TPS_LDO2_ENABLE | TPS_VLDO2_3_0V | TPS_LDO1_ENABLE);
-
-        } else if (machine_is_omap_h2()) {
-                /* gpio3 for SD, gpio4 for VDD_DSP */
-
-                /* Enable LOW_PWR */
-                tps65010_set_low_pwr(ON);
-        } else if (machine_is_omap_h3()) {
-                /* gpio4 for SD, gpio3 for VDD_DSP */
-#ifdef CONFIG_PM
-                /* Enable LOW_PWR */
-                tps65013_set_low_pwr(ON);
-#endif
-        }
-#endif
-
         return status;
 }
 /* NOTE:  this MUST be initialized before the other parts of the system
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index d663e6960d..e73d58c43f 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -67,20 +67,16 @@ static int i2c_device_match(struct device *dev, struct device_driver *drv)
 #ifdef  CONFIG_HOTPLUG
 
 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
-static int i2c_device_uevent(struct device *dev, char **envp, int num_envp,
-                      char *buffer, int buffer_size)
+static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct i2c_client       *client = to_i2c_client(dev);
-        int                     i = 0, length = 0;
 
         /* by definition, legacy drivers can't hotplug */
         if (dev->driver || !client->driver_name)
                 return 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                        "MODALIAS=%s", client->driver_name))
+        if (add_uevent_var(env, "MODALIAS=%s", client->driver_name))
                 return -ENOMEM;
-        envp[i] = NULL;
         dev_dbg(dev, "uevent\n");
         return 0;
 }
@@ -190,7 +186,7 @@ static struct device_attribute i2c_dev_attrs[] = {
         { },
 };
 
-struct bus_type i2c_bus_type = {
+static struct bus_type i2c_bus_type = {
         .name           = "i2c",
         .dev_attrs      = i2c_dev_attrs,
         .match          = i2c_device_match,
@@ -201,7 +197,6 @@ struct bus_type i2c_bus_type = {
         .suspend        = i2c_device_suspend,
         .resume         = i2c_device_resume,
 };
-EXPORT_SYMBOL_GPL(i2c_bus_type);
 
 /**
  * i2c_new_device - instantiate an i2c device for use with a new style driver
@@ -230,7 +225,9 @@ i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
         client->adapter = adap;
 
         client->dev.platform_data = info->platform_data;
-        client->flags = info->flags;
+        device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
+
+        client->flags = info->flags & ~I2C_CLIENT_WAKE;
         client->addr = info->addr;
         client->irq = info->irq;
 
@@ -283,7 +280,7 @@ EXPORT_SYMBOL_GPL(i2c_unregister_device);
 
 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
 
-void i2c_adapter_dev_release(struct device *dev)
+static void i2c_adapter_dev_release(struct device *dev)
 {
         struct i2c_adapter *adap = to_i2c_adapter(dev);
         complete(&adap->dev_released);
@@ -301,7 +298,7 @@ static struct device_attribute i2c_adapter_attrs[] = {
         { },
 };
 
-struct class i2c_adapter_class = {
+static struct class i2c_adapter_class = {
         .owner                  = THIS_MODULE,
         .name                   = "i2c-adapter",
         .dev_attrs              = i2c_adapter_attrs,
@@ -934,28 +931,6 @@ int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
 }
 EXPORT_SYMBOL(i2c_master_recv);
 
-int i2c_control(struct i2c_client *client,
-        unsigned int cmd, unsigned long arg)
-{
-        int ret = 0;
-        struct i2c_adapter *adap = client->adapter;
-
-        dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
-        switch (cmd) {
-                case I2C_RETRIES:
-                        adap->retries = arg;
-                        break;
-                case I2C_TIMEOUT:
-                        adap->timeout = arg;
-                        break;
-                default:
-                        if (adap->algo->algo_control!=NULL)
-                                ret = adap->algo->algo_control(adap,cmd,arg);
-        }
-        return ret;
-}
-EXPORT_SYMBOL(i2c_control);
-
 /* ----------------------------------------------------
  * the i2c address scanning function
  * Will not work for 10-bit addresses!
@@ -1310,7 +1285,22 @@ s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
 }
 EXPORT_SYMBOL(i2c_smbus_write_word_data);
 
-/* Returns the number of read bytes */
+/**
+ * i2c_smbus_read_block_data - SMBus block read request
+ * @client: Handle to slave device
+ * @command: Command byte issued to let the slave know what data should
+ *      be returned
+ * @values: Byte array into which data will be read; big enough to hold
+ *      the data returned by the slave.  SMBus allows at most 32 bytes.
+ *
+ * Returns the number of bytes read in the slave's response, else a
+ * negative number to indicate some kind of error.
+ *
+ * Note that using this function requires that the client's adapter support
+ * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
+ * support this; its emulation through I2C messaging relies on a specific
+ * mechanism (I2C_M_RECV_LEN) which may not be implemented.
+ */
 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
                               u8 *values)
 {
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index 64eee9551b..5a15e50748 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -226,8 +226,10 @@ static int i2cdev_ioctl(struct inode *inode, struct file *file,
 
                 res = 0;
                 for( i=0; i<rdwr_arg.nmsgs; i++ ) {
-                        /* Limit the size of the message to a sane amount */
-                        if (rdwr_pa[i].len > 8192) {
+                        /* Limit the size of the message to a sane amount;
+                         * and don't let length change either. */
+                        if ((rdwr_pa[i].len > 8192) ||
+                            (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
                                 res = -EINVAL;
                                 break;
                         }
@@ -352,9 +354,19 @@ static int i2cdev_ioctl(struct inode *inode, struct file *file,
                                 return -EFAULT;
                 }
                 return res;
-
+        case I2C_RETRIES:
+                client->adapter->retries = arg;
+                break;
+        case I2C_TIMEOUT:
+                client->adapter->timeout = arg;
+                break;
         default:
-                return i2c_control(client,cmd,arg);
+                /* NOTE:  returning a fault code here could cause trouble
+                 * in buggy userspace code.  Some old kernel bugs returned
+                 * zero in this case, and userspace code might accidentally
+                 * have depended on that bug.
+                 */
+                return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index aa0e0c9f74..8982c09324 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -1074,22 +1074,6 @@ endif
 config BLK_DEV_IDEDMA
         def_bool BLK_DEV_IDEDMA_PCI || BLK_DEV_IDEDMA_PMAC || BLK_DEV_IDEDMA_ICS || BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
 
-config IDEDMA_IVB
-        bool "IGNORE word93 Validation BITS"
-        depends on BLK_DEV_IDEDMA_PCI || BLK_DEV_IDEDMA_PMAC || BLK_DEV_IDEDMA_ICS
-        ---help---
-          There are unclear terms in ATA-4 and ATA-5 standards how certain
-          hardware (an 80c ribbon) should be detected. Different interpretations
-          of the standards have been released in hardware. This causes problems:
-          for example, a host with Ultra Mode 4 (or higher) will not run
-          in that mode with an 80c ribbon.
-
-          If you are experiencing compatibility or performance problems, you
-          MAY try to answer Y here. However, it does not necessarily solve
-          any of your problems, it could even cause more of them.
-
-          It is normally safe to answer Y; however, the default is N.
-
 endif
 
 config BLK_DEV_HD_ONLY
diff --git a/drivers/ide/arm/icside.c b/drivers/ide/arm/icside.c
index 7912a471f1..bd1f5b6703 100644
--- a/drivers/ide/arm/icside.c
+++ b/drivers/ide/arm/icside.c
@@ -248,7 +248,7 @@ static void icside_build_sglist(ide_drive_t *drive, struct request *rq)
  *      MW1     80      50      50      150     C
  *      MW2     70      25      25      120     C
  */
-static int icside_set_speed(ide_drive_t *drive, const u8 xfer_mode)
+static void icside_set_dma_mode(ide_drive_t *drive, const u8 xfer_mode)
 {
         int cycle_time, use_dma_info = 0;
 
@@ -273,7 +273,7 @@ static int icside_set_speed(ide_drive_t *drive, const u8 xfer_mode)
                 cycle_time = 480;
                 break;
         default:
-                return 1;
+                return;
         }
 
         /*
@@ -287,8 +287,6 @@ static int icside_set_speed(ide_drive_t *drive, const u8 xfer_mode)
 
         printk("%s: %s selected (peak %dMB/s)\n", drive->name,
                 ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
-
-        return ide_config_drive_speed(drive, xfer_mode);
 }
 
 static void icside_dma_host_off(ide_drive_t *drive)
@@ -313,41 +311,10 @@ static int icside_dma_on(ide_drive_t *drive)
 
 static int icside_dma_check(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
-        ide_hwif_t *hwif = HWIF(drive);
-        int xfer_mode = 0;
-
-        if (!(id->capability & 1) || !hwif->autodma)
-                goto out;
-
-        /*
-         * Consult the list of known "bad" drives
-         */
-        if (__ide_dma_bad_drive(drive))
-                goto out;
-
-        /*
-         * Enable DMA on any drive that has multiword DMA
-         */
-        if (id->field_valid & 2) {
-                xfer_mode = ide_max_dma_mode(drive);
-                goto out;
-        }
-
-        /*
-         * Consult the list of known "good" drives
-         */
-        if (__ide_dma_good_drive(drive)) {
-                if (id->eide_dma_time > 150)
-                        goto out;
-                xfer_mode = XFER_MW_DMA_1;
-        }
-
-out:
-        if (xfer_mode == 0)
-                return -1;
+        if (ide_tune_dma(drive))
+                return 0;
 
-        return icside_set_speed(drive, xfer_mode) ? -1 : 0;
+        return -1;
 }
 
 static int icside_dma_end(ide_drive_t *drive)
@@ -464,7 +431,7 @@ static void icside_dma_init(ide_hwif_t *hwif)
 
         hwif->dmatable_cpu      = NULL;
         hwif->dmatable_dma      = 0;
-        hwif->speedproc         = icside_set_speed;
+        hwif->set_dma_mode      = icside_set_dma_mode;
         hwif->autodma           = 1;
 
         hwif->ide_dma_check     = icside_dma_check;
diff --git a/drivers/ide/cris/ide-cris.c b/drivers/ide/cris/ide-cris.c
index 4bb42b30bf..2b4d2a0ae5 100644
--- a/drivers/ide/cris/ide-cris.c
+++ b/drivers/ide/cris/ide-cris.c
@@ -716,11 +716,9 @@ static void cris_set_pio_mode(ide_drive_t *drive, const u8 pio)
         }
 
         cris_ide_set_speed(TYPE_PIO, setup, strobe, hold);
-
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static int speed_cris_ide(ide_drive_t *drive, const u8 speed)
+static void cris_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         int cyc = 0, dvs = 0, strobe = 0, hold = 0;
 
@@ -759,8 +757,6 @@ static int speed_cris_ide(ide_drive_t *drive, const u8 speed)
                 cris_ide_set_speed(TYPE_UDMA, cyc, dvs, 0);
         else
                 cris_ide_set_speed(TYPE_DMA, 0, strobe, hold);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 void __init
@@ -791,7 +787,7 @@ init_e100_ide (void)
                 hwif->mmio = 1;
                 hwif->chipset = ide_etrax100;
                 hwif->set_pio_mode = &cris_set_pio_mode;
-                hwif->speedproc = &speed_cris_ide;
+                hwif->set_dma_mode = &cris_set_dma_mode;
                 hwif->ata_input_data = &cris_ide_input_data;
                 hwif->ata_output_data = &cris_ide_output_data;
                 hwif->atapi_input_bytes = &cris_atapi_input_bytes;
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index 6bff81a58b..1d5f682310 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -649,7 +649,6 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
         if (!on)
                 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D3);
 }
-EXPORT_SYMBOL_GPL(ide_acpi_set_state);
 
 /**
  * ide_acpi_init - initialize the ACPI link for an IDE interface
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 6000c08f51..b453211ee0 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -169,6 +169,11 @@ ide_startstop_t ide_dma_intr (ide_drive_t *drive)
 
 EXPORT_SYMBOL_GPL(ide_dma_intr);
 
+static int ide_dma_good_drive(ide_drive_t *drive)
+{
+        return ide_in_drive_list(drive->id, drive_whitelist);
+}
+
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
 /**
  *      ide_build_sglist        -       map IDE scatter gather for DMA I/O
@@ -357,7 +362,7 @@ static int config_drive_for_dma (ide_drive_t *drive)
                                 return 0;
 
                 /* Consult the list of known "good" drives */
-                if (__ide_dma_good_drive(drive))
+                if (ide_dma_good_drive(drive))
                         return 0;
         }
 
@@ -639,14 +644,6 @@ int __ide_dma_bad_drive (ide_drive_t *drive)
 
 EXPORT_SYMBOL(__ide_dma_bad_drive);
 
-int __ide_dma_good_drive (ide_drive_t *drive)
-{
-        struct hd_driveid *id = drive->id;
-        return ide_in_drive_list(id, drive_whitelist);
-}
-
-EXPORT_SYMBOL(__ide_dma_good_drive);
-
 static const u8 xfer_mode_bases[] = {
         XFER_UDMA_0,
         XFER_MW_DMA_0,
@@ -746,6 +743,14 @@ u8 ide_find_dma_mode(ide_drive_t *drive, u8 req_mode)
                 }
         }
 
+        if (hwif->chipset == ide_acorn && mode == 0) {
+                /*
+                 * is this correct?
+                 */
+                if (ide_dma_good_drive(drive) && drive->id->eide_dma_time < 150)
+                        mode = XFER_MW_DMA_1;
+        }
+
         printk(KERN_DEBUG "%s: selected mode 0x%x\n", drive->name, mode);
 
         return min(mode, req_mode);
@@ -769,7 +774,10 @@ int ide_tune_dma(ide_drive_t *drive)
         if (!speed)
                 return 0;
 
-        if (drive->hwif->speedproc(drive, speed))
+        if (drive->hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
+                return 0;
+
+        if (ide_set_dma_mode(drive, speed))
                 return 0;
 
         return 1;
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 9560a8f4a8..4cece93011 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -836,9 +836,17 @@ static ide_startstop_t do_special (ide_drive_t *drive)
                 if (set_pio_mode_abuse(drive->hwif, req_pio)) {
                         if (hwif->set_pio_mode)
                                 hwif->set_pio_mode(drive, req_pio);
-                } else
+                } else {
+                        int keep_dma = drive->using_dma;
+
                         ide_set_pio(drive, req_pio);
 
+                        if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) {
+                                if (keep_dma)
+                                        hwif->ide_dma_on(drive);
+                        }
+                }
+
                 return ide_stopped;
         } else {
                 if (drive->media == ide_disk)
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index cf0678b611..aa738833be 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -473,57 +473,22 @@ int drive_is_ready (ide_drive_t *drive)
 EXPORT_SYMBOL(drive_is_ready);
 
 /*
- * Global for All, and taken from ide-pmac.c. Can be called
- * with spinlock held & IRQs disabled, so don't schedule !
- */
-int wait_for_ready (ide_drive_t *drive, int timeout)
-{
-        ide_hwif_t *hwif        = HWIF(drive);
-        u8 stat                 = 0;
-
-        while(--timeout) {
-                stat = hwif->INB(IDE_STATUS_REG);
-                if (!(stat & BUSY_STAT)) {
-                        if (drive->ready_stat == 0)
-                                break;
-                        else if ((stat & drive->ready_stat)||(stat & ERR_STAT))
-                                break;
-                }
-                mdelay(1);
-        }
-        if ((stat & ERR_STAT) || timeout <= 0) {
-                if (stat & ERR_STAT) {
-                        printk(KERN_ERR "%s: wait_for_ready, "
-                                "error status: %x\n", drive->name, stat);
-                }
-                return 1;
-        }
-        return 0;
-}
-
-/*
  * 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
- * cases return 1 after invoking ide_error() -- caller should just return.
+ * cases return error -- caller may then invoke ide_error().
  *
  * This routine should get fixed to not hog the cpu during extra long waits..
  * That could be done by busy-waiting for the first jiffy or two, and then
  * setting a timer to wake up at half second intervals thereafter,
  * until timeout is achieved, before timing out.
  */
-int ide_wait_stat (ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout)
+static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout, u8 *rstat)
 {
-        ide_hwif_t *hwif = HWIF(drive);
-        u8 stat;
-        int i;
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long flags;
- 
-        /* bail early if we've exceeded max_failures */
-        if (drive->max_failures && (drive->failures > drive->max_failures)) {
-                *startstop = ide_stopped;
-                return 1;
-        }
+        int i;
+        u8 stat;
 
         udelay(1);      /* spec allows drive 400ns to assert "BUSY" */
         if ((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) {
@@ -541,8 +506,8 @@ int ide_wait_stat (ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 b
                                         break;
 
                                 local_irq_restore(flags);
-                                *startstop = ide_error(drive, "status timeout", stat);
-                                return 1;
+                                *rstat = stat;
+                                return -EBUSY;
                         }
                 }
                 local_irq_restore(flags);
@@ -556,11 +521,39 @@ int ide_wait_stat (ide_startstop_t *startstop, ide_drive_t *drive, u8 good, u8 b
          */
         for (i = 0; i < 10; i++) {
                 udelay(1);
-                if (OK_STAT((stat = hwif->INB(IDE_STATUS_REG)), good, bad))
+                if (OK_STAT((stat = hwif->INB(IDE_STATUS_REG)), good, bad)) {
+                        *rstat = stat;
                         return 0;
+                }
         }
-        *startstop = ide_error(drive, "status error", stat);
-        return 1;
+        *rstat = stat;
+        return -EFAULT;
+}
+
+/*
+ * In case of error returns error value after doing "*startstop = ide_error()".
+ * 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 err;
+        u8 stat;
+
+        /* bail early if we've exceeded max_failures */
+        if (drive->max_failures && (drive->failures > drive->max_failures)) {
+                *startstop = ide_stopped;
+                return 1;
+        }
+
+        err = __ide_wait_stat(drive, good, bad, timeout, &stat);
+
+        if (err) {
+                char *s = (err == -EBUSY) ? "status timeout" : "status error";
+                *startstop = ide_error(drive, s, stat);
+        }
+
+        return err;
 }
 
 EXPORT_SYMBOL(ide_wait_stat);
@@ -620,15 +613,10 @@ u8 eighty_ninty_three (ide_drive_t *drive)
 
         /*
          * FIXME:
-         * - change master/slave IDENTIFY order
          * - force bit13 (80c cable present) check also for !ivb devices
          *   (unless the slave device is pre-ATA3)
          */
-#ifndef CONFIG_IDEDMA_IVB
         if ((id->hw_config & 0x4000) || (ivb && (id->hw_config & 0x2000)))
-#else
-        if (id->hw_config & 0x6000)
-#endif
                 return 1;
 
 no_80w:
@@ -778,15 +766,10 @@ int ide_driveid_update (ide_drive_t *drive)
 #endif
 }
 
-/*
- * Similar to ide_wait_stat(), except it never calls ide_error internally.
- *
- * const char *msg == consider adding for verbose errors.
- */
-int ide_config_drive_speed (ide_drive_t *drive, u8 speed)
+int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
-        int     i, error        = 1;
+        ide_hwif_t *hwif = drive->hwif;
+        int error;
         u8 stat;
 
 //      while (HWGROUP(drive)->busy)
@@ -826,35 +809,10 @@ int ide_config_drive_speed (ide_drive_t *drive, u8 speed)
         hwif->OUTBSYNC(drive, WIN_SETFEATURES, IDE_COMMAND_REG);
         if ((IDE_CONTROL_REG) && (drive->quirk_list == 2))
                 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
-        udelay(1);
-        /*
-         * Wait for drive to become non-BUSY
-         */
-        if ((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) {
-                unsigned long flags, timeout;
-                local_irq_set(flags);
-                timeout = jiffies + WAIT_CMD;
-                while ((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) {
-                        if (time_after(jiffies, timeout))
-                                break;
-                }
-                local_irq_restore(flags);
-        }
 
-        /*
-         * Allow status to settle, then read it again.
-         * A few rare drives vastly violate the 400ns spec here,
-         * so we'll wait up to 10usec for a "good" status
-         * rather than expensively fail things immediately.
-         * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
-         */
-        for (i = 0; i < 10; i++) {
-                udelay(1);
-                if (OK_STAT((stat = hwif->INB(IDE_STATUS_REG)), drive->ready_stat, BUSY_STAT|DRQ_STAT|ERR_STAT)) {
-                        error = 0;
-                        break;
-                }
-        }
+        error = __ide_wait_stat(drive, drive->ready_stat,
+                                BUSY_STAT|DRQ_STAT|ERR_STAT,
+                                WAIT_CMD, &stat);
 
         SELECT_MASK(drive, 0);
 
@@ -899,9 +857,6 @@ int ide_config_drive_speed (ide_drive_t *drive, u8 speed)
         return error;
 }
 
-EXPORT_SYMBOL(ide_config_drive_speed);
-
-
 /*
  * This should get invoked any time we exit the driver to
  * wait for an interrupt response from a drive.  handler() points
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index d97390c054..0e2562f0f7 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -349,7 +349,7 @@ void ide_set_pio(ide_drive_t *drive, u8 req_pio)
                           drive->name, host_pio, req_pio,
                           req_pio == 255 ? "(auto-tune)" : "", pio);
 
-        hwif->set_pio_mode(drive, pio);
+        (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio);
 }
 
 EXPORT_SYMBOL_GPL(ide_set_pio);
@@ -378,39 +378,83 @@ 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;
+
+        if (hwif->set_pio_mode == NULL)
+                return -1;
+
+        /*
+         * TODO: temporary hack for some legacy host drivers that didn't
+         * set transfer mode on the device in ->set_pio_mode method...
+         */
+        if (hwif->set_dma_mode == NULL) {
+                hwif->set_pio_mode(drive, mode - XFER_PIO_0);
+                return 0;
+        }
+
+        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
+                if (ide_config_drive_speed(drive, mode))
+                        return -1;
+                hwif->set_pio_mode(drive, mode - XFER_PIO_0);
+                return 0;
+        } else {
+                hwif->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;
+
+        if (hwif->set_dma_mode == NULL)
+                return -1;
+
+        if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
+                if (ide_config_drive_speed(drive, mode))
+                        return -1;
+                hwif->set_dma_mode(drive, mode);
+                return 0;
+        } else {
+                hwif->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
- *      @speed: speed to attempt 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 speedproc() does not.  High level drivers should never
- *      invoke speedproc() directly.
+ *      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;
 
-        if (hwif->speedproc == NULL)
+        if (hwif->set_dma_mode == NULL)
                 return -1;
 
         rate = ide_rate_filter(drive, rate);
 
-        if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5) {
-                if (hwif->set_pio_mode)
-                        hwif->set_pio_mode(drive, rate - XFER_PIO_0);
+        if (rate >= XFER_PIO_0 && rate <= XFER_PIO_5)
+                return ide_set_pio_mode(drive, rate);
 
-                /*
-                 * FIXME: this is incorrect to return zero here but
-                 * since all users of ide_set_xfer_rate() ignore
-                 * the return value it is not a problem currently
-                 */
-                return 0;
-        }
+        /*
+         * TODO: transfer modes 0x00-0x07 passed from the user-space are
+         * currently handled here which needs fixing (please note that such
+         * case could happen iff the transfer mode has already been set on
+         * the device by ide-proc.c::set_xfer_rate()).
+         */
 
-        return hwif->speedproc(drive, rate);
+        return ide_set_dma_mode(drive, rate);
 }
 
 static void ide_dump_opcode(ide_drive_t *drive)
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index b4c9f63a38..d101171260 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -719,9 +719,9 @@ EXPORT_SYMBOL_GPL(ide_undecoded_slave);
  */
 static void probe_hwif(ide_hwif_t *hwif, void (*fixup)(ide_hwif_t *hwif))
 {
-        unsigned int unit;
         unsigned long flags;
         unsigned int irqd;
+        int unit;
 
         if (hwif->noprobe)
                 return;
@@ -777,10 +777,9 @@ static void probe_hwif(ide_hwif_t *hwif, void (*fixup)(ide_hwif_t *hwif))
                 printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
 
         /*
-         * Second drive should only exist if first drive was found,
-         * but a lot of cdrom drives are configured as single slaves.
+         * Need to probe slave device first to make it release PDIAG-.
          */
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
+        for (unit = MAX_DRIVES - 1; unit >= 0; unit--) {
                 ide_drive_t *drive = &hwif->drives[unit];
                 drive->dn = (hwif->channel ? 2 : 0) + unit;
                 (void) probe_for_drive(drive);
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index e96212ce57..5c0e4078b5 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -397,7 +397,7 @@ static void ide_hwif_restore(ide_hwif_t *hwif, ide_hwif_t *tmp_hwif)
 #endif
 
         hwif->set_pio_mode              = tmp_hwif->set_pio_mode;
-        hwif->speedproc                 = tmp_hwif->speedproc;
+        hwif->set_dma_mode              = tmp_hwif->set_dma_mode;
         hwif->mdma_filter               = tmp_hwif->mdma_filter;
         hwif->udma_filter               = tmp_hwif->udma_filter;
         hwif->selectproc                = tmp_hwif->selectproc;
@@ -1663,20 +1663,13 @@ static struct device_attribute ide_dev_attrs[] = {
         __ATTR_NULL
 };
 
-static int ide_uevent(struct device *dev, char **envp, int num_envp,
-                      char *buffer, int buffer_size)
+static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         ide_drive_t *drive = to_ide_device(dev);
-        int i = 0;
-        int length = 0;
-
-        add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                       "MEDIA=%s", media_string(drive));
-        add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                       "DRIVENAME=%s", drive->name);
-        add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                       "MODALIAS=ide:m-%s", media_string(drive));
-        envp[i] = NULL;
+
+        add_uevent_var(env, "MEDIA=%s", media_string(drive));
+        add_uevent_var(env, "DRIVENAME=%s", drive->name);
+        add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));
         return 0;
 }
 
diff --git a/drivers/ide/legacy/ide_platform.c b/drivers/ide/legacy/ide_platform.c
index ccfb9893a4..b992b2b91f 100644
--- a/drivers/ide/legacy/ide_platform.c
+++ b/drivers/ide/legacy/ide_platform.c
@@ -65,7 +65,7 @@ found:
         hwif->hw.irq = hwif->irq = irq;
 
         hwif->hw.dma = NO_DMA;
-        hwif->hw.chipset = ide_generic;
+        hwif->chipset = hwif->hw.chipset = ide_generic;
 
         if (mmio) {
                 hwif->mmio = 1;
diff --git a/drivers/ide/mips/au1xxx-ide.c b/drivers/ide/mips/au1xxx-ide.c
index 85819ae206..aebde49365 100644
--- a/drivers/ide/mips/au1xxx-ide.c
+++ b/drivers/ide/mips/au1xxx-ide.c
@@ -101,12 +101,7 @@ void auide_outsw(unsigned long port, void *addr, u32 count)
 
 static void au1xxx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        int mem_sttime;
-        int mem_stcfg;
-        u8 speed;
-
-        mem_sttime = 0;
-        mem_stcfg  = au_readl(MEM_STCFG2);
+        int mem_sttime = 0, mem_stcfg = au_readl(MEM_STCFG2);
 
         /* set pio mode! */
         switch(pio) {
@@ -164,18 +159,11 @@ static void au1xxx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
         au_writel(mem_sttime,MEM_STTIME2);
         au_writel(mem_stcfg,MEM_STCFG2);
-
-        speed = pio + XFER_PIO_0;
-        ide_config_drive_speed(drive, speed);
 }
 
-static int auide_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void auide_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        int mem_sttime;
-        int mem_stcfg;
-
-        mem_sttime = 0;
-        mem_stcfg  = au_readl(MEM_STCFG2);
+        int mem_sttime = 0, mem_stcfg = au_readl(MEM_STCFG2);
 
         switch(speed) {
 #ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
@@ -211,16 +199,11 @@ static int auide_tune_chipset(ide_drive_t *drive, const u8 speed)
                 break;
 #endif
         default:
-                return 1;
+                return;
         }
 
-        if (ide_config_drive_speed(drive, speed))
-                return 1;
-
         au_writel(mem_sttime,MEM_STTIME2);
         au_writel(mem_stcfg,MEM_STCFG2);
-
-        return 0;
 }
 
 /*
@@ -682,6 +665,7 @@ static int au_ide_probe(struct device *dev)
 #endif
 
         hwif->pio_mask = ATA_PIO4;
+        hwif->host_flags = IDE_HFLAG_POST_SET_MODE;
 
         hwif->noprobe = 0;
         hwif->drives[0].unmask          = 1;
@@ -702,7 +686,7 @@ static int au_ide_probe(struct device *dev)
 #endif
 
         hwif->set_pio_mode              = &au1xxx_set_pio_mode;
-        hwif->speedproc                 = &auide_tune_chipset;
+        hwif->set_dma_mode              = &auide_set_dma_mode;
 
 #ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
         hwif->dma_off_quietly           = &auide_dma_off_quietly;
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index 0d5f62c5df..d6cb2d5143 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -87,7 +87,7 @@ static u8 pci_bus_clock_list_ultra (u8 speed, struct chipset_bus_clock_list_entr
         return chipset_table->ultra_settings;
 }
 
-static int aec6210_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void aec6210_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -111,10 +111,9 @@ static int aec6210_tune_chipset(ide_drive_t *drive, const u8 speed)
         tmp2 = ((ultra_conf << (2*drive->dn)) | (tmp1 & ~(3 << (2*drive->dn))));
         pci_write_config_byte(dev, 0x54, tmp2);
         local_irq_restore(flags);
-        return(ide_config_drive_speed(drive, speed));
 }
 
-static int aec6260_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void aec6260_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -135,12 +134,11 @@ static int aec6260_tune_chipset(ide_drive_t *drive, const u8 speed)
         tmp2 = ((ultra_conf << (4*unit)) | (tmp1 & ~(7 << (4*unit))));
         pci_write_config_byte(dev, (0x44|hwif->channel), tmp2);
         local_irq_restore(flags);
-        return(ide_config_drive_speed(drive, speed));
 }
 
 static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void) HWIF(drive)->speedproc(drive, pio + XFER_PIO_0);
+        drive->hwif->set_dma_mode(drive, pio + XFER_PIO_0);
 }
 
 static int aec62xx_config_drive_xfer_rate (ide_drive_t *drive)
@@ -205,9 +203,9 @@ static void __devinit init_hwif_aec62xx(ide_hwif_t *hwif)
         if (dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF) {
                 if(hwif->mate)
                         hwif->mate->serialized = hwif->serialized = 1;
-                hwif->speedproc = &aec6210_tune_chipset;
+                hwif->set_dma_mode = &aec6210_set_mode;
         } else
-                hwif->speedproc = &aec6260_tune_chipset;
+                hwif->set_dma_mode = &aec6260_set_mode;
 
         if (!hwif->dma_base) {
                 hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/alim15x3.c b/drivers/ide/pci/alim15x3.c
index d04b966b43..0b83443bf2 100644
--- a/drivers/ide/pci/alim15x3.c
+++ b/drivers/ide/pci/alim15x3.c
@@ -283,14 +283,14 @@ static int ali_get_info (char *buffer, char **addr, off_t offset, int count)
 #endif  /* defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS) */
 
 /**
- *      ali_tune_pio    -       set host controller for PIO mode
+ *      ali_set_pio_mode        -       set host controller for PIO mode
  *      @drive: drive
  *      @pio: PIO mode number
  *
  *      Program the controller for the given PIO mode.
  */
 
-static void ali_tune_pio(ide_drive_t *drive, const u8 pio)
+static void ali_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
@@ -358,21 +358,6 @@ static void ali_tune_pio(ide_drive_t *drive, const u8 pio)
 }
 
 /**
- *      ali_set_pio_mode        -       set up drive for PIO mode
- *      @drive: drive to tune
- *      @pio: desired mode
- *
- *      Program the controller with the desired PIO timing for the given drive.
- *      Then set up the drive itself.
- */
-
-static void ali_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        ali_tune_pio(drive, pio);
-        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
-/**
  *      ali_udma_filter         -       compute UDMA mask
  *      @drive: IDE device
  *
@@ -401,15 +386,14 @@ static u8 ali_udma_filter(ide_drive_t *drive)
 }
 
 /**
- *      ali15x3_tune_chipset    -       set up chipset/drive for new speed
- *      @drive: drive to configure for
- *      @speed: desired speed
+ *      ali_set_dma_mode        -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
  *      Configure the hardware for the desired IDE transfer mode.
- *      We also do the needed drive configuration through helpers
  */
 
-static int ali15x3_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void ali_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -419,7 +403,7 @@ static int ali15x3_tune_chipset(ide_drive_t *drive, const u8 speed)
         int m5229_udma          = (hwif->channel) ? 0x57 : 0x56;
 
         if (speed < XFER_PIO_0)
-                return 1;
+                return;
 
         if (speed == XFER_UDMA_6)
                 speed1 = 0x47;
@@ -450,7 +434,6 @@ static int ali15x3_tune_chipset(ide_drive_t *drive, const u8 speed)
                         pci_write_config_byte(dev, 0x4b, tmpbyte);
                 }
         }
-        return (ide_config_drive_speed(drive, speed));
 }
 
 /**
@@ -699,7 +682,7 @@ static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
 {
         hwif->autodma = 0;
         hwif->set_pio_mode = &ali_set_pio_mode;
-        hwif->speedproc = &ali15x3_tune_chipset;
+        hwif->set_dma_mode = &ali_set_dma_mode;
         hwif->udma_filter = &ali_udma_filter;
 
         /* don't use LBA48 DMA on ALi devices before rev 0xC5 */
@@ -711,6 +694,10 @@ static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
                 return;
         }
 
+        /*
+         * check in ->init_dma guarantees m5229_revision >= 0x20 here
+         */
+
         if (m5229_revision > 0x20)
                 hwif->atapi_dma = 1;
 
@@ -728,18 +715,15 @@ static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
         hwif->mwdma_mask = 0x07;
         hwif->swdma_mask = 0x07;
 
-        if (m5229_revision >= 0x20) {
-                /*
-                 * M1543C or newer for DMAing
-                 */
-                hwif->ide_dma_check = &ali15x3_config_drive_for_dma;
-                hwif->dma_setup = &ali15x3_dma_setup;
-                if (!noautodma)
-                        hwif->autodma = 1;
-
-                if (hwif->cbl != ATA_CBL_PATA40_SHORT)
-                        hwif->cbl = ata66_ali15x3(hwif);
-        }
+        hwif->ide_dma_check = &ali15x3_config_drive_for_dma;
+        hwif->dma_setup = &ali15x3_dma_setup;
+
+        if (hwif->cbl != ATA_CBL_PATA40_SHORT)
+                hwif->cbl = ata66_ali15x3(hwif);
+
+        if (!noautodma)
+                hwif->autodma = 1;
+
         hwif->drives[0].autodma = hwif->autodma;
         hwif->drives[1].autodma = hwif->autodma;
 }
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 513205e52a..6ff4089a23 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -1,5 +1,5 @@
 /*
- * Version 2.22
+ * Version 2.23
  *
  * AMD 755/756/766/8111 and nVidia nForce/2/2s/3/3s/CK804/MCP04
  * IDE driver for Linux.
@@ -229,20 +229,16 @@ static void amd_set_speed(struct pci_dev *dev, unsigned char dn, struct ide_timi
 }
 
 /*
- * amd_set_drive() computes timing values configures the drive and
- * the chipset to a desired transfer mode. It also can be called
- * by upper layers.
+ * amd_set_drive() computes timing values and configures the chipset
+ * to a desired transfer mode.  It also can be called by upper layers.
  */
 
-static int amd_set_drive(ide_drive_t *drive, const u8 speed)
+static void amd_set_drive(ide_drive_t *drive, const u8 speed)
 {
         ide_drive_t *peer = HWIF(drive)->drives + (~drive->dn & 1);
         struct ide_timing t, p;
         int T, UT;
 
-        if (speed != XFER_PIO_SLOW)
-                ide_config_drive_speed(drive, speed);
-
         T = 1000000000 / amd_clock;
         UT = (amd_config->udma_mask == ATA_UDMA2) ? T : (T / 2);
 
@@ -257,12 +253,6 @@ static int amd_set_drive(ide_drive_t *drive, const u8 speed)
         if (speed == XFER_UDMA_6 && amd_clock <= 33333) t.udma = 15;
 
         amd_set_speed(HWIF(drive)->pci_dev, drive->dn, &t);
-
-        if (!drive->init_speed) 
-                drive->init_speed = speed;
-        drive->current_speed = speed;
-
-        return 0;
 }
 
 /*
@@ -399,7 +389,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &amd_set_pio_mode;
-        hwif->speedproc = &amd_set_drive;
+        hwif->set_dma_mode = &amd_set_drive;
 
         for (i = 0; i < 2; i++) {
                 hwif->drives[i].io_32bit = 1;
@@ -441,7 +431,8 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \
                 .bootable       = ON_BOARD,                             \
                 .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST            \
-                                | IDE_HFLAG_PIO_NO_DOWNGRADE,           \
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE            \
+                                | IDE_HFLAG_POST_SET_MODE,              \
                 .pio_mask       = ATA_PIO5,                             \
         }
 
@@ -454,7 +445,8 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .enablebits     = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \
                 .bootable       = ON_BOARD,                             \
                 .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST            \
-                                | IDE_HFLAG_PIO_NO_DOWNGRADE,           \
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE            \
+                                | IDE_HFLAG_POST_SET_MODE,              \
                 .pio_mask       = ATA_PIO5,                             \
         }
 
diff --git a/drivers/ide/pci/atiixp.c b/drivers/ide/pci/atiixp.c
index 178876a3af..0eb97f021d 100644
--- a/drivers/ide/pci/atiixp.c
+++ b/drivers/ide/pci/atiixp.c
@@ -122,14 +122,14 @@ static void atiixp_dma_host_off(ide_drive_t *drive)
 }
 
 /**
- *      atiixp_tune_pio -       tune a drive attached to a ATIIXP
- *      @drive: drive to tune
- *      @pio: desired PIO mode
+ *      atiixp_set_pio_mode     -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      Set the interface PIO mode.
  */
 
-static void atiixp_tune_pio(ide_drive_t *drive, u8 pio)
+static void atiixp_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         struct pci_dev *dev = drive->hwif->pci_dev;
         unsigned long flags;
@@ -153,23 +153,16 @@ static void atiixp_tune_pio(ide_drive_t *drive, u8 pio)
         spin_unlock_irqrestore(&atiixp_lock, flags);
 }
 
-static void atiixp_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        atiixp_tune_pio(drive, pio);
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
 /**
- *      atiixp_tune_chipset     -       tune a ATIIXP interface
- *      @drive: IDE drive to tune
- *      @speed: speed to configure
+ *      atiixp_set_dma_mode     -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      Set a ATIIXP interface channel to the desired speeds. This involves
- *      requires the right timing data into the ATIIXP configuration space
- *      then setting the drive parameters appropriately
+ *      Set a ATIIXP host controller to the desired DMA mode.  This involves
+ *      programming the right timing data into the PCI configuration space.
  */
 
-static int atiixp_speedproc(ide_drive_t *drive, const u8 speed)
+static void atiixp_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         struct pci_dev *dev = drive->hwif->pci_dev;
         unsigned long flags;
@@ -204,9 +197,7 @@ static int atiixp_speedproc(ide_drive_t *drive, const u8 speed)
         else
                 pio = speed - XFER_PIO_0;
 
-        atiixp_tune_pio(drive, pio);
-
-        return ide_config_drive_speed(drive, speed);
+        atiixp_set_pio_mode(drive, pio);
 }
 
 /**
@@ -249,7 +240,7 @@ static void __devinit init_hwif_atiixp(ide_hwif_t *hwif)
 
         hwif->autodma = 0;
         hwif->set_pio_mode = &atiixp_set_pio_mode;
-        hwif->speedproc = &atiixp_speedproc;
+        hwif->set_dma_mode = &atiixp_set_dma_mode;
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
 
diff --git a/drivers/ide/pci/cmd64x.c b/drivers/ide/pci/cmd64x.c
index 0b568c60f9..d50f15e34b 100644
--- a/drivers/ide/pci/cmd64x.c
+++ b/drivers/ide/pci/cmd64x.c
@@ -280,10 +280,9 @@ static void cmd64x_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 return;
 
         cmd64x_tune_pio(drive, pio);
-        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static int cmd64x_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void cmd64x_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -324,13 +323,11 @@ static int cmd64x_tune_chipset(ide_drive_t *drive, const u8 speed)
                 program_cycle_times(drive, 480, 215);
                 break;
         default:
-                return 1;
+                return;
         }
 
         if (speed >= XFER_SW_DMA_0)
                 (void) pci_write_config_byte(dev, pciU, regU);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
@@ -524,7 +521,7 @@ static void __devinit init_hwif_cmd64x(ide_hwif_t *hwif)
         pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
 
         hwif->set_pio_mode = &cmd64x_set_pio_mode;
-        hwif->speedproc = &cmd64x_tune_chipset;
+        hwif->set_dma_mode = &cmd64x_set_dma_mode;
 
         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
 
diff --git a/drivers/ide/pci/cs5520.c b/drivers/ide/pci/cs5520.c
index 1217d2a747..fbce90048a 100644
--- a/drivers/ide/pci/cs5520.c
+++ b/drivers/ide/pci/cs5520.c
@@ -96,22 +96,13 @@ static void cs5520_set_pio_mode(ide_drive_t *drive, const u8 pio)
         reg = inb(hwif->dma_base + 0x02 + 8*controller);
         reg |= 1<<((drive->dn&1)+5);
         outb(reg, hwif->dma_base + 0x02 + 8*controller);
-
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static int cs5520_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void cs5520_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         printk(KERN_ERR "cs55x0: bad ide timing.\n");
 
         cs5520_set_pio_mode(drive, 0);
-
-        /*
-         * FIXME: this is incorrect to return zero here but
-         * since all users of ide_set_xfer_rate() ignore
-         * the return value it is not a problem currently
-         */
-        return 0;
 }
 
 static int cs5520_config_drive_xfer_rate(ide_drive_t *drive)
@@ -150,26 +141,25 @@ static int cs5520_dma_on(ide_drive_t *drive)
 static void __devinit init_hwif_cs5520(ide_hwif_t *hwif)
 {
         hwif->set_pio_mode = &cs5520_set_pio_mode;
-        hwif->speedproc = &cs5520_tune_chipset;
-        hwif->ide_dma_check = &cs5520_config_drive_xfer_rate;
-        hwif->ide_dma_on = &cs5520_dma_on;
+        hwif->set_dma_mode = &cs5520_set_dma_mode;
 
-        if(!noautodma)
-                hwif->autodma = 1;
-        
-        if(!hwif->dma_base)
-        {
-                hwif->drives[0].autotune = 1;
-                hwif->drives[1].autotune = 1;
+        if (hwif->dma_base == 0) {
+                hwif->drives[1].autotune = hwif->drives[0].autotune = 1;
                 return;
         }
 
+        hwif->ide_dma_check = &cs5520_config_drive_xfer_rate;
+        hwif->ide_dma_on = &cs5520_dma_on;
+
         /* ATAPI is harder so leave it for now */
         hwif->atapi_dma = 0;
         hwif->ultra_mask = 0;
         hwif->swdma_mask = 0;
         hwif->mwdma_mask = 0;
-        
+
+        if (!noautodma)
+                hwif->autodma = 1;
+
         hwif->drives[0].autodma = hwif->autodma;
         hwif->drives[1].autodma = hwif->autodma;
 }
diff --git a/drivers/ide/pci/cs5530.c b/drivers/ide/pci/cs5530.c
index 741507b4cd..e4121577ce 100644
--- a/drivers/ide/pci/cs5530.c
+++ b/drivers/ide/pci/cs5530.c
@@ -30,22 +30,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 
-/**
- *      cs5530_xfer_set_mode    -       set a new transfer mode at the drive
- *      @drive: drive to tune
- *      @mode: new mode
- *
- *      Logging wrapper to the IDE driver speed configuration. This can
- *      probably go away now.
- */
- 
-static int cs5530_set_xfer_mode (ide_drive_t *drive, u8 mode)
-{
-        printk(KERN_DEBUG "%s: cs5530_set_xfer_mode(%s)\n",
-                drive->name, ide_xfer_verbose(mode));
-        return (ide_config_drive_speed(drive, mode));
-}
-
 /*
  * Here are the standard PIO mode 0-4 timings for each "format".
  * Format-0 uses fast data reg timings, with slower command reg timings.
@@ -62,20 +46,12 @@ static unsigned int cs5530_pio_timings[2][5] = {
 #define CS5530_BAD_PIO(timings) (((timings)&~0x80000000)==0x0000e132)
 #define CS5530_BASEREG(hwif)    (((hwif)->dma_base & ~0xf) + ((hwif)->channel ? 0x30 : 0x20))
 
-static void cs5530_tunepio(ide_drive_t *drive, u8 pio)
-{
-        unsigned long basereg = CS5530_BASEREG(drive->hwif);
-        unsigned int format = (inl(basereg + 4) >> 31) & 1;
-
-        outl(cs5530_pio_timings[format][pio], basereg + ((drive->dn & 1)<<3));
-}
-
 /**
- *      cs5530_set_pio_mode     -       set PIO mode
+ *      cs5530_set_pio_mode     -       set host controller for PIO mode
  *      @drive: drive
  *      @pio: PIO mode number
  *
- *      Handles setting of PIO mode for both the chipset and drive.
+ *      Handles setting of PIO mode for the chipset.
  *
  *      The init_hwif_cs5530() routine guarantees that all drives
  *      will have valid default PIO timings set up before we get here.
@@ -83,8 +59,10 @@ static void cs5530_tunepio(ide_drive_t *drive, u8 pio)
 
 static void cs5530_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        if (cs5530_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
-                cs5530_tunepio(drive, pio);
+        unsigned long basereg = CS5530_BASEREG(drive->hwif);
+        unsigned int format = (inl(basereg + 4) >> 31) & 1;
+
+        outl(cs5530_pio_timings[format][pio], basereg + ((drive->dn & 1)<<3));
 }
 
 /**
@@ -142,20 +120,11 @@ static int cs5530_config_dma(ide_drive_t *drive)
         return 1;
 }
 
-static int cs5530_tune_chipset(ide_drive_t *drive, const u8 mode)
+static void cs5530_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
         unsigned long basereg;
         unsigned int reg, timings = 0;
 
-        /*
-         * Tell the drive to switch to the new mode; abort on failure.
-         */
-        if (cs5530_set_xfer_mode(drive, mode))
-                return 1;       /* failure */
-
-        /*
-         * Now tune the chipset to match the drive:
-         */
         switch (mode) {
                 case XFER_UDMA_0:       timings = 0x00921250; break;
                 case XFER_UDMA_1:       timings = 0x00911140; break;
@@ -180,8 +149,6 @@ static int cs5530_tune_chipset(ide_drive_t *drive, const u8 mode)
                 outl(reg, basereg + 4);         /* write drive0 config register */
                 outl(timings, basereg + 12);    /* write drive1 config register */
         }
-
-        return 0;       /* success */
 }
 
 /**
@@ -299,7 +266,7 @@ static void __devinit init_hwif_cs5530 (ide_hwif_t *hwif)
                 hwif->serialized = hwif->mate->serialized = 1;
 
         hwif->set_pio_mode = &cs5530_set_pio_mode;
-        hwif->speedproc = &cs5530_tune_chipset;
+        hwif->set_dma_mode = &cs5530_set_dma_mode;
 
         basereg = CS5530_BASEREG(hwif);
         d0_timings = inl(basereg + 0);
@@ -340,6 +307,7 @@ static ide_pci_device_t cs5530_chipset __devinitdata = {
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
         .pio_mask       = ATA_PIO4,
+        .host_flags     = IDE_HFLAG_POST_SET_MODE,
 };
 
 static int __devinit cs5530_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/cs5535.c b/drivers/ide/pci/cs5535.c
index 383b7eccbc..257865778f 100644
--- a/drivers/ide/pci/cs5535.c
+++ b/drivers/ide/pci/cs5535.c
@@ -131,24 +131,21 @@ static void cs5535_set_speed(ide_drive_t *drive, const u8 speed)
         }
 }
 
-/****
- *      cs5535_set_drive         -     Configure the drive to the new speed
- *      @drive: Drive to set up
- *      @speed: desired speed
+/**
+ *      cs5535_set_dma_mode     -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      cs5535_set_drive() configures the drive and the chipset to a
- *      new speed. It also can be called by upper layers.
+ *      Programs the chipset for DMA mode.
  */
-static int cs5535_set_drive(ide_drive_t *drive, u8 speed)
+
+static void cs5535_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_config_drive_speed(drive, speed);
         cs5535_set_speed(drive, speed);
-
-        return 0;
 }
 
 /**
- *      cs5535_set_pio_mode     -       PIO setup
+ *      cs5535_set_pio_mode     -       set host controller for PIO mode
  *      @drive: drive
  *      @pio: PIO mode number
  *
@@ -157,7 +154,6 @@ static int cs5535_set_drive(ide_drive_t *drive, u8 speed)
 
 static void cs5535_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_config_drive_speed(drive, XFER_PIO_0 + pio);
         cs5535_set_speed(drive, XFER_PIO_0 + pio);
 }
 
@@ -194,12 +190,16 @@ static u8 __devinit cs5535_cable_detect(struct pci_dev *dev)
  */
 static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
 {
-        int i;
-
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &cs5535_set_pio_mode;
-        hwif->speedproc = &cs5535_set_drive;
+        hwif->set_dma_mode = &cs5535_set_dma_mode;
+
+        hwif->drives[1].autotune = hwif->drives[0].autotune = 1;
+
+        if (hwif->dma_base == 0)
+                return;
+
         hwif->ide_dma_check = &cs5535_dma_check;
 
         hwif->atapi_dma = 1;
@@ -211,11 +211,7 @@ static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
         if (!noautodma)
                 hwif->autodma = 1;
 
-        /* just setting autotune and not worrying about bios timings */
-        for (i = 0; i < 2; i++) {
-                hwif->drives[i].autotune = 1;
-                hwif->drives[i].autodma = hwif->autodma;
-        }
+        hwif->drives[1].autodma = hwif->drives[0].autodma = hwif->autodma;
 }
 
 static ide_pci_device_t cs5535_chipset __devinitdata = {
@@ -223,7 +219,7 @@ static ide_pci_device_t cs5535_chipset __devinitdata = {
         .init_hwif      = init_hwif_cs5535,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
-        .host_flags     = IDE_HFLAG_SINGLE,
+        .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_POST_SET_MODE,
         .pio_mask       = ATA_PIO4,
 };
 
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
index a1bb10188f..218852aaf2 100644
--- a/drivers/ide/pci/hpt34x.c
+++ b/drivers/ide/pci/hpt34x.c
@@ -43,7 +43,7 @@
 
 #define HPT343_DEBUG_DRIVE_INFO         0
 
-static int hpt34x_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void hpt34x_set_mode(ide_drive_t *drive, const u8 speed)
 {
         struct pci_dev *dev     = HWIF(drive)->pci_dev;
         u32 reg1= 0, tmp1 = 0, reg2 = 0, tmp2 = 0;
@@ -73,13 +73,11 @@ static int hpt34x_tune_chipset(ide_drive_t *drive, const u8 speed)
                 drive->dn, reg1, tmp1, reg2, tmp2,
                 hi_speed, lo_speed);
 #endif /* HPT343_DEBUG_DRIVE_INFO */
-
-        return(ide_config_drive_speed(drive, speed));
 }
 
 static void hpt34x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void) hpt34x_tune_chipset(drive, (XFER_PIO_0 + pio));
+        hpt34x_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 static int hpt34x_config_drive_xfer_rate (ide_drive_t *drive)
@@ -145,7 +143,8 @@ static void __devinit init_hwif_hpt34x(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &hpt34x_set_pio_mode;
-        hwif->speedproc = &hpt34x_tune_chipset;
+        hwif->set_dma_mode = &hpt34x_set_mode;
+
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
 
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 0e7d3b60d4..8812a9bb03 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -600,7 +600,7 @@ static u32 get_speed_setting(u8 speed, struct hpt_info *info)
         return (*info->settings)[i];
 }
 
-static int hpt36x_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void hpt36x_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev  *dev    = hwif->pci_dev;
@@ -623,11 +623,9 @@ static int hpt36x_tune_chipset(ide_drive_t *drive, const u8 speed)
         new_itr &= ~0xc0000000;
 
         pci_write_config_dword(dev, itr_addr, new_itr);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
-static int hpt37x_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void hpt37x_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev  *dev    = hwif->pci_dev;
@@ -647,24 +645,22 @@ static int hpt37x_tune_chipset(ide_drive_t *drive, const u8 speed)
         if (speed < XFER_MW_DMA_0)
                 new_itr &= ~0x80000000; /* Disable on-chip PIO FIFO/buffer */
         pci_write_config_dword(dev, itr_addr, new_itr);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
-static int hpt3xx_tune_chipset(ide_drive_t *drive, u8 speed)
+static void hpt3xx_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct hpt_info *info   = pci_get_drvdata(hwif->pci_dev);
 
         if (info->chip_type >= HPT370)
-                return hpt37x_tune_chipset(drive, speed);
+                hpt37x_set_mode(drive, speed);
         else    /* hpt368: hpt_minimum_revision(dev, 2) */
-                return hpt36x_tune_chipset(drive, speed);
+                hpt36x_set_mode(drive, speed);
 }
 
 static void hpt3xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void) hpt3xx_tune_chipset (drive, XFER_PIO_0 + pio);
+        hpt3xx_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 static int hpt3xx_quirkproc(ide_drive_t *drive)
@@ -1257,7 +1253,7 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
         hwif->select_data       = hwif->channel ? 0x54 : 0x50;
 
         hwif->set_pio_mode      = &hpt3xx_set_pio_mode;
-        hwif->speedproc         = &hpt3xx_tune_chipset;
+        hwif->set_dma_mode      = &hpt3xx_set_mode;
         hwif->quirkproc         = &hpt3xx_quirkproc;
         hwif->intrproc          = &hpt3xx_intrproc;
         hwif->maskproc          = &hpt3xx_maskproc;
diff --git a/drivers/ide/pci/it8213.c b/drivers/ide/pci/it8213.c
index 76e91ff942..ecf4ce078d 100644
--- a/drivers/ide/pci/it8213.c
+++ b/drivers/ide/pci/it8213.c
@@ -48,15 +48,15 @@ static u8 it8213_dma_2_pio (u8 xfer_rate) {
         }
 }
 
-/*
- *      it8213_tune_pio -       tune a drive
- *      @drive: drive to tune
- *      @pio: desired PIO mode
+/**
+ *      it8213_set_pio_mode     -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      Set the interface PIO mode.
  */
 
-static void it8213_tune_pio(ide_drive_t *drive, const u8 pio)
+static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -105,21 +105,15 @@ static void it8213_tune_pio(ide_drive_t *drive, const u8 pio)
         spin_unlock_irqrestore(&tune_lock, flags);
 }
 
-static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        it8213_tune_pio(drive, pio);
-        ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
 /**
- *      it8213_tune_chipset     -       set controller timings
- *      @drive: Drive to set up
- *      @speed: speed we want to achieve
+ *      it8213_set_dma_mode     -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      Tune the ITE chipset for the desired mode.
+ *      Tune the ITE chipset for the DMA mode.
  */
 
-static int it8213_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void it8213_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -152,7 +146,7 @@ static int it8213_tune_chipset(ide_drive_t *drive, const u8 speed)
                 case XFER_SW_DMA_2:
                         break;
                 default:
-                        return -1;
+                        return;
         }
 
         if (speed >= XFER_UDMA_0) {
@@ -182,9 +176,7 @@ static int it8213_tune_chipset(ide_drive_t *drive, const u8 speed)
                         pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
         }
 
-        it8213_tune_pio(drive, it8213_dma_2_pio(speed));
-
-        return ide_config_drive_speed(drive, speed);
+        it8213_set_pio_mode(drive, it8213_dma_2_pio(speed));
 }
 
 /**
@@ -220,7 +212,7 @@ static void __devinit init_hwif_it8213(ide_hwif_t *hwif)
 {
         u8 reg42h = 0;
 
-        hwif->speedproc = &it8213_tune_chipset;
+        hwif->set_dma_mode = &it8213_set_dma_mode;
         hwif->set_pio_mode = &it8213_set_pio_mode;
 
         hwif->autodma = 0;
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index 758a98230c..1b69d82478 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -229,24 +229,24 @@ static void it821x_clock_strategy(ide_drive_t *drive)
 }
 
 /**
- *      it821x_tunepio  -       tune a drive
- *      @drive: drive to tune
- *      @pio: the desired PIO mode
+ *      it821x_set_pio_mode     -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
- *      Try to tune the drive/host to the desired PIO mode taking into
- *      the consideration the maximum PIO mode supported by the other
- *      device on the cable.
+ *      Tune the host to the desired PIO mode taking into the consideration
+ *      the maximum PIO mode supported by the other device on the cable.
  */
 
-static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
+static void it821x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = drive->hwif;
         struct it821x_dev *itdev = ide_get_hwifdata(hwif);
         int unit = drive->select.b.unit;
         ide_drive_t *pair = &hwif->drives[1 - unit];
+        u8 set_pio = pio;
 
         /* Spec says 89 ref driver uses 88 */
-        static u16 pio[]        = { 0xAA88, 0xA382, 0xA181, 0x3332, 0x3121 };
+        static u16 pio_timings[]= { 0xAA88, 0xA382, 0xA181, 0x3332, 0x3121 };
         static u8 pio_want[]    = { ATA_66, ATA_66, ATA_66, ATA_66, ATA_ANY };
 
         /*
@@ -261,22 +261,12 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
                         set_pio = pair_pio;
         }
 
-        if (itdev->smart)
-                return 0;
-
         /* We prefer 66Mhz clock for PIO 0-3, don't care for PIO4 */
         itdev->want[unit][1] = pio_want[set_pio];
         itdev->want[unit][0] = 1;       /* PIO is lowest priority */
-        itdev->pio[unit] = pio[set_pio];
+        itdev->pio[unit] = pio_timings[set_pio];
         it821x_clock_strategy(drive);
         it821x_program(drive, itdev->pio[unit]);
-
-        return ide_config_drive_speed(drive, XFER_PIO_0 + set_pio);
-}
-
-static void it821x_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        (void)it821x_tunepio(drive, pio);
 }
 
 /**
@@ -405,47 +395,24 @@ static int it821x_dma_end(ide_drive_t *drive)
 }
 
 /**
- *      it821x_tune_chipset     -       set controller timings
- *      @drive: Drive to set up
- *      @speed: speed we want to achieve
+ *      it821x_set_dma_mode     -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      Tune the ITE chipset for the desired mode.
+ *      Tune the ITE chipset for the desired DMA mode.
  */
 
-static int it821x_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void it821x_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-
-        ide_hwif_t *hwif        = drive->hwif;
-        struct it821x_dev *itdev = ide_get_hwifdata(hwif);
-
-        if (itdev->smart == 0) {
-                switch (speed) {
-                        /* MWDMA tuning is really hard because our MWDMA and PIO
-                           timings are kept in the same place. We can switch in the
-                           host dma on/off callbacks */
-                        case XFER_MW_DMA_2:
-                        case XFER_MW_DMA_1:
-                        case XFER_MW_DMA_0:
-                                it821x_tune_mwdma(drive, (speed - XFER_MW_DMA_0));
-                                break;
-                        case XFER_UDMA_6:
-                        case XFER_UDMA_5:
-                        case XFER_UDMA_4:
-                        case XFER_UDMA_3:
-                        case XFER_UDMA_2:
-                        case XFER_UDMA_1:
-                        case XFER_UDMA_0:
-                                it821x_tune_udma(drive, (speed - XFER_UDMA_0));
-                                break;
-                        default:
-                                return 1;
-                }
-
-                return ide_config_drive_speed(drive, speed);
-        }
-
-        /* don't touch anything in the smart mode */
-        return 0;
+        /*
+         * MWDMA tuning is really hard because our MWDMA and PIO
+         * timings are kept in the same place.  We can switch in the
+         * host dma on/off callbacks.
+         */
+        if (speed >= XFER_UDMA_0 && speed <= XFER_UDMA_6)
+                it821x_tune_udma(drive, speed - XFER_UDMA_0);
+        else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2)
+                it821x_tune_mwdma(drive, speed - XFER_MW_DMA_0);
 }
 
 /**
@@ -629,14 +596,15 @@ static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
                         printk(KERN_WARNING "it821x: Revision 0x10, workarounds activated.\n");
         }
 
-        hwif->speedproc = &it821x_tune_chipset;
-        hwif->set_pio_mode = &it821x_set_pio_mode;
+        if (idev->smart == 0) {
+                hwif->set_pio_mode = &it821x_set_pio_mode;
+                hwif->set_dma_mode = &it821x_set_dma_mode;
 
-        /* MWDMA/PIO clock switching for pass through mode */
-        if(!idev->smart) {
+                /* MWDMA/PIO clock switching for pass through mode */
                 hwif->dma_start = &it821x_dma_start;
                 hwif->ide_dma_end = &it821x_dma_end;
-        }
+        } else
+                hwif->host_flags |= IDE_HFLAG_NO_SET_MODE;
 
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/jmicron.c b/drivers/ide/pci/jmicron.c
index d379fbaf67..582b4cae2b 100644
--- a/drivers/ide/pci/jmicron.c
+++ b/drivers/ide/pci/jmicron.c
@@ -85,21 +85,18 @@ static u8 __devinit ata66_jmicron(ide_hwif_t *hwif)
 
 static void jmicron_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 /**
- *      jmicron_tune_chipset    -       set controller timings
- *      @drive: Drive to set up
- *      @speed: speed we want to achieve
+ *      jmicron_set_dma_mode    -       set host controller for DMA mode
+ *      @drive: drive
+ *      @mode: DMA mode
  *
- *      As the JMicron snoops for timings all we actually need to do is
- *      set the transfer mode on the device.
+ *      As the JMicron snoops for timings we don't need to do anything here.
  */
 
-static int jmicron_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void jmicron_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
-        return ide_config_drive_speed(drive, speed);
 }
 
 /**
@@ -129,8 +126,8 @@ static int jmicron_config_drive_for_dma (ide_drive_t *drive)
 
 static void __devinit init_hwif_jmicron(ide_hwif_t *hwif)
 {
-        hwif->speedproc = &jmicron_tune_chipset;
         hwif->set_pio_mode = &jmicron_set_pio_mode;
+        hwif->set_dma_mode = &jmicron_set_dma_mode;
 
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index 5fb1eedc81..ad0bdcb0c0 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -146,19 +146,16 @@ static struct udma_timing {
         { 0x1a, 0x01, 0xcb },   /* UDMA mode 6 */
 };
 
-static int pdcnew_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void pdcnew_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         u8 adj                  = (drive->dn & 1) ? 0x08 : 0x00;
-        int                     err;
 
         /*
-         * Issue SETFEATURES_XFER to the drive first. PDC202xx hardware will
+         * IDE core issues SETFEATURES_XFER to the drive first (thanks to
+         * IDE_HFLAG_POST_SET_MODE in ->host_flags).  PDC202xx hardware will
          * automatically set the timing registers based on 100 MHz PLL output.
-         */
-        err = ide_config_drive_speed(drive, speed);
-
-        /*
+         *
          * As we set up the PLL to output 133 MHz for UltraDMA/133 capable
          * chips, we must override the default register settings...
          */
@@ -211,13 +208,11 @@ static int pdcnew_tune_chipset(ide_drive_t *drive, const u8 speed)
 
                 set_indexed_reg(hwif, 0x10 + adj, tmp & 0x7f);
         }
-
-        return err;
 }
 
 static void pdcnew_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void)pdcnew_tune_chipset(drive, XFER_PIO_0 + pio);
+        pdcnew_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 static u8 pdcnew_cable_detect(ide_hwif_t *hwif)
@@ -490,9 +485,9 @@ static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &pdcnew_set_pio_mode;
+        hwif->set_dma_mode = &pdcnew_set_mode;
 
         hwif->quirkproc = &pdcnew_quirkproc;
-        hwif->speedproc = &pdcnew_tune_chipset;
         hwif->resetproc = &pdcnew_reset;
 
         hwif->err_stops_fifo = 1;
@@ -583,6 +578,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 1 */
                 .name           = "PDC20269",
                 .init_setup     = init_setup_pdcnew,
@@ -592,6 +588,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 2 */
                 .name           = "PDC20270",
                 .init_setup     = init_setup_pdc20270,
@@ -601,6 +598,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 3 */
                 .name           = "PDC20271",
                 .init_setup     = init_setup_pdcnew,
@@ -610,6 +608,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 4 */
                 .name           = "PDC20275",
                 .init_setup     = init_setup_pdcnew,
@@ -619,6 +618,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 5 */
                 .name           = "PDC20276",
                 .init_setup     = init_setup_pdc20276,
@@ -628,6 +628,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         },{     /* 6 */
                 .name           = "PDC20277",
                 .init_setup     = init_setup_pdcnew,
@@ -637,6 +638,7 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .bootable       = OFF_BOARD,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
+                .host_flags     = IDE_HFLAG_POST_SET_MODE,
         }
 };
 
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index b578307fad..8c3e8cf36e 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -63,7 +63,7 @@ static const char *pdc_quirk_drives[] = {
 
 static void pdc_old_disable_66MHz_clock(ide_hwif_t *);
 
-static int pdc202xx_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void pdc202xx_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -138,13 +138,11 @@ static int pdc202xx_tune_chipset(ide_drive_t *drive, const u8 speed)
         pci_read_config_dword(dev, drive_pci, &drive_conf);
         printk("0x%08x\n", drive_conf);
 #endif
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 static void pdc202xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pdc202xx_tune_chipset(drive, XFER_PIO_0 + pio);
+        pdc202xx_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 static u8 pdc202xx_old_cable_detect (ide_hwif_t *hwif)
@@ -330,14 +328,13 @@ static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &pdc202xx_set_pio_mode;
+        hwif->set_dma_mode = &pdc202xx_set_mode;
 
         hwif->quirkproc = &pdc202xx_quirkproc;
 
         if (hwif->pci_dev->device != PCI_DEVICE_ID_PROMISE_20246)
                 hwif->resetproc = &pdc202xx_reset;
 
-        hwif->speedproc = &pdc202xx_tune_chipset;
-
         hwif->err_stops_fifo = 1;
 
         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/piix.c b/drivers/ide/pci/piix.c
index fd8214a7ab..38c91ba649 100644
--- a/drivers/ide/pci/piix.c
+++ b/drivers/ide/pci/piix.c
@@ -137,13 +137,14 @@ static u8 piix_dma_2_pio (u8 xfer_rate) {
 }
 
 /**
- *      piix_tune_pio           -       tune PIIX for PIO mode
- *      @drive: drive to tune
- *      @pio: desired PIO mode
+ *      piix_set_pio_mode       -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      Set the interface PIO mode based upon the settings done by AMI BIOS.
  */
-static void piix_tune_pio (ide_drive_t *drive, u8 pio)
+
+static void piix_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -204,31 +205,15 @@ static void piix_tune_pio (ide_drive_t *drive, u8 pio)
 }
 
 /**
- *      piix_set_pio_mode       -       set PIO mode
- *      @drive: drive to tune
- *      @pio: desired PIO mode
- *
- *      Set the drive's PIO mode (might be useful if drive is not registered
- *      in CMOS for any reason).
- */
-
-static void piix_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        piix_tune_pio(drive, pio);
-        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
-/**
- *      piix_tune_chipset       -       tune a PIIX interface
- *      @drive: IDE drive to tune
- *      @speed: speed to configure
+ *      piix_set_dma_mode       -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      Set a PIIX interface channel to the desired speeds. This involves
- *      requires the right timing data into the PIIX configuration space
- *      then setting the drive parameters appropriately
+ *      Set a PIIX host controller to the desired DMA mode.  This involves
+ *      programming the right timing data into the PCI configuration space.
  */
 
-static int piix_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void piix_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -259,7 +244,7 @@ static int piix_tune_chipset(ide_drive_t *drive, const u8 speed)
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:     break;
-                default:                return -1;
+                default:                return;
         }
 
         if (speed >= XFER_UDMA_0) {
@@ -288,9 +273,7 @@ static int piix_tune_chipset(ide_drive_t *drive, const u8 speed)
                         pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
         }
 
-        piix_tune_pio(drive, piix_dma_2_pio(speed));
-
-        return ide_config_drive_speed(drive, speed);
+        piix_set_pio_mode(drive, piix_dma_2_pio(speed));
 }
 
 /**
@@ -448,7 +431,8 @@ static void __devinit init_hwif_piix(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &piix_set_pio_mode;
-        hwif->speedproc = &piix_tune_chipset;
+        hwif->set_dma_mode = &piix_set_dma_mode;
+
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
 
diff --git a/drivers/ide/pci/sc1200.c b/drivers/ide/pci/sc1200.c
index 79ecab6894..ee0e3f554d 100644
--- a/drivers/ide/pci/sc1200.c
+++ b/drivers/ide/pci/sc1200.c
@@ -68,17 +68,6 @@ static unsigned short sc1200_get_pci_clock (void)
         return pci_clock;
 }
 
-extern char *ide_xfer_verbose (byte xfer_rate);
-
-/*
- * Set a new transfer mode at the drive
- */
-static int sc1200_set_xfer_mode (ide_drive_t *drive, byte mode)
-{
-        printk("%s: sc1200_set_xfer_mode(%s)\n", drive->name, ide_xfer_verbose(mode));
-        return ide_config_drive_speed(drive, mode);
-}
-
 /*
  * Here are the standard PIO mode 0-4 timings for each "format".
  * Format-0 uses fast data reg timings, with slower command reg timings.
@@ -138,7 +127,7 @@ out:
         return mask;
 }
 
-static int sc1200_tune_chipset(ide_drive_t *drive, const u8 mode)
+static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
         ide_hwif_t              *hwif = HWIF(drive);
         int                     unit = drive->select.b.unit;
@@ -146,17 +135,9 @@ static int sc1200_tune_chipset(ide_drive_t *drive, const u8 mode)
         unsigned short          pci_clock;
         unsigned int            basereg = hwif->channel ? 0x50 : 0x40;
 
-        /*
-         * Tell the drive to switch to the new mode; abort on failure.
-         */
-        if (sc1200_set_xfer_mode(drive, mode))
-                return 1;       /* failure */
-
         pci_clock = sc1200_get_pci_clock();
 
         /*
-         * Now tune the chipset to match the drive:
-         *
          * Note that each DMA mode has several timings associated with it.
          * The correct timing depends on the fast PCI clock freq.
          */
@@ -216,8 +197,6 @@ static int sc1200_tune_chipset(ide_drive_t *drive, const u8 mode)
         } else {
                 pci_write_config_dword(hwif->pci_dev, basereg+12, timings);
         }
-
-        return 0;       /* success */
 }
 
 /*
@@ -286,13 +265,12 @@ static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
         if (mode != -1) {
                 printk("SC1200: %s: changing (U)DMA mode\n", drive->name);
                 hwif->dma_off_quietly(drive);
-                if (sc1200_tune_chipset(drive, mode) == 0)
+                if (ide_set_dma_mode(drive, mode) == 0)
                         hwif->dma_host_on(drive);
                 return;
         }
 
-        if (sc1200_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
-                sc1200_tunepio(drive, pio);
+        sc1200_tunepio(drive, pio);
 }
 
 #ifdef CONFIG_PM
@@ -400,16 +378,20 @@ static void __devinit init_hwif_sc1200 (ide_hwif_t *hwif)
         if (hwif->mate)
                 hwif->serialized = hwif->mate->serialized = 1;
         hwif->autodma = 0;
-        if (hwif->dma_base) {
-                hwif->udma_filter = sc1200_udma_filter;
-                hwif->ide_dma_check = &sc1200_config_dma;
-                hwif->ide_dma_end   = &sc1200_ide_dma_end;
-                if (!noautodma)
-                        hwif->autodma = 1;
-
-                hwif->set_pio_mode = &sc1200_set_pio_mode;
-                hwif->speedproc = &sc1200_tune_chipset;
-        }
+
+        hwif->set_pio_mode = &sc1200_set_pio_mode;
+        hwif->set_dma_mode = &sc1200_set_dma_mode;
+
+        if (hwif->dma_base == 0)
+                return;
+
+        hwif->udma_filter = sc1200_udma_filter;
+        hwif->ide_dma_check = &sc1200_config_dma;
+        hwif->ide_dma_end   = &sc1200_ide_dma_end;
+
+        if (!noautodma)
+                hwif->autodma = 1;
+
         hwif->atapi_dma = 1;
         hwif->ultra_mask = 0x07;
         hwif->mwdma_mask = 0x07;
@@ -423,7 +405,7 @@ static ide_pci_device_t sc1200_chipset __devinitdata = {
         .init_hwif      = init_hwif_sc1200,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
-        .host_flags     = IDE_HFLAG_ABUSE_DMA_MODES,
+        .host_flags     = IDE_HFLAG_ABUSE_DMA_MODES | IDE_HFLAG_POST_SET_MODE,
         .pio_mask       = ATA_PIO4,
 };
 
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index 66a526e0ec..67f06dd11b 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -190,15 +190,15 @@ scc_ide_outsl(unsigned long port, void *addr, u32 count)
 }
 
 /**
- *      scc_tune_pio    -       tune a drive PIO mode
- *      @drive: drive to tune
- *      @mode_wanted: the target operating mode
+ *      scc_set_pio_mode        -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      Load the timing settings for this device mode into the
  *      controller.
  */
 
-static void scc_tune_pio(ide_drive_t *drive, const u8 pio)
+static void scc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct scc_ports *ports = ide_get_hwifdata(hwif);
@@ -221,22 +221,16 @@ static void scc_tune_pio(ide_drive_t *drive, const u8 pio)
         out_be32((void __iomem *)pioct_port, reg);
 }
 
-static void scc_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        scc_tune_pio(drive, pio);
-        ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
 /**
- *      scc_tune_chipset        -       tune a drive DMA mode
- *      @drive: Drive to set up
- *      @speed: speed we want to achieve
+ *      scc_set_dma_mode        -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
  *      Load the timing settings for this device mode into the
  *      controller.
  */
 
-static int scc_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void scc_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct scc_ports *ports = ide_get_hwifdata(hwif);
@@ -271,7 +265,7 @@ static int scc_tune_chipset(ide_drive_t *drive, const u8 speed)
                 idx = speed - XFER_UDMA_0;
                 break;
         default:
-                return 1;
+                return;
         }
 
         jcactsel = JCACTSELtbl[offset][idx];
@@ -287,8 +281,6 @@ static int scc_tune_chipset(ide_drive_t *drive, const u8 speed)
         }
         reg = JCTSStbl[offset][idx] << 16 | JCENVTtbl[offset][idx];
         out_be32((void __iomem *)udenvt_port, reg);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 /**
@@ -708,8 +700,8 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
 
         hwif->dma_setup = scc_dma_setup;
         hwif->ide_dma_end = scc_ide_dma_end;
-        hwif->speedproc = scc_tune_chipset;
         hwif->set_pio_mode = scc_set_pio_mode;
+        hwif->set_dma_mode = scc_set_dma_mode;
         hwif->ide_dma_check = scc_config_drive_for_dma;
         hwif->ide_dma_test_irq = scc_dma_test_irq;
         hwif->udma_filter = scc_udma_filter;
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index 0351cf2104..49ec0ac64a 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -124,7 +124,7 @@ static u8 svwks_csb_check (struct pci_dev *dev)
         return 0;
 }
 
-static void svwks_tune_pio(ide_drive_t *drive, const u8 pio)
+static void svwks_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         static const u8 pio_modes[] = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
         static const u8 drive_pci[] = { 0x41, 0x40, 0x43, 0x42 };
@@ -145,7 +145,7 @@ static void svwks_tune_pio(ide_drive_t *drive, const u8 pio)
         }
 }
 
-static int svwks_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void svwks_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         static const u8 udma_modes[]            = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
         static const u8 dma_modes[]             = { 0x77, 0x21, 0x20 };
@@ -193,14 +193,6 @@ static int svwks_tune_chipset(ide_drive_t *drive, const u8 speed)
         pci_write_config_byte(dev, drive_pci2[drive->dn], dma_timing);
         pci_write_config_byte(dev, (0x56|hwif->channel), ultra_timing);
         pci_write_config_byte(dev, 0x54, ultra_enable);
-
-        return (ide_config_drive_speed(drive, speed));
-}
-
-static void svwks_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        svwks_tune_pio(drive, pio);
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 static int svwks_config_drive_xfer_rate (ide_drive_t *drive)
@@ -384,7 +376,7 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
                 hwif->irq = hwif->channel ? 15 : 14;
 
         hwif->set_pio_mode = &svwks_set_pio_mode;
-        hwif->speedproc = &svwks_tune_chipset;
+        hwif->set_dma_mode = &svwks_set_dma_mode;
         hwif->udma_filter = &svwks_udma_filter;
 
         hwif->atapi_dma = 1;
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index c292e1de1d..85ffaaa39b 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -291,12 +291,8 @@ static void sgiioc4_dma_off_quietly(ide_drive_t *drive)
         drive->hwif->dma_host_off(drive);
 }
 
-static int sgiioc4_speedproc(ide_drive_t *drive, const u8 speed)
+static void sgiioc4_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        if (speed != XFER_MW_DMA_2)
-                return 1;
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 static int sgiioc4_ide_dma_check(ide_drive_t *drive)
@@ -591,11 +587,9 @@ static void __devinit
 ide_init_sgiioc4(ide_hwif_t * hwif)
 {
         hwif->mmio = 1;
-        hwif->atapi_dma = 1;
-        hwif->mwdma_mask = 0x04;
         hwif->pio_mask = 0x00;
         hwif->set_pio_mode = NULL; /* Sets timing for PIO mode */
-        hwif->speedproc = &sgiioc4_speedproc;
+        hwif->set_dma_mode = &sgiioc4_set_dma_mode;
         hwif->selectproc = NULL;/* Use the default routine to select drive */
         hwif->reset_poll = NULL;/* No HBA specific reset_poll needed */
         hwif->pre_reset = NULL; /* No HBA specific pre_set needed */
@@ -606,6 +600,14 @@ ide_init_sgiioc4(ide_hwif_t * hwif)
         hwif->quirkproc = NULL;
         hwif->busproc = NULL;
 
+        hwif->INB = &sgiioc4_INB;
+
+        if (hwif->dma_base == 0)
+                return;
+
+        hwif->atapi_dma = 1;
+        hwif->mwdma_mask = 0x04;
+
         hwif->dma_setup = &sgiioc4_ide_dma_setup;
         hwif->dma_start = &sgiioc4_ide_dma_start;
         hwif->ide_dma_end = &sgiioc4_ide_dma_end;
@@ -617,8 +619,6 @@ ide_init_sgiioc4(ide_hwif_t * hwif)
         hwif->dma_host_off = &sgiioc4_dma_host_off;
         hwif->dma_lost_irq = &sgiioc4_dma_lost_irq;
         hwif->dma_timeout = &ide_dma_timeout;
-
-        hwif->INB = &sgiioc4_INB;
 }
 
 static int __devinit
@@ -688,8 +688,6 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
         /* Initializing chipset IRQ Registers */
         writel(0x03, (void __iomem *)(irqport + IOC4_INTR_SET * 4));
 
-        ide_init_sgiioc4(hwif);
-
         hwif->autodma = 0;
 
         if (dma_base && ide_dma_sgiioc4(hwif, dma_base) == 0) {
@@ -699,6 +697,8 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
                 printk(KERN_INFO "%s: %s Bus-Master DMA disabled\n",
                                  hwif->name, DRV_NAME);
 
+        ide_init_sgiioc4(hwif);
+
         if (probe_hwif_init(hwif))
                 return -EIO;
 
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index 5d1e5e52a0..ce7784996d 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -165,16 +165,16 @@ out:
 }
 
 /**
- *      sil_tune_pio    -       tune a drive
- *      @drive: drive to tune
- *      @pio: the desired PIO mode
+ *      sil_set_pio_mode        -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      Load the timing settings for this device mode into the
  *      controller. If we are in PIO mode 3 or 4 turn on IORDY
  *      monitoring (bit 9). The TF timing is bits 31:16
  */
 
-static void sil_tune_pio(ide_drive_t *drive, u8 pio)
+static void sil_set_pio_mode(ide_drive_t *drive, u8 pio)
 {
         const u16 tf_speed[]    = { 0x328a, 0x2283, 0x1281, 0x10c3, 0x10c1 };
         const u16 data_speed[]  = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
@@ -234,21 +234,15 @@ static void sil_tune_pio(ide_drive_t *drive, u8 pio)
         }
 }
 
-static void sil_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        sil_tune_pio(drive, pio);
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
 /**
- *      siimage_tune_chipset    -       set controller timings
- *      @drive: Drive to set up
- *      @speed: speed we want to achieve
+ *      sil_set_dma_mode        -       set host controller for DMA mode
+ *      @drive: drive
+ *      @speed: DMA mode
  *
- *      Tune the SII chipset for the desired mode.
+ *      Tune the SiI chipset for the desired DMA mode.
  */
 
-static int siimage_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         u8 ultra6[]             = { 0x0F, 0x0B, 0x07, 0x05, 0x03, 0x02, 0x01 };
         u8 ultra5[]             = { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01 };
@@ -303,7 +297,7 @@ static int siimage_tune_chipset(ide_drive_t *drive, const u8 speed)
                         mode |= ((unit) ? 0x30 : 0x03);
                         break;
                 default:
-                        return 1;
+                        return;
         }
 
         if (hwif->mmio) {
@@ -315,7 +309,6 @@ static int siimage_tune_chipset(ide_drive_t *drive, const u8 speed)
                 pci_write_config_word(hwif->pci_dev, ma, multi);
                 pci_write_config_word(hwif->pci_dev, ua, ultra);
         }
-        return (ide_config_drive_speed(drive, speed));
 }
 
 /**
@@ -904,8 +897,8 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
         hwif->autodma = 0;
         
         hwif->resetproc = &siimage_reset;
-        hwif->speedproc = &siimage_tune_chipset;
         hwif->set_pio_mode = &sil_set_pio_mode;
+        hwif->set_dma_mode = &sil_set_dma_mode;
         hwif->reset_poll = &siimage_reset_poll;
         hwif->pre_reset = &siimage_pre_reset;
         hwif->udma_filter = &sil_udma_filter;
diff --git a/drivers/ide/pci/sis5513.c b/drivers/ide/pci/sis5513.c
index 3e18899de6..b375ee53d6 100644
--- a/drivers/ide/pci/sis5513.c
+++ b/drivers/ide/pci/sis5513.c
@@ -451,7 +451,7 @@ static void config_drive_art_rwp (ide_drive_t *drive)
 }
 
 /* Set per-drive active and recovery time */
-static void config_art_rwp_pio (ide_drive_t *drive, u8 pio)
+static void sis_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -519,20 +519,14 @@ static void config_art_rwp_pio (ide_drive_t *drive, u8 pio)
         }
 }
 
-static void sis_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        config_art_rwp_pio(drive, pio);
-        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
-static int sis5513_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void sis_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u32 regdw;
         u8 drive_pci, reg;
 
-        /* See config_art_rwp_pio for drive pci config registers */
+        /* See sis_set_pio_mode() for drive PCI config registers */
         drive_pci = 0x40;
         if (chipset_family >= ATA_133) {
                 u32 reg54h;
@@ -600,8 +594,6 @@ static int sis5513_tune_chipset(ide_drive_t *drive, const u8 speed)
                         BUG();
                         break;
         }
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 static int sis5513_config_xfer_rate(ide_drive_t *drive)
@@ -841,7 +833,7 @@ static void __devinit init_hwif_sis5513 (ide_hwif_t *hwif)
                 hwif->irq = hwif->channel ? 15 : 14;
 
         hwif->set_pio_mode = &sis_set_pio_mode;
-        hwif->speedproc = &sis5513_tune_chipset;
+        hwif->set_dma_mode = &sis_set_dma_mode;
 
         if (chipset_family >= ATA_133)
                 hwif->udma_filter = sis5513_ata133_udma_filter;
diff --git a/drivers/ide/pci/sl82c105.c b/drivers/ide/pci/sl82c105.c
index f492318ba7..2ef26e3f7b 100644
--- a/drivers/ide/pci/sl82c105.c
+++ b/drivers/ide/pci/sl82c105.c
@@ -75,7 +75,7 @@ static unsigned int get_pio_timings(ide_drive_t *drive, u8 pio)
 /*
  * Configure the chipset for PIO mode.
  */
-static void sl82c105_tune_pio(ide_drive_t *drive, const u8 pio)
+static void sl82c105_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         struct pci_dev *dev     = HWIF(drive)->pci_dev;
         int reg                 = 0x44 + drive->dn * 4;
@@ -105,9 +105,9 @@ static void sl82c105_tune_pio(ide_drive_t *drive, const u8 pio)
 }
 
 /*
- * Configure the drive and chipset for a new transfer speed.
+ * Configure the chipset for DMA mode.
  */
-static int sl82c105_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void sl82c105_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         static u16 mwdma_timings[] = {0x0707, 0x0201, 0x0200};
         u16 drv_ctrl;
@@ -140,10 +140,8 @@ static int sl82c105_tune_chipset(ide_drive_t *drive, const u8 speed)
                 }
                 break;
         default:
-                return -1;
+                return;
         }
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 /*
@@ -306,17 +304,6 @@ static void sl82c105_resetproc(ide_drive_t *drive)
         pci_read_config_dword(dev, 0x40, &val);
         pci_set_drvdata(dev, (void *)val);
 }
-        
-/*
- * We only deal with PIO mode here - DMA mode 'using_dma' is not
- * initialised at the point that this function is called.
- */
-static void sl82c105_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        sl82c105_tune_pio(drive, pio);
-
-        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
 
 /*
  * Return the revision of the Winbond bridge
@@ -383,7 +370,7 @@ static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif)
         DBG(("init_hwif_sl82c105(hwif: ide%d)\n", hwif->index));
 
         hwif->set_pio_mode      = &sl82c105_set_pio_mode;
-        hwif->speedproc         = &sl82c105_tune_chipset;
+        hwif->set_dma_mode      = &sl82c105_set_dma_mode;
         hwif->selectproc        = &sl82c105_selectproc;
         hwif->resetproc         = &sl82c105_resetproc;
 
diff --git a/drivers/ide/pci/slc90e66.c b/drivers/ide/pci/slc90e66.c
index ae8e913245..ebac87f720 100644
--- a/drivers/ide/pci/slc90e66.c
+++ b/drivers/ide/pci/slc90e66.c
@@ -42,7 +42,7 @@ static u8 slc90e66_dma_2_pio (u8 xfer_rate) {
         }
 }
 
-static void slc90e66_tune_pio (ide_drive_t *drive, u8 pio)
+static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -95,13 +95,7 @@ static void slc90e66_tune_pio (ide_drive_t *drive, u8 pio)
         spin_unlock_irqrestore(&ide_lock, flags);
 }
 
-static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        slc90e66_tune_pio(drive, pio);
-        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
-}
-
-static int slc90e66_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void slc90e66_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -125,7 +119,7 @@ static int slc90e66_tune_chipset(ide_drive_t *drive, const u8 speed)
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:     break;
-                default:                return -1;
+                default:                return;
         }
 
         if (speed >= XFER_UDMA_0) {
@@ -144,9 +138,7 @@ static int slc90e66_tune_chipset(ide_drive_t *drive, const u8 speed)
                         pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
         }
 
-        slc90e66_tune_pio(drive, slc90e66_dma_2_pio(speed));
-
-        return ide_config_drive_speed(drive, speed);
+        slc90e66_set_pio_mode(drive, slc90e66_dma_2_pio(speed));
 }
 
 static int slc90e66_config_drive_xfer_rate (ide_drive_t *drive)
@@ -172,8 +164,8 @@ static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
         if (!hwif->irq)
                 hwif->irq = hwif->channel ? 15 : 14;
 
-        hwif->speedproc = &slc90e66_tune_chipset;
         hwif->set_pio_mode = &slc90e66_set_pio_mode;
+        hwif->set_dma_mode = &slc90e66_set_dma_mode;
 
         pci_read_config_byte(hwif->pci_dev, 0x47, &reg47);
 
diff --git a/drivers/ide/pci/tc86c001.c b/drivers/ide/pci/tc86c001.c
index e23b9cfb6e..840415d68d 100644
--- a/drivers/ide/pci/tc86c001.c
+++ b/drivers/ide/pci/tc86c001.c
@@ -13,7 +13,7 @@
 #include <linux/pci.h>
 #include <linux/ide.h>
 
-static int tc86c001_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void tc86c001_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long scr_port  = hwif->config_data + (drive->dn ? 0x02 : 0x00);
@@ -39,13 +39,11 @@ static int tc86c001_tune_chipset(ide_drive_t *drive, const u8 speed)
         scr &= (speed < XFER_MW_DMA_0) ? 0xf8ff : 0xff0f;
         scr |= mode;
         outw(scr, scr_port);
-
-        return ide_config_drive_speed(drive, speed);
 }
 
 static void tc86c001_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void) tc86c001_tune_chipset(drive, XFER_PIO_0 + pio);
+        tc86c001_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 /*
@@ -193,7 +191,8 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
         hwif->config_data = sc_base;
 
         hwif->set_pio_mode = &tc86c001_set_pio_mode;
-        hwif->speedproc = &tc86c001_tune_chipset;
+        hwif->set_dma_mode = &tc86c001_set_mode;
+
         hwif->busproc   = &tc86c001_busproc;
 
         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/triflex.c b/drivers/ide/pci/triflex.c
index c3ff066eea..54e411d4e5 100644
--- a/drivers/ide/pci/triflex.c
+++ b/drivers/ide/pci/triflex.c
@@ -40,7 +40,7 @@
 #include <linux/ide.h>
 #include <linux/init.h>
 
-static int triflex_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void triflex_set_mode(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
@@ -82,20 +82,18 @@ static int triflex_tune_chipset(ide_drive_t *drive, const u8 speed)
                         timing = 0x0808;
                         break;
                 default:
-                        return -1;
+                        return;
         }
 
         triflex_timings &= ~(0xFFFF << (16 * unit));
         triflex_timings |= (timing << (16 * unit));
         
         pci_write_config_dword(dev, channel_offset, triflex_timings);
-        
-        return (ide_config_drive_speed(drive, speed));
 }
 
 static void triflex_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        (void)triflex_tune_chipset(drive, XFER_PIO_0 + pio);
+        triflex_set_mode(drive, XFER_PIO_0 + pio);
 }
 
 static int triflex_config_drive_xfer_rate(ide_drive_t *drive)
@@ -111,7 +109,7 @@ static int triflex_config_drive_xfer_rate(ide_drive_t *drive)
 static void __devinit init_hwif_triflex(ide_hwif_t *hwif)
 {
         hwif->set_pio_mode = &triflex_set_pio_mode;
-        hwif->speedproc = &triflex_tune_chipset;
+        hwif->set_dma_mode = &triflex_set_mode;
 
         if (hwif->dma_base == 0)
                 return;
diff --git a/drivers/ide/pci/via82cxxx.c b/drivers/ide/pci/via82cxxx.c
index 378feb491e..479e496610 100644
--- a/drivers/ide/pci/via82cxxx.c
+++ b/drivers/ide/pci/via82cxxx.c
@@ -1,6 +1,6 @@
 /*
  *
- * Version 3.48
+ * Version 3.49
  *
  * VIA IDE driver for Linux. Supported southbridges:
  *
@@ -153,21 +153,17 @@ static void via_set_speed(ide_hwif_t *hwif, u8 dn, struct ide_timing *timing)
  *      @drive: Drive to set up
  *      @speed: desired speed
  *
- *      via_set_drive() computes timing values configures the drive and
- *      the chipset to a desired transfer mode. It also can be called
- *      by upper layers.
+ *      via_set_drive() computes timing values configures the chipset to
+ *      a desired transfer mode.  It also can be called by upper layers.
  */
 
-static int via_set_drive(ide_drive_t *drive, const u8 speed)
+static void via_set_drive(ide_drive_t *drive, const u8 speed)
 {
         ide_drive_t *peer = HWIF(drive)->drives + (~drive->dn & 1);
         struct via82cxxx_dev *vdev = pci_get_drvdata(drive->hwif->pci_dev);
         struct ide_timing t, p;
         unsigned int T, UT;
 
-        if (speed != XFER_PIO_SLOW)
-                ide_config_drive_speed(drive, speed);
-
         T = 1000000000 / via_clock;
 
         switch (vdev->via_config->udma_mask) {
@@ -186,16 +182,10 @@ static int via_set_drive(ide_drive_t *drive, const u8 speed)
         }
 
         via_set_speed(HWIF(drive), drive->dn, &t);
-
-        if (!drive->init_speed)
-                drive->init_speed = speed;
-        drive->current_speed = speed;
-
-        return 0;
 }
 
 /**
- *      via_set_pio_mode        -       PIO setup
+ *      via_set_pio_mode        -       set host controller for PIO mode
  *      @drive: drive
  *      @pio: PIO mode number
  *
@@ -456,8 +446,7 @@ static void __devinit init_hwif_via82cxxx(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->set_pio_mode = &via_set_pio_mode;
-        hwif->speedproc = &via_set_drive;
-
+        hwif->set_dma_mode = &via_set_drive;
 
 #ifdef CONFIG_PPC_CHRP
         if(machine_is(chrp) && _chrp_type == _CHRP_Pegasos) {
@@ -500,7 +489,8 @@ static ide_pci_device_t via82cxxx_chipsets[] __devinitdata = {
                 .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}},
                 .bootable       = ON_BOARD,
                 .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST
-                                | IDE_HFLAG_PIO_NO_DOWNGRADE,
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE
+                                | IDE_HFLAG_POST_SET_MODE,
                 .pio_mask       = ATA_PIO5,
         },{     /* 1 */
                 .name           = "VP_IDE",
@@ -510,7 +500,8 @@ static ide_pci_device_t via82cxxx_chipsets[] __devinitdata = {
                 .enablebits     = {{0x00,0x00,0x00}, {0x00,0x00,0x00}},
                 .bootable       = ON_BOARD,
                 .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST
-                                | IDE_HFLAG_PIO_NO_DOWNGRADE,
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE
+                                | IDE_HFLAG_POST_SET_MODE,
                 .pio_mask       = ATA_PIO5,
         }
 };
diff --git a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c
index f759a53978..7d8873839e 100644
--- a/drivers/ide/ppc/pmac.c
+++ b/drivers/ide/ppc/pmac.c
@@ -392,6 +392,7 @@ kauai_lookup_timing(struct kauai_timing* table, int cycle_time)
         for (i=0; table[i].cycle_time; i++)
                 if (cycle_time > table[i+1].cycle_time)
                         return table[i].timing_reg;
+        BUG();
         return 0;
 }
 
@@ -529,97 +530,12 @@ pmac_outbsync(ide_drive_t *drive, u8 value, unsigned long port)
 }
 
 /*
- * Send the SET_FEATURE IDE command to the drive and update drive->id with
- * the new state. We currently don't use the generic routine as it used to
- * cause various trouble, especially with older mediabays.
- * This code is sometimes triggering a spurrious interrupt though, I need
- * to sort that out sooner or later and see if I can finally get the
- * common version to work properly in all cases
- */
-static int
-pmac_ide_do_setfeature(ide_drive_t *drive, u8 command)
-{
-        ide_hwif_t *hwif = HWIF(drive);
-        int result = 1;
-        
-        disable_irq_nosync(hwif->irq);
-        udelay(1);
-        SELECT_DRIVE(drive);
-        SELECT_MASK(drive, 0);
-        udelay(1);
-        /* Get rid of pending error state */
-        (void) hwif->INB(IDE_STATUS_REG);
-        /* Timeout bumped for some powerbooks */
-        if (wait_for_ready(drive, 2000)) {
-                /* Timeout bumped for some powerbooks */
-                printk(KERN_ERR "%s: pmac_ide_do_setfeature disk not ready "
-                        "before SET_FEATURE!\n", drive->name);
-                goto out;
-        }
-        udelay(10);
-        hwif->OUTB(drive->ctl | 2, IDE_CONTROL_REG);
-        hwif->OUTB(command, IDE_NSECTOR_REG);
-        hwif->OUTB(SETFEATURES_XFER, IDE_FEATURE_REG);
-        hwif->OUTBSYNC(drive, WIN_SETFEATURES, IDE_COMMAND_REG);
-        udelay(1);
-        /* Timeout bumped for some powerbooks */
-        result = wait_for_ready(drive, 2000);
-        hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
-        if (result)
-                printk(KERN_ERR "%s: pmac_ide_do_setfeature disk not ready "
-                        "after SET_FEATURE !\n", drive->name);
-out:
-        SELECT_MASK(drive, 0);
-        if (result == 0) {
-                drive->id->dma_ultra &= ~0xFF00;
-                drive->id->dma_mword &= ~0x0F00;
-                drive->id->dma_1word &= ~0x0F00;
-                switch(command) {
-                        case XFER_UDMA_7:
-                                drive->id->dma_ultra |= 0x8080; break;
-                        case XFER_UDMA_6:
-                                drive->id->dma_ultra |= 0x4040; break;
-                        case XFER_UDMA_5:
-                                drive->id->dma_ultra |= 0x2020; break;
-                        case XFER_UDMA_4:
-                                drive->id->dma_ultra |= 0x1010; break;
-                        case XFER_UDMA_3:
-                                drive->id->dma_ultra |= 0x0808; break;
-                        case XFER_UDMA_2:
-                                drive->id->dma_ultra |= 0x0404; break;
-                        case XFER_UDMA_1:
-                                drive->id->dma_ultra |= 0x0202; break;
-                        case XFER_UDMA_0:
-                                drive->id->dma_ultra |= 0x0101; break;
-                        case XFER_MW_DMA_2:
-                                drive->id->dma_mword |= 0x0404; break;
-                        case XFER_MW_DMA_1:
-                                drive->id->dma_mword |= 0x0202; break;
-                        case XFER_MW_DMA_0:
-                                drive->id->dma_mword |= 0x0101; break;
-                        case XFER_SW_DMA_2:
-                                drive->id->dma_1word |= 0x0404; break;
-                        case XFER_SW_DMA_1:
-                                drive->id->dma_1word |= 0x0202; break;
-                        case XFER_SW_DMA_0:
-                                drive->id->dma_1word |= 0x0101; break;
-                        default: break;
-                }
-                if (!drive->init_speed)
-                        drive->init_speed = command;
-                drive->current_speed = command;
-        }
-        enable_irq(hwif->irq);
-        return result;
-}
-
-/*
  * Old tuning functions (called on hdparm -p), sets up drive PIO timings
  */
 static void
 pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        u32 *timings;
+        u32 *timings, t;
         unsigned accessTicks, recTicks;
         unsigned accessTime, recTime;
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -630,6 +546,7 @@ pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 
         /* which drive is it ? */
         timings = &pmif->timings[drive->select.b.unit & 0x01];
+        t = *timings;
 
         cycle_time = ide_pio_cycle_time(drive, pio);
 
@@ -637,18 +554,14 @@ pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
         case controller_sh_ata6: {
                 /* 133Mhz cell */
                 u32 tr = kauai_lookup_timing(shasta_pio_timings, cycle_time);
-                if (tr == 0)
-                        return;
-                *timings = ((*timings) & ~TR_133_PIOREG_PIO_MASK) | tr;
+                t = (t & ~TR_133_PIOREG_PIO_MASK) | tr;
                 break;
                 }
         case controller_un_ata6:
         case controller_k2_ata6: {
                 /* 100Mhz cell */
                 u32 tr = kauai_lookup_timing(kauai_pio_timings, cycle_time);
-                if (tr == 0)
-                        return;
-                *timings = ((*timings) & ~TR_100_PIOREG_PIO_MASK) | tr;
+                t = (t & ~TR_100_PIOREG_PIO_MASK) | tr;
                 break;
                 }
         case controller_kl_ata4:
@@ -662,9 +575,9 @@ pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 accessTicks = min(accessTicks, 0x1fU);
                 recTicks = SYSCLK_TICKS_66(recTime);
                 recTicks = min(recTicks, 0x1fU);
-                *timings = ((*timings) & ~TR_66_PIO_MASK) |
-                                (accessTicks << TR_66_PIO_ACCESS_SHIFT) |
-                                (recTicks << TR_66_PIO_RECOVERY_SHIFT);
+                t = (t & ~TR_66_PIO_MASK) |
+                        (accessTicks << TR_66_PIO_ACCESS_SHIFT) |
+                        (recTicks << TR_66_PIO_RECOVERY_SHIFT);
                 break;
         default: {
                 /* 33Mhz cell */
@@ -684,11 +597,11 @@ pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
                         recTicks--; /* guess, but it's only for PIO0, so... */
                         ebit = 1;
                 }
-                *timings = ((*timings) & ~TR_33_PIO_MASK) |
+                t = (t & ~TR_33_PIO_MASK) |
                                 (accessTicks << TR_33_PIO_ACCESS_SHIFT) |
                                 (recTicks << TR_33_PIO_RECOVERY_SHIFT);
                 if (ebit)
-                        *timings |= TR_33_PIO_E;
+                        t |= TR_33_PIO_E;
                 break;
                 }
         }
@@ -698,9 +611,7 @@ pmac_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 drive->name, pio,  *timings);
 #endif  
 
-        if (pmac_ide_do_setfeature(drive, XFER_PIO_0 + pio))
-                return;
-
+        *timings = t;
         pmac_ide_do_update_timings(drive);
 }
 
@@ -746,8 +657,6 @@ set_timings_udma_ata6(u32 *pio_timings, u32 *ultra_timings, u8 speed)
         if (speed > XFER_UDMA_5 || t == NULL)
                 return 1;
         tr = kauai_lookup_timing(kauai_udma_timings, (int)t->udma);
-        if (tr == 0)
-                return 1;
         *ultra_timings = ((*ultra_timings) & ~TR_100_UDMAREG_UDMA_MASK) | tr;
         *ultra_timings = (*ultra_timings) | TR_100_UDMAREG_UDMA_EN;
 
@@ -766,8 +675,6 @@ set_timings_udma_shasta(u32 *pio_timings, u32 *ultra_timings, u8 speed)
         if (speed > XFER_UDMA_6 || t == NULL)
                 return 1;
         tr = kauai_lookup_timing(shasta_udma133_timings, (int)t->udma);
-        if (tr == 0)
-                return 1;
         *ultra_timings = ((*ultra_timings) & ~TR_133_UDMAREG_UDMA_MASK) | tr;
         *ultra_timings = (*ultra_timings) | TR_133_UDMAREG_UDMA_EN;
 
@@ -777,12 +684,13 @@ set_timings_udma_shasta(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 /*
  * Calculate MDMA timings for all cells
  */
-static int
+static void
 set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
-                        u8 speed, int drive_cycle_time)
+                        u8 speed)
 {
         int cycleTime, accessTime = 0, recTime = 0;
         unsigned accessTicks, recTicks;
+        struct hd_driveid *id = drive->id;
         struct mdma_timings_t* tm = NULL;
         int i;
 
@@ -792,11 +700,14 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
                 case 1: cycleTime = 150; break;
                 case 2: cycleTime = 120; break;
                 default:
-                        return 1;
+                        BUG();
+                        break;
         }
-        /* Adjust for drive */
-        if (drive_cycle_time && drive_cycle_time > cycleTime)
-                cycleTime = drive_cycle_time;
+
+        /* Check if drive provides explicit DMA cycle time */
+        if ((id->field_valid & 2) && id->eide_dma_time)
+                cycleTime = max_t(int, id->eide_dma_time, cycleTime);
+
         /* OHare limits according to some old Apple sources */  
         if ((intf_type == controller_ohare) && (cycleTime < 150))
                 cycleTime = 150;
@@ -824,8 +735,6 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
                                 break;
                         i++;
                 }
-                if (i < 0)
-                        return 1;
                 cycleTime = tm[i].cycleTime;
                 accessTime = tm[i].accessTime;
                 recTime = tm[i].recoveryTime;
@@ -839,8 +748,6 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
         case controller_sh_ata6: {
                 /* 133Mhz cell */
                 u32 tr = kauai_lookup_timing(shasta_mdma_timings, cycleTime);
-                if (tr == 0)
-                        return 1;
                 *timings = ((*timings) & ~TR_133_PIOREG_MDMA_MASK) | tr;
                 *timings2 = (*timings2) & ~TR_133_UDMAREG_UDMA_EN;
                 }
@@ -848,8 +755,6 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
         case controller_k2_ata6: {
                 /* 100Mhz cell */
                 u32 tr = kauai_lookup_timing(kauai_mdma_timings, cycleTime);
-                if (tr == 0)
-                        return 1;
                 *timings = ((*timings) & ~TR_100_PIOREG_MDMA_MASK) | tr;
                 *timings2 = (*timings2) & ~TR_100_UDMAREG_UDMA_EN;
                 }
@@ -911,30 +816,23 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
         printk(KERN_ERR "%s: Set MDMA timing for mode %d, reg: 0x%08x\n",
                 drive->name, speed & 0xf,  *timings);
 #endif  
-        return 0;
 }
 #endif /* #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC */
 
-/* 
- * Speedproc. This function is called by the core to set any of the standard
- * DMA timing (MDMA or UDMA) to both the drive and the controller.
- * You may notice we don't use this function on normal "dma check" operation,
- * our dedicated function is more precise as it uses the drive provided
- * cycle time value. We should probably fix this one to deal with that too...
- */
-static int pmac_ide_tune_chipset(ide_drive_t *drive, const u8 speed)
+static void pmac_ide_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
         int unit = (drive->select.b.unit & 0x01);
         int ret = 0;
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
-        u32 *timings, *timings2;
+        u32 *timings, *timings2, tl[2];
 
-        if (pmif == NULL)
-                return 1;
-                
         timings = &pmif->timings[unit];
         timings2 = &pmif->timings[unit+2];
-        
+
+        /* Copy timings to local image */
+        tl[0] = *timings;
+        tl[1] = *timings2;
+
         switch(speed) {
 #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
                 case XFER_UDMA_6:
@@ -945,38 +843,36 @@ static int pmac_ide_tune_chipset(ide_drive_t *drive, const u8 speed)
                 case XFER_UDMA_1:
                 case XFER_UDMA_0:
                         if (pmif->kind == controller_kl_ata4)
-                                ret = set_timings_udma_ata4(timings, speed);
+                                ret = set_timings_udma_ata4(&tl[0], speed);
                         else if (pmif->kind == controller_un_ata6
                                  || pmif->kind == controller_k2_ata6)
-                                ret = set_timings_udma_ata6(timings, timings2, speed);
+                                ret = set_timings_udma_ata6(&tl[0], &tl[1], speed);
                         else if (pmif->kind == controller_sh_ata6)
-                                ret = set_timings_udma_shasta(timings, timings2, speed);
+                                ret = set_timings_udma_shasta(&tl[0], &tl[1], speed);
                         else
-                                ret = 1;                
+                                ret = 1;
                         break;
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_MW_DMA_0:
-                        ret = set_timings_mdma(drive, pmif->kind, timings, timings2, speed, 0);
+                        set_timings_mdma(drive, pmif->kind, &tl[0], &tl[1], speed);
                         break;
                 case XFER_SW_DMA_2:
                 case XFER_SW_DMA_1:
                 case XFER_SW_DMA_0:
-                        return 1;
+                        return;
 #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
                 default:
                         ret = 1;
         }
         if (ret)
-                return ret;
+                return;
 
-        ret = pmac_ide_do_setfeature(drive, speed);
-        if (ret)
-                return ret;
-                
-        pmac_ide_do_update_timings(drive);      
+        /* Apply timings to controller */
+        *timings = tl[0];
+        *timings2 = tl[1];
 
-        return 0;
+        pmac_ide_do_update_timings(drive);      
 }
 
 /*
@@ -1236,6 +1132,10 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
         hwif->cbl = pmif->cable_80 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
         hwif->drives[0].unmask = 1;
         hwif->drives[1].unmask = 1;
+        hwif->drives[0].autotune = IDE_TUNE_AUTO;
+        hwif->drives[1].autotune = IDE_TUNE_AUTO;
+        hwif->host_flags = IDE_HFLAG_SET_PIO_MODE_KEEP_DMA |
+                           IDE_HFLAG_POST_SET_MODE;
         hwif->pio_mask = ATA_PIO4;
         hwif->set_pio_mode = pmac_ide_set_pio_mode;
         if (pmif->kind == controller_un_ata6
@@ -1244,7 +1144,7 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
                 hwif->selectproc = pmac_ide_kauai_selectproc;
         else
                 hwif->selectproc = pmac_ide_selectproc;
-        hwif->speedproc = pmac_ide_tune_chipset;
+        hwif->set_dma_mode = pmac_ide_set_dma_mode;
 
         printk(KERN_INFO "ide%d: Found Apple %s controller, bus ID %d%s, irq %d\n",
                hwif->index, model_name[pmif->kind], pmif->aapl_bus_id,
@@ -1679,138 +1579,16 @@ pmac_ide_destroy_dmatable (ide_drive_t *drive)
 }
 
 /*
- * Pick up best MDMA timing for the drive and apply it
- */
-static int
-pmac_ide_mdma_enable(ide_drive_t *drive, u16 mode)
-{
-        ide_hwif_t *hwif = HWIF(drive);
-        pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)hwif->hwif_data;
-        int drive_cycle_time;
-        struct hd_driveid *id = drive->id;
-        u32 *timings, *timings2;
-        u32 timing_local[2];
-        int ret;
-
-        /* which drive is it ? */
-        timings = &pmif->timings[drive->select.b.unit & 0x01];
-        timings2 = &pmif->timings[(drive->select.b.unit & 0x01) + 2];
-
-        /* Check if drive provide explicit cycle time */
-        if ((id->field_valid & 2) && (id->eide_dma_time))
-                drive_cycle_time = id->eide_dma_time;
-        else
-                drive_cycle_time = 0;
-
-        /* Copy timings to local image */
-        timing_local[0] = *timings;
-        timing_local[1] = *timings2;
-
-        /* Calculate controller timings */
-        ret = set_timings_mdma( drive, pmif->kind,
-                                &timing_local[0],
-                                &timing_local[1],
-                                mode,
-                                drive_cycle_time);
-        if (ret)
-                return 0;
-
-        /* Set feature on drive */
-        printk(KERN_INFO "%s: Enabling MultiWord DMA %d\n", drive->name, mode & 0xf);
-        ret = pmac_ide_do_setfeature(drive, mode);
-        if (ret) {
-                printk(KERN_WARNING "%s: Failed !\n", drive->name);
-                return 0;
-        }
-
-        /* Apply timings to controller */
-        *timings = timing_local[0];
-        *timings2 = timing_local[1];
-
-        return 1;
-}
-
-/*
- * Pick up best UDMA timing for the drive and apply it
- */
-static int
-pmac_ide_udma_enable(ide_drive_t *drive, u16 mode)
-{
-        ide_hwif_t *hwif = HWIF(drive);
-        pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)hwif->hwif_data;
-        u32 *timings, *timings2;
-        u32 timing_local[2];
-        int ret;
-                
-        /* which drive is it ? */
-        timings = &pmif->timings[drive->select.b.unit & 0x01];
-        timings2 = &pmif->timings[(drive->select.b.unit & 0x01) + 2];
-
-        /* Copy timings to local image */
-        timing_local[0] = *timings;
-        timing_local[1] = *timings2;
-        
-        /* Calculate timings for interface */
-        if (pmif->kind == controller_un_ata6
-            || pmif->kind == controller_k2_ata6)
-                ret = set_timings_udma_ata6(    &timing_local[0],
-                                                &timing_local[1],
-                                                mode);
-        else if (pmif->kind == controller_sh_ata6)
-                ret = set_timings_udma_shasta(  &timing_local[0],
-                                                &timing_local[1],
-                                                mode);
-        else
-                ret = set_timings_udma_ata4(&timing_local[0], mode);
-        if (ret)
-                return 0;
-                
-        /* Set feature on drive */
-        printk(KERN_INFO "%s: Enabling Ultra DMA %d\n", drive->name, mode & 0x0f);
-        ret = pmac_ide_do_setfeature(drive, mode);
-        if (ret) {
-                printk(KERN_WARNING "%s: Failed !\n", drive->name);
-                return 0;
-        }
-
-        /* Apply timings to controller */
-        *timings = timing_local[0];
-        *timings2 = timing_local[1];
-
-        return 1;
-}
-
-/*
  * Check what is the best DMA timing setting for the drive and
  * call appropriate functions to apply it.
  */
 static int
 pmac_ide_dma_check(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
-        ide_hwif_t *hwif = HWIF(drive);
-        int enable = 1;
-        drive->using_dma = 0;
-        
-        if (drive->media == ide_floppy)
-                enable = 0;
-        if (((id->capability & 1) == 0) && !__ide_dma_good_drive(drive))
-                enable = 0;
-        if (__ide_dma_bad_drive(drive))
-                enable = 0;
-
-        if (enable) {
-                u8 mode = ide_max_dma_mode(drive);
-
-                if (mode >= XFER_UDMA_0)
-                        drive->using_dma = pmac_ide_udma_enable(drive, mode);
-                else if (mode >= XFER_MW_DMA_0)
-                        drive->using_dma = pmac_ide_mdma_enable(drive, mode);
-                hwif->OUTB(0, IDE_CONTROL_REG);
-                /* Apply settings to controller */
-                pmac_ide_do_update_timings(drive);
-        }
-        return 0;
+        if (ide_tune_dma(drive))
+                return 0;
+
+        return -1;
 }
 
 /*
@@ -2044,7 +1822,10 @@ pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
                         hwif->mwdma_mask = 0x07;
                         hwif->swdma_mask = 0x00;
                         break;
-        }       
+        }
+
+        hwif->autodma = 1;
+        hwif->drives[1].autodma = hwif->drives[0].autodma = hwif->autodma;
 }
 
 #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 2ffd53461d..1939fee616 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -153,8 +153,7 @@ struct host_info {
 };
 
 static int nodemgr_bus_match(struct device * dev, struct device_driver * drv);
-static int nodemgr_uevent(struct device *dev, char **envp, int num_envp,
-                          char *buffer, int buffer_size);
+static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env);
 static void nodemgr_resume_ne(struct node_entry *ne);
 static void nodemgr_remove_ne(struct node_entry *ne);
 static struct node_entry *find_entry_by_guid(u64 guid);
@@ -1160,12 +1159,9 @@ static void nodemgr_process_root_directory(struct host_info *hi, struct node_ent
 
 #ifdef CONFIG_HOTPLUG
 
-static int nodemgr_uevent(struct device *dev, char **envp, int num_envp,
-                          char *buffer, int buffer_size)
+static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct unit_directory *ud;
-        int i = 0;
-        int length = 0;
         int retval = 0;
         /* ieee1394:venNmoNspNverN */
         char buf[8 + 1 + 3 + 8 + 2 + 8 + 2 + 8 + 3 + 8 + 1];
@@ -1180,9 +1176,7 @@ static int nodemgr_uevent(struct device *dev, char **envp, int num_envp,
 
 #define PUT_ENVP(fmt,val)                                       \
 do {                                                            \
-        retval = add_uevent_var(envp, num_envp, &i,             \
-                                buffer, buffer_size, &length,   \
-                                fmt, val);                      \
+        retval = add_uevent_var(env, fmt, val);         \
         if (retval)                                             \
                 return retval;                                  \
 } while (0)
@@ -1201,15 +1195,12 @@ do {								\
 
 #undef PUT_ENVP
 
-        envp[i] = NULL;
-
         return 0;
 }
 
 #else
 
-static int nodemgr_uevent(struct device *dev, char **envp, int num_envp,
-                          char *buffer, int buffer_size)
+static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index 70b77ae674..3d40506813 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -434,21 +434,18 @@ static void ib_device_release(struct class_device *cdev)
         kfree(dev);
 }
 
-static int ib_device_uevent(struct class_device *cdev, char **envp,
-                            int num_envp, char *buf, int size)
+static int ib_device_uevent(struct class_device *cdev,
+                            struct kobj_uevent_env *env)
 {
         struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
-        int i = 0, len = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buf, size, &len,
-                           "NAME=%s", dev->name))
+        if (add_uevent_var(env, "NAME=%s", dev->name))
                 return -ENOMEM;
 
         /*
          * It would be nice to pass the node GUID with the event...
          */
 
-        envp[i] = NULL;
         return 0;
 }
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 5fe7555866..5dc361c954 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -859,87 +859,66 @@ static void input_dev_release(struct device *device)
  * Input uevent interface - loading event handlers based on
  * device bitfields.
  */
-static int input_add_uevent_bm_var(char **envp, int num_envp, int *cur_index,
-                                   char *buffer, int buffer_size, int *cur_len,
+static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
                                    const char *name, unsigned long *bitmap, int max)
 {
-        if (*cur_index >= num_envp - 1)
-                return -ENOMEM;
-
-        envp[*cur_index] = buffer + *cur_len;
+        int len;
 
-        *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0), name);
-        if (*cur_len >= buffer_size)
+        if (add_uevent_var(env, "%s=", name))
                 return -ENOMEM;
 
-        *cur_len += input_print_bitmap(buffer + *cur_len,
-                                        max(buffer_size - *cur_len, 0),
-                                        bitmap, max, 0) + 1;
-        if (*cur_len > buffer_size)
+        len = input_print_bitmap(&env->buf[env->buflen - 1],
+                                 sizeof(env->buf) - env->buflen,
+                                 bitmap, max, 0);
+        if (len >= (sizeof(env->buf) - env->buflen))
                 return -ENOMEM;
 
-        (*cur_index)++;
+        env->buflen += len;
         return 0;
 }
 
-static int input_add_uevent_modalias_var(char **envp, int num_envp, int *cur_index,
-                                         char *buffer, int buffer_size, int *cur_len,
+static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
                                          struct input_dev *dev)
 {
-        if (*cur_index >= num_envp - 1)
-                return -ENOMEM;
-
-        envp[*cur_index] = buffer + *cur_len;
+        int len;
 
-        *cur_len += snprintf(buffer + *cur_len, max(buffer_size - *cur_len, 0),
-                             "MODALIAS=");
-        if (*cur_len >= buffer_size)
+        if (add_uevent_var(env, "MODALIAS="))
                 return -ENOMEM;
 
-        *cur_len += input_print_modalias(buffer + *cur_len,
-                                         max(buffer_size - *cur_len, 0),
-                                         dev, 0) + 1;
-        if (*cur_len > buffer_size)
+        len = input_print_modalias(&env->buf[env->buflen - 1],
+                                   sizeof(env->buf) - env->buflen,
+                                   dev, 0);
+        if (len >= (sizeof(env->buf) - env->buflen))
                 return -ENOMEM;
 
-        (*cur_index)++;
+        env->buflen += len;
         return 0;
 }
 
 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
         do {                                                            \
-                int err = add_uevent_var(envp, num_envp, &i,            \
-                                        buffer, buffer_size, &len,      \
-                                        fmt, val);                      \
+                int err = add_uevent_var(env, fmt, val);                \
                 if (err)                                                \
                         return err;                                     \
         } while (0)
 
 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
         do {                                                            \
-                int err = input_add_uevent_bm_var(envp, num_envp, &i,   \
-                                        buffer, buffer_size, &len,      \
-                                        name, bm, max);                 \
+                int err = input_add_uevent_bm_var(env, name, bm, max);  \
                 if (err)                                                \
                         return err;                                     \
         } while (0)
 
 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
         do {                                                            \
-                int err = input_add_uevent_modalias_var(envp,           \
-                                        num_envp, &i,                   \
-                                        buffer, buffer_size, &len,      \
-                                        dev);                           \
+                int err = input_add_uevent_modalias_var(env, dev);      \
                 if (err)                                                \
                         return err;                                     \
         } while (0)
 
-static int input_dev_uevent(struct device *device, char **envp,
-                            int num_envp, char *buffer, int buffer_size)
+static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
 {
         struct input_dev *dev = to_input_dev(device);
-        int i = 0;
-        int len = 0;
 
         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
                                 dev->id.bustype, dev->id.vendor,
@@ -971,7 +950,6 @@ static int input_dev_uevent(struct device *device, char **envp,
 
         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
 
-        envp[i] = NULL;
         return 0;
 }
 
diff --git a/drivers/input/keyboard/atakbd.c b/drivers/input/keyboard/atakbd.c
index ded1d6ac6f..f948d3a14a 100644
--- a/drivers/input/keyboard/atakbd.c
+++ b/drivers/input/keyboard/atakbd.c
@@ -55,7 +55,140 @@ MODULE_AUTHOR("Michael Schmitz <schmitz@biophys.uni-duesseldorf.de>");
 MODULE_DESCRIPTION("Atari keyboard driver");
 MODULE_LICENSE("GPL");
 
-static unsigned char atakbd_keycode[0x72];
+/*
+ 0x47: KP_7     71
+ 0x48: KP_8     72
+ 0x49: KP_9     73
+ 0x62: KP_/     98
+ 0x4b: KP_4     75
+ 0x4c: KP_5     76
+ 0x4d: KP_6     77
+ 0x37: KP_*     55
+ 0x4f: KP_1     79
+ 0x50: KP_2     80
+ 0x51: KP_3     81
+ 0x4a: KP_-     74
+ 0x52: KP_0     82
+ 0x53: KP_.     83
+ 0x4e: KP_+     78
+
+ 0x67: Up       103
+ 0x6c: Down     108
+ 0x69: Left     105
+ 0x6a: Right    106
+ */
+
+
+static unsigned char atakbd_keycode[0x72] = {   /* American layout */
+        [0]      = KEY_GRAVE,
+        [1]      = KEY_ESC,
+        [2]      = KEY_1,
+        [3]      = KEY_2,
+        [4]      = KEY_3,
+        [5]      = KEY_4,
+        [6]      = KEY_5,
+        [7]      = KEY_6,
+        [8]      = KEY_7,
+        [9]      = KEY_8,
+        [10]     = KEY_9,
+        [11]     = KEY_0,
+        [12]     = KEY_MINUS,
+        [13]     = KEY_EQUAL,
+        [14]     = KEY_BACKSPACE,
+        [15]     = KEY_TAB,
+        [16]     = KEY_Q,
+        [17]     = KEY_W,
+        [18]     = KEY_E,
+        [19]     = KEY_R,
+        [20]     = KEY_T,
+        [21]     = KEY_Y,
+        [22]     = KEY_U,
+        [23]     = KEY_I,
+        [24]     = KEY_O,
+        [25]     = KEY_P,
+        [26]     = KEY_LEFTBRACE,
+        [27]     = KEY_RIGHTBRACE,
+        [28]     = KEY_ENTER,
+        [29]     = KEY_LEFTCTRL,
+        [30]     = KEY_A,
+        [31]     = KEY_S,
+        [32]     = KEY_D,
+        [33]     = KEY_F,
+        [34]     = KEY_G,
+        [35]     = KEY_H,
+        [36]     = KEY_J,
+        [37]     = KEY_K,
+        [38]     = KEY_L,
+        [39]     = KEY_SEMICOLON,
+        [40]     = KEY_APOSTROPHE,
+        [41]     = KEY_BACKSLASH,       /* FIXME, '#' */
+        [42]     = KEY_LEFTSHIFT,
+        [43]     = KEY_GRAVE,           /* FIXME: '~' */
+        [44]     = KEY_Z,
+        [45]     = KEY_X,
+        [46]     = KEY_C,
+        [47]     = KEY_V,
+        [48]     = KEY_B,
+        [49]     = KEY_N,
+        [50]     = KEY_M,
+        [51]     = KEY_COMMA,
+        [52]     = KEY_DOT,
+        [53]     = KEY_SLASH,
+        [54]     = KEY_RIGHTSHIFT,
+        [55]     = KEY_KPASTERISK,
+        [56]     = KEY_LEFTALT,
+        [57]     = KEY_SPACE,
+        [58]     = KEY_CAPSLOCK,
+        [59]     = KEY_F1,
+        [60]     = KEY_F2,
+        [61]     = KEY_F3,
+        [62]     = KEY_F4,
+        [63]     = KEY_F5,
+        [64]     = KEY_F6,
+        [65]     = KEY_F7,
+        [66]     = KEY_F8,
+        [67]     = KEY_F9,
+        [68]     = KEY_F10,
+        [69]     = KEY_ESC,
+        [70]     = KEY_DELETE,
+        [71]     = KEY_KP7,
+        [72]     = KEY_KP8,
+        [73]     = KEY_KP9,
+        [74]     = KEY_KPMINUS,
+        [75]     = KEY_KP4,
+        [76]     = KEY_KP5,
+        [77]     = KEY_KP6,
+        [78]     = KEY_KPPLUS,
+        [79]     = KEY_KP1,
+        [80]     = KEY_KP2,
+        [81]     = KEY_KP3,
+        [82]     = KEY_KP0,
+        [83]     = KEY_KPDOT,
+        [90]     = KEY_KPLEFTPAREN,
+        [91]     = KEY_KPRIGHTPAREN,
+        [92]     = KEY_KPASTERISK,      /* FIXME */
+        [93]     = KEY_KPASTERISK,
+        [94]     = KEY_KPPLUS,
+        [95]     = KEY_HELP,
+        [96]     = KEY_BACKSLASH,       /* FIXME: '<' */
+        [97]     = KEY_KPASTERISK,      /* FIXME */
+        [98]     = KEY_KPSLASH,
+        [99]     = KEY_KPLEFTPAREN,
+        [100]    = KEY_KPRIGHTPAREN,
+        [101]    = KEY_KPSLASH,
+        [102]    = KEY_KPASTERISK,
+        [103]    = KEY_UP,
+        [104]    = KEY_KPASTERISK,      /* FIXME */
+        [105]    = KEY_LEFT,
+        [106]    = KEY_RIGHT,
+        [107]    = KEY_KPASTERISK,      /* FIXME */
+        [108]    = KEY_DOWN,
+        [109]    = KEY_KPASTERISK,      /* FIXME */
+        [110]    = KEY_KPASTERISK,      /* FIXME */
+        [111]    = KEY_KPASTERISK,      /* FIXME */
+        [112]    = KEY_KPASTERISK,      /* FIXME */
+        [113]    = KEY_KPASTERISK       /* FIXME */
+};
 
 static struct input_dev *atakbd_dev;
 
@@ -86,21 +219,20 @@ static int __init atakbd_init(void)
 {
         int i;
 
-        if (!ATARIHW_PRESENT(ST_MFP))
+        if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ST_MFP))
                 return -EIO;
 
-        // TODO: request_mem_region if not done in arch code
-
-        if (!(atakbd_dev = input_allocate_device()))
-                return -ENOMEM;
-
         // need to init core driver if not already done so
         if (atari_keyb_init())
                 return -ENODEV;
 
+        atakbd_dev = input_allocate_device();
+        if (!atakbd_dev)
+                return -ENOMEM;
+
         atakbd_dev->name = "Atari Keyboard";
         atakbd_dev->phys = "atakbd/input0";
-        atakbd_dev->id.bustype = BUS_ATARI;
+        atakbd_dev->id.bustype = BUS_HOST;
         atakbd_dev->id.vendor = 0x0001;
         atakbd_dev->id.product = 0x0001;
         atakbd_dev->id.version = 0x0100;
@@ -111,16 +243,17 @@ static int __init atakbd_init(void)
         atakbd_dev->keycodemax = ARRAY_SIZE(atakbd_keycode);
 
         for (i = 1; i < 0x72; i++) {
-                atakbd_keycode[i] = i;
                 set_bit(atakbd_keycode[i], atakbd_dev->keybit);
         }
 
-        input_register_device(atakbd_dev);
+        /* error check */
+        if (input_register_device(atakbd_dev)) {
+                input_free_device(atakbd_dev);
+                return -ENOMEM;
+        }
 
         atari_input_keyboard_interrupt_hook = atakbd_interrupt;
 
-        printk(KERN_INFO "input: %s at IKBD ACIA\n", atakbd_dev->name);
-
         return 0;
 }
 
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
index 906bf5e8de..c19f77fbaf 100644
--- a/drivers/input/misc/pcspkr.c
+++ b/drivers/input/misc/pcspkr.c
@@ -17,17 +17,18 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/platform_device.h>
-#include <asm/8253pit.h>
 #include <asm/io.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("PC Speaker beeper driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcspkr");
 
 #ifdef CONFIG_X86
 /* Use the global PIT lock ! */
 #include <asm/i8253.h>
 #else
+#include <asm/8253pit.h>
 static DEFINE_SPINLOCK(i8253_lock);
 #endif
 
diff --git a/drivers/input/mouse/atarimouse.c b/drivers/input/mouse/atarimouse.c
index 43ab6566fb..c8c7244b48 100644
--- a/drivers/input/mouse/atarimouse.c
+++ b/drivers/input/mouse/atarimouse.c
@@ -73,14 +73,11 @@ static void atamouse_interrupt(char *buf)
 {
         int buttons, dx, dy;
 
-/*      ikbd_mouse_disable(); */
-
         buttons = (buf[0] & 1) | ((buf[0] & 2) << 1);
 #ifdef FIXED_ATARI_JOYSTICK
         buttons |= atari_mouse_buttons & 2;
         atari_mouse_buttons = buttons;
 #endif
-/*      ikbd_mouse_rel_pos(); */
 
         /* only relative events get here */
         dx =  buf[1];
@@ -126,15 +123,16 @@ static int __init atamouse_init(void)
         if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ST_MFP))
                 return -ENODEV;
 
-        if (!(atamouse_dev = input_allocate_device()))
-                return -ENOMEM;
-
         if (!(atari_keyb_init()))
                 return -ENODEV;
 
+        atamouse_dev = input_allocate_device();
+        if (!atamouse_dev)
+                return -ENOMEM;
+
         atamouse_dev->name = "Atari mouse";
         atamouse_dev->phys = "atamouse/input0";
-        atamouse_dev->id.bustype = BUS_ATARI;
+        atamouse_dev->id.bustype = BUS_HOST;
         atamouse_dev->id.vendor = 0x0001;
         atamouse_dev->id.product = 0x0002;
         atamouse_dev->id.version = 0x0100;
@@ -145,9 +143,11 @@ static int __init atamouse_init(void)
         atamouse_dev->open = atamouse_open;
         atamouse_dev->close = atamouse_close;
 
-        input_register_device(atamouse_dev);
+        if (input_register_device(atamouse_dev)) {
+                input_free_device(atamouse_dev);
+                return -ENOMEM;
+        }
 
-        printk(KERN_INFO "input: %s at keyboard ACIA\n", atamouse_dev->name);
         return 0;
 }
 
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 372ca49311..b3bc15acd3 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -876,18 +876,14 @@ static int serio_bus_match(struct device *dev, struct device_driver *drv)
 
 #define SERIO_ADD_UEVENT_VAR(fmt, val...)                               \
         do {                                                            \
-                int err = add_uevent_var(envp, num_envp, &i,    \
-                                        buffer, buffer_size, &len,      \
-                                        fmt, val);                      \
+                int err = add_uevent_var(env, fmt, val);                \
                 if (err)                                                \
                         return err;                                     \
         } while (0)
 
-static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
+static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct serio *serio;
-        int i = 0;
-        int len = 0;
 
         if (!dev)
                 return -ENODEV;
@@ -900,7 +896,6 @@ static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buf
         SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
         SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
                                 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
-        envp[i] = NULL;
 
         return 0;
 }
@@ -908,7 +903,7 @@ static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buf
 
 #else
 
-static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
+static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
diff --git a/drivers/isdn/hisax/avm_pci.c b/drivers/isdn/hisax/avm_pci.c
index b04a178e50..f8b79783c8 100644
--- a/drivers/isdn/hisax/avm_pci.c
+++ b/drivers/isdn/hisax/avm_pci.c
@@ -20,7 +20,6 @@
 #include <linux/isapnp.h>
 #include <linux/interrupt.h>
 
-extern const char *CardType[];
 static const char *avm_pci_rev = "$Revision: 1.29.2.4 $";
 
 #define  AVM_FRITZ_PCI          1
@@ -726,100 +725,15 @@ AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
         return(0);
 }
 
-#ifdef CONFIG_PCI
-static struct pci_dev *dev_avm __devinitdata = NULL;
-#endif
-#ifdef __ISAPNP__
-static struct pnp_card *pnp_avm_c __devinitdata = NULL;
-#endif
-
-int __devinit
-setup_avm_pcipnp(struct IsdnCard *card)
+static int __devinit avm_setup_rest(struct IsdnCardState *cs)
 {
         u_int val, ver;
-        struct IsdnCardState *cs = card->cs;
-        char tmp[64];
 
-        strcpy(tmp, avm_pci_rev);
-        printk(KERN_INFO "HiSax: AVM PCI driver Rev. %s\n", HiSax_getrev(tmp));
-        if (cs->typ != ISDN_CTYPE_FRITZPCI)
-                return (0);
-        if (card->para[1]) {
-                /* old manual method */
-                cs->hw.avm.cfg_reg = card->para[1];
-                cs->irq = card->para[0];
-                cs->subtyp = AVM_FRITZ_PNP;
-                goto ready;
-        }
-#ifdef __ISAPNP__
-        if (isapnp_present()) {
-                struct pnp_dev *pnp_avm_d = NULL;
-                if ((pnp_avm_c = pnp_find_card(
-                        ISAPNP_VENDOR('A', 'V', 'M'),
-                        ISAPNP_FUNCTION(0x0900), pnp_avm_c))) {
-                        if ((pnp_avm_d = pnp_find_dev(pnp_avm_c,
-                                ISAPNP_VENDOR('A', 'V', 'M'),
-                                ISAPNP_FUNCTION(0x0900), pnp_avm_d))) {
-                                int err;
-
-                                pnp_disable_dev(pnp_avm_d);
-                                err = pnp_activate_dev(pnp_avm_d);
-                                if (err<0) {
-                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-                                                __FUNCTION__, err);
-                                        return(0);
-                                }
-                                cs->hw.avm.cfg_reg =
-                                        pnp_port_start(pnp_avm_d, 0);
-                                cs->irq = pnp_irq(pnp_avm_d, 0);
-                                if (!cs->irq) {
-                                        printk(KERN_ERR "FritzPnP:No IRQ\n");
-                                        return(0);
-                                }
-                                if (!cs->hw.avm.cfg_reg) {
-                                        printk(KERN_ERR "FritzPnP:No IO address\n");
-                                        return(0);
-                                }
-                                cs->subtyp = AVM_FRITZ_PNP;
-                                goto ready;
-                        }
-                }
-        } else {
-                printk(KERN_INFO "FritzPnP: no ISA PnP present\n");
-        }
-#endif
-#ifdef CONFIG_PCI
-        if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
-                PCI_DEVICE_ID_AVM_A1,  dev_avm))) {
-                if (pci_enable_device(dev_avm))
-                        return(0);
-                cs->irq = dev_avm->irq;
-                if (!cs->irq) {
-                        printk(KERN_ERR "FritzPCI: No IRQ for PCI card found\n");
-                        return(0);
-                }
-                cs->hw.avm.cfg_reg = pci_resource_start(dev_avm, 1);
-                if (!cs->hw.avm.cfg_reg) {
-                        printk(KERN_ERR "FritzPCI: No IO-Adr for PCI card found\n");
-                        return(0);
-                }
-                cs->subtyp = AVM_FRITZ_PCI;
-        } else {
-                printk(KERN_WARNING "FritzPCI: No PCI card found\n");
-                return(0);
-        }
-        cs->irq_flags |= IRQF_SHARED;
-#else
-        printk(KERN_WARNING "FritzPCI: NO_PCI_BIOS\n");
-        return (0);
-#endif /* CONFIG_PCI */
-ready:
         cs->hw.avm.isac = cs->hw.avm.cfg_reg + 0x10;
         if (!request_region(cs->hw.avm.cfg_reg, 32,
                 (cs->subtyp == AVM_FRITZ_PCI) ? "avm PCI" : "avm PnP")) {
                 printk(KERN_WARNING
-                       "HiSax: %s config port %x-%x already in use\n",
-                       CardType[card->typ],
+                       "HiSax: Fritz!PCI/PNP config port %x-%x already in use\n",
                        cs->hw.avm.cfg_reg,
                        cs->hw.avm.cfg_reg + 31);
                 return (0);
@@ -860,3 +774,137 @@ ready:
         ISACVersion(cs, (cs->subtyp == AVM_FRITZ_PCI) ? "AVM PCI:" : "AVM PnP:");
         return (1);
 }
+
+#ifndef __ISAPNP__
+
+static int __devinit avm_pnp_setup(struct IsdnCardState *cs)
+{
+        return(1);      /* no-op: success */
+}
+
+#else
+
+static struct pnp_card *pnp_avm_c __devinitdata = NULL;
+
+static int __devinit avm_pnp_setup(struct IsdnCardState *cs)
+{
+        struct pnp_dev *pnp_avm_d = NULL;
+
+        if (!isapnp_present())
+                return(1);      /* no-op: success */
+
+        if ((pnp_avm_c = pnp_find_card(
+                ISAPNP_VENDOR('A', 'V', 'M'),
+                ISAPNP_FUNCTION(0x0900), pnp_avm_c))) {
+                if ((pnp_avm_d = pnp_find_dev(pnp_avm_c,
+                        ISAPNP_VENDOR('A', 'V', 'M'),
+                        ISAPNP_FUNCTION(0x0900), pnp_avm_d))) {
+                        int err;
+
+                        pnp_disable_dev(pnp_avm_d);
+                        err = pnp_activate_dev(pnp_avm_d);
+                        if (err<0) {
+                                printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
+                                        __FUNCTION__, err);
+                                return(0);
+                        }
+                        cs->hw.avm.cfg_reg =
+                                pnp_port_start(pnp_avm_d, 0);
+                        cs->irq = pnp_irq(pnp_avm_d, 0);
+                        if (!cs->irq) {
+                                printk(KERN_ERR "FritzPnP:No IRQ\n");
+                                return(0);
+                        }
+                        if (!cs->hw.avm.cfg_reg) {
+                                printk(KERN_ERR "FritzPnP:No IO address\n");
+                                return(0);
+                        }
+                        cs->subtyp = AVM_FRITZ_PNP;
+
+                        return (2);     /* goto 'ready' label */
+                }
+        }
+
+        return (1);
+}
+
+#endif /* __ISAPNP__ */
+
+#ifndef CONFIG_PCI
+
+static int __devinit avm_pci_setup(struct IsdnCardState *cs)
+{
+        return(1);      /* no-op: success */
+}
+
+#else
+
+static struct pci_dev *dev_avm __devinitdata = NULL;
+
+static int __devinit avm_pci_setup(struct IsdnCardState *cs)
+{
+        if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
+                PCI_DEVICE_ID_AVM_A1, dev_avm))) {
+
+                if (pci_enable_device(dev_avm))
+                        return(0);
+
+                cs->irq = dev_avm->irq;
+                if (!cs->irq) {
+                        printk(KERN_ERR "FritzPCI: No IRQ for PCI card found\n");
+                        return(0);
+                }
+
+                cs->hw.avm.cfg_reg = pci_resource_start(dev_avm, 1);
+                if (!cs->hw.avm.cfg_reg) {
+                        printk(KERN_ERR "FritzPCI: No IO-Adr for PCI card found\n");
+                        return(0);
+                }
+
+                cs->subtyp = AVM_FRITZ_PCI;
+        } else {
+                printk(KERN_WARNING "FritzPCI: No PCI card found\n");
+                return(0);
+        }
+
+        cs->irq_flags |= IRQF_SHARED;
+
+        return (1);
+}
+
+#endif /* CONFIG_PCI */
+
+int __devinit
+setup_avm_pcipnp(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        char tmp[64];
+        int rc;
+
+        strcpy(tmp, avm_pci_rev);
+        printk(KERN_INFO "HiSax: AVM PCI driver Rev. %s\n", HiSax_getrev(tmp));
+
+        if (cs->typ != ISDN_CTYPE_FRITZPCI)
+                return (0);
+
+        if (card->para[1]) {
+                /* old manual method */
+                cs->hw.avm.cfg_reg = card->para[1];
+                cs->irq = card->para[0];
+                cs->subtyp = AVM_FRITZ_PNP;
+                goto ready;
+        }
+
+        rc = avm_pnp_setup(cs);
+        if (rc < 1)
+                return (0);
+        if (rc == 2)
+                goto ready;
+
+        rc = avm_pci_setup(cs);
+        if (rc < 1)
+                return (0);
+
+ready:
+        return avm_setup_rest(cs);
+}
diff --git a/drivers/isdn/hisax/bkm_a8.c b/drivers/isdn/hisax/bkm_a8.c
index 6339bb443f..99ef3b43fc 100644
--- a/drivers/isdn/hisax/bkm_a8.c
+++ b/drivers/isdn/hisax/bkm_a8.c
@@ -20,8 +20,6 @@
 #include <linux/pci.h>
 #include "bkm_ax.h"
 
-#ifdef CONFIG_PCI
-
 #define ATTEMPT_PCI_REMAPPING   /* Required for PLX rev 1 */
 
 extern const char *CardType[];
@@ -279,12 +277,9 @@ static u_char pci_bus __devinitdata = 0;
 static u_char pci_device_fn __devinitdata = 0;
 static u_char pci_irq __devinitdata = 0;
 
-#endif /* CONFIG_PCI */
-
 int __devinit
 setup_sct_quadro(struct IsdnCard *card)
 {
-#ifdef CONFIG_PCI
         struct IsdnCardState *cs = card->cs;
         char tmp[64];
         u_int found = 0;
@@ -442,7 +437,4 @@ setup_sct_quadro(struct IsdnCard *card)
                 sct_quadro_subtypes[cs->subtyp],
                 readreg(cs->hw.ax.base, cs->hw.ax.data_adr, IPAC_ID));
         return (1);
-#else
-        printk(KERN_ERR "HiSax: bkm_a8 only supported on PCI Systems\n");
-#endif /* CONFIG_PCI */
 }
diff --git a/drivers/isdn/hisax/diva.c b/drivers/isdn/hisax/diva.c
index 6eebeb441b..8267450787 100644
--- a/drivers/isdn/hisax/diva.c
+++ b/drivers/isdn/hisax/diva.c
@@ -25,8 +25,6 @@
 #include <linux/pci.h>
 #include <linux/isapnp.h>
 
-extern const char *CardType[];
-
 static const char *Diva_revision = "$Revision: 1.33.2.6 $";
 
 #define byteout(addr,val) outb(val,addr)
@@ -906,225 +904,15 @@ Diva_card_msg(struct IsdnCardState *cs, int mt, void *arg)
         return(0);
 }
 
-static struct pci_dev *dev_diva __devinitdata = NULL;
-static struct pci_dev *dev_diva_u __devinitdata = NULL;
-static struct pci_dev *dev_diva201 __devinitdata = NULL;
-static struct pci_dev *dev_diva202 __devinitdata = NULL;
-
-#ifdef __ISAPNP__
-static struct isapnp_device_id diva_ids[] __devinitdata = {
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51),
-          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51), 
-          (unsigned long) "Diva picola" },
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51),
-          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0x51), 
-          (unsigned long) "Diva picola" },
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71),
-          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71), 
-          (unsigned long) "Diva 2.0" },
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71),
-          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0x71), 
-          (unsigned long) "Diva 2.0" },
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1),
-          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1), 
-          (unsigned long) "Diva 2.01" },
-        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1),
-          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0xA1), 
-          (unsigned long) "Diva 2.01" },
-        { 0, }
-};
-
-static struct isapnp_device_id *ipid __devinitdata = &diva_ids[0];
-static struct pnp_card *pnp_c __devinitdata = NULL;
-#endif
-
-
-int __devinit
-setup_diva(struct IsdnCard *card)
+static int __devinit setup_diva_common(struct IsdnCardState *cs)
 {
-        int bytecnt = 8;
+        int bytecnt;
         u_char val;
-        struct IsdnCardState *cs = card->cs;
-        char tmp[64];
-
-        strcpy(tmp, Diva_revision);
-        printk(KERN_INFO "HiSax: Eicon.Diehl Diva driver Rev. %s\n", HiSax_getrev(tmp));
-        if (cs->typ != ISDN_CTYPE_DIEHLDIVA)
-                return(0);
-        cs->hw.diva.status = 0;
-        if (card->para[1]) {
-                cs->hw.diva.ctrl_reg = 0;
-                cs->hw.diva.cfg_reg = card->para[1];
-                val = readreg(cs->hw.diva.cfg_reg + DIVA_IPAC_ADR,
-                        cs->hw.diva.cfg_reg + DIVA_IPAC_DATA, IPAC_ID);
-                printk(KERN_INFO "Diva: IPAC version %x\n", val);
-                if ((val == 1) || (val==2)) {
-                        cs->subtyp = DIVA_IPAC_ISA;
-                        cs->hw.diva.ctrl = 0;
-                        cs->hw.diva.isac = card->para[1] + DIVA_IPAC_DATA;
-                        cs->hw.diva.hscx = card->para[1] + DIVA_IPAC_DATA;
-                        cs->hw.diva.isac_adr = card->para[1] + DIVA_IPAC_ADR;
-                        cs->hw.diva.hscx_adr = card->para[1] + DIVA_IPAC_ADR;
-                        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-                } else {
-                        cs->subtyp = DIVA_ISA;
-                        cs->hw.diva.ctrl = card->para[1] + DIVA_ISA_CTRL;
-                        cs->hw.diva.isac = card->para[1] + DIVA_ISA_ISAC_DATA;
-                        cs->hw.diva.hscx = card->para[1] + DIVA_HSCX_DATA;
-                        cs->hw.diva.isac_adr = card->para[1] + DIVA_ISA_ISAC_ADR;
-                        cs->hw.diva.hscx_adr = card->para[1] + DIVA_HSCX_ADR;
-                }
-                cs->irq = card->para[0];
-        } else {
-#ifdef __ISAPNP__
-                if (isapnp_present()) {
-                        struct pnp_dev *pnp_d;
-                        while(ipid->card_vendor) {
-                                if ((pnp_c = pnp_find_card(ipid->card_vendor,
-                                        ipid->card_device, pnp_c))) {
-                                        pnp_d = NULL;
-                                        if ((pnp_d = pnp_find_dev(pnp_c,
-                                                ipid->vendor, ipid->function, pnp_d))) {
-                                                int err;
-
-                                                printk(KERN_INFO "HiSax: %s detected\n",
-                                                        (char *)ipid->driver_data);
-                                                pnp_disable_dev(pnp_d);
-                                                err = pnp_activate_dev(pnp_d);
-                                                if (err<0) {
-                                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-                                                                __FUNCTION__, err);
-                                                        return(0);
-                                                }
-                                                card->para[1] = pnp_port_start(pnp_d, 0);
-                                                card->para[0] = pnp_irq(pnp_d, 0);
-                                                if (!card->para[0] || !card->para[1]) {
-                                                        printk(KERN_ERR "Diva PnP:some resources are missing %ld/%lx\n",
-                                                                card->para[0], card->para[1]);
-                                                        pnp_disable_dev(pnp_d); 
-                                                        return(0);
-                                                }
-                                                cs->hw.diva.cfg_reg  = card->para[1];
-                                                cs->irq = card->para[0];
-                                                if (ipid->function == ISAPNP_FUNCTION(0xA1)) {
-                                                        cs->subtyp = DIVA_IPAC_ISA;
-                                                        cs->hw.diva.ctrl = 0;
-                                                        cs->hw.diva.isac =
-                                                                card->para[1] + DIVA_IPAC_DATA;
-                                                        cs->hw.diva.hscx =
-                                                                card->para[1] + DIVA_IPAC_DATA;
-                                                        cs->hw.diva.isac_adr =
-                                                                card->para[1] + DIVA_IPAC_ADR;
-                                                        cs->hw.diva.hscx_adr =
-                                                                card->para[1] + DIVA_IPAC_ADR;
-                                                        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-                                                } else {
-                                                        cs->subtyp = DIVA_ISA;
-                                                        cs->hw.diva.ctrl =
-                                                                card->para[1] + DIVA_ISA_CTRL;
-                                                        cs->hw.diva.isac =
-                                                                card->para[1] + DIVA_ISA_ISAC_DATA;
-                                                        cs->hw.diva.hscx =
-                                                                card->para[1] + DIVA_HSCX_DATA;
-                                                        cs->hw.diva.isac_adr =
-                                                                card->para[1] + DIVA_ISA_ISAC_ADR;
-                                                        cs->hw.diva.hscx_adr =
-                                                                card->para[1] + DIVA_HSCX_ADR;
-                                                }
-                                                goto ready;
-                                        } else {
-                                                printk(KERN_ERR "Diva PnP: PnP error card found, no device\n");
-                                                return(0);
-                                        }
-                                }
-                                ipid++;
-                                pnp_c=NULL;
-                        } 
-                        if (!ipid->card_vendor) {
-                                printk(KERN_INFO "Diva PnP: no ISAPnP card found\n");
-                        }
-                }
-#endif
-#ifdef CONFIG_PCI
-                cs->subtyp = 0;
-                if ((dev_diva = pci_find_device(PCI_VENDOR_ID_EICON,
-                        PCI_DEVICE_ID_EICON_DIVA20, dev_diva))) {
-                        if (pci_enable_device(dev_diva))
-                                return(0);
-                        cs->subtyp = DIVA_PCI;
-                        cs->irq = dev_diva->irq;
-                        cs->hw.diva.cfg_reg = pci_resource_start(dev_diva, 2);
-                } else if ((dev_diva_u = pci_find_device(PCI_VENDOR_ID_EICON,
-                        PCI_DEVICE_ID_EICON_DIVA20_U, dev_diva_u))) {
-                        if (pci_enable_device(dev_diva_u))
-                                return(0);
-                        cs->subtyp = DIVA_PCI;
-                        cs->irq = dev_diva_u->irq;
-                        cs->hw.diva.cfg_reg = pci_resource_start(dev_diva_u, 2);
-                } else if ((dev_diva201 = pci_find_device(PCI_VENDOR_ID_EICON,
-                        PCI_DEVICE_ID_EICON_DIVA201, dev_diva201))) {
-                        if (pci_enable_device(dev_diva201))
-                                return(0);
-                        cs->subtyp = DIVA_IPAC_PCI;
-                        cs->irq = dev_diva201->irq;
-                        cs->hw.diva.pci_cfg =
-                                (ulong) ioremap(pci_resource_start(dev_diva201, 0), 4096);
-                        cs->hw.diva.cfg_reg =
-                                (ulong) ioremap(pci_resource_start(dev_diva201, 1), 4096);
-                } else if ((dev_diva202 = pci_find_device(PCI_VENDOR_ID_EICON,
-                        PCI_DEVICE_ID_EICON_DIVA202, dev_diva202))) {
-                        if (pci_enable_device(dev_diva202))
-                                return(0);
-                        cs->subtyp = DIVA_IPACX_PCI;
-                        cs->irq = dev_diva202->irq;
-                        cs->hw.diva.pci_cfg =
-                                (ulong) ioremap(pci_resource_start(dev_diva202, 0), 4096);
-                        cs->hw.diva.cfg_reg =
-                                (ulong) ioremap(pci_resource_start(dev_diva202, 1), 4096);
-                } else {
-                        printk(KERN_WARNING "Diva: No PCI card found\n");
-                        return(0);
-                }
-
-                if (!cs->irq) {
-                        printk(KERN_WARNING "Diva: No IRQ for PCI card found\n");
-                        iounmap_diva(cs);
-                        return(0);
-                }
-
-                if (!cs->hw.diva.cfg_reg) {
-                        printk(KERN_WARNING "Diva: No IO-Adr for PCI card found\n");
-                        iounmap_diva(cs);
-                        return(0);
-                }
-                cs->irq_flags |= IRQF_SHARED;
-#else
-                printk(KERN_WARNING "Diva: cfgreg 0 and NO_PCI_BIOS\n");
-                printk(KERN_WARNING "Diva: unable to config DIVA PCI\n");
-                return (0);
-#endif /* CONFIG_PCI */
-                if ((cs->subtyp == DIVA_IPAC_PCI) ||
-                    (cs->subtyp == DIVA_IPACX_PCI)   ) {
-                        cs->hw.diva.ctrl = 0;
-                        cs->hw.diva.isac = 0;
-                        cs->hw.diva.hscx = 0;
-                        cs->hw.diva.isac_adr = 0;
-                        cs->hw.diva.hscx_adr = 0;
-                        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-                        bytecnt = 0;
-                } else {
-                        cs->hw.diva.ctrl = cs->hw.diva.cfg_reg + DIVA_PCI_CTRL;
-                        cs->hw.diva.isac = cs->hw.diva.cfg_reg + DIVA_PCI_ISAC_DATA;
-                        cs->hw.diva.hscx = cs->hw.diva.cfg_reg + DIVA_HSCX_DATA;
-                        cs->hw.diva.isac_adr = cs->hw.diva.cfg_reg + DIVA_PCI_ISAC_ADR;
-                        cs->hw.diva.hscx_adr = cs->hw.diva.cfg_reg + DIVA_HSCX_ADR;
-                        bytecnt = 32;
-                }
-        }
 
-#ifdef __ISAPNP__
-ready:
-#endif
+        if ((cs->subtyp == DIVA_ISA) || (cs->subtyp == DIVA_IPAC_ISA))
+                bytecnt = 8;
+        else
+                bytecnt = 32;
 
         printk(KERN_INFO
                 "Diva: %s card configured at %#lx IRQ %d\n",
@@ -1145,7 +933,7 @@ ready:
                 if (!request_region(cs->hw.diva.cfg_reg, bytecnt, "diva isdn")) {
                         printk(KERN_WARNING
                                "HiSax: %s config port %lx-%lx already in use\n",
-                               CardType[card->typ],
+                               "diva",
                                cs->hw.diva.cfg_reg,
                                cs->hw.diva.cfg_reg + bytecnt);
                         iounmap_diva(cs);
@@ -1206,3 +994,290 @@ ready:
         }
         return (1);
 }
+
+#ifdef CONFIG_ISA
+
+static int __devinit setup_diva_isa(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        u_char val;
+
+        if (!card->para[1])
+                return (-1);    /* card not found; continue search */
+
+        cs->hw.diva.ctrl_reg = 0;
+        cs->hw.diva.cfg_reg = card->para[1];
+        val = readreg(cs->hw.diva.cfg_reg + DIVA_IPAC_ADR,
+                cs->hw.diva.cfg_reg + DIVA_IPAC_DATA, IPAC_ID);
+        printk(KERN_INFO "Diva: IPAC version %x\n", val);
+        if ((val == 1) || (val==2)) {
+                cs->subtyp = DIVA_IPAC_ISA;
+                cs->hw.diva.ctrl = 0;
+                cs->hw.diva.isac = card->para[1] + DIVA_IPAC_DATA;
+                cs->hw.diva.hscx = card->para[1] + DIVA_IPAC_DATA;
+                cs->hw.diva.isac_adr = card->para[1] + DIVA_IPAC_ADR;
+                cs->hw.diva.hscx_adr = card->para[1] + DIVA_IPAC_ADR;
+                test_and_set_bit(HW_IPAC, &cs->HW_Flags);
+        } else {
+                cs->subtyp = DIVA_ISA;
+                cs->hw.diva.ctrl = card->para[1] + DIVA_ISA_CTRL;
+                cs->hw.diva.isac = card->para[1] + DIVA_ISA_ISAC_DATA;
+                cs->hw.diva.hscx = card->para[1] + DIVA_HSCX_DATA;
+                cs->hw.diva.isac_adr = card->para[1] + DIVA_ISA_ISAC_ADR;
+                cs->hw.diva.hscx_adr = card->para[1] + DIVA_HSCX_ADR;
+        }
+        cs->irq = card->para[0];
+
+        return (1);             /* card found */
+}
+
+#else   /* if !CONFIG_ISA */
+
+static int __devinit setup_diva_isa(struct IsdnCard *card)
+{
+        return (-1);    /* card not found; continue search */
+}
+
+#endif  /* CONFIG_ISA */
+
+#ifdef __ISAPNP__
+static struct isapnp_device_id diva_ids[] __devinitdata = {
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51),
+          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51), 
+          (unsigned long) "Diva picola" },
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x51),
+          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0x51), 
+          (unsigned long) "Diva picola" },
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71),
+          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71), 
+          (unsigned long) "Diva 2.0" },
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0x71),
+          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0x71), 
+          (unsigned long) "Diva 2.0" },
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1),
+          ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1), 
+          (unsigned long) "Diva 2.01" },
+        { ISAPNP_VENDOR('G', 'D', 'I'), ISAPNP_FUNCTION(0xA1),
+          ISAPNP_VENDOR('E', 'I', 'C'), ISAPNP_FUNCTION(0xA1), 
+          (unsigned long) "Diva 2.01" },
+        { 0, }
+};
+
+static struct isapnp_device_id *ipid __devinitdata = &diva_ids[0];
+static struct pnp_card *pnp_c __devinitdata = NULL;
+
+static int __devinit setup_diva_isapnp(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        struct pnp_dev *pnp_d;
+
+        if (!isapnp_present())
+                return (-1);    /* card not found; continue search */
+
+        while(ipid->card_vendor) {
+                if ((pnp_c = pnp_find_card(ipid->card_vendor,
+                        ipid->card_device, pnp_c))) {
+                        pnp_d = NULL;
+                        if ((pnp_d = pnp_find_dev(pnp_c,
+                                ipid->vendor, ipid->function, pnp_d))) {
+                                int err;
+
+                                printk(KERN_INFO "HiSax: %s detected\n",
+                                        (char *)ipid->driver_data);
+                                pnp_disable_dev(pnp_d);
+                                err = pnp_activate_dev(pnp_d);
+                                if (err<0) {
+                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
+                                                __FUNCTION__, err);
+                                        return(0);
+                                }
+                                card->para[1] = pnp_port_start(pnp_d, 0);
+                                card->para[0] = pnp_irq(pnp_d, 0);
+                                if (!card->para[0] || !card->para[1]) {
+                                        printk(KERN_ERR "Diva PnP:some resources are missing %ld/%lx\n",
+                                                card->para[0], card->para[1]);
+                                        pnp_disable_dev(pnp_d); 
+                                        return(0);
+                                }
+                                cs->hw.diva.cfg_reg  = card->para[1];
+                                cs->irq = card->para[0];
+                                if (ipid->function == ISAPNP_FUNCTION(0xA1)) {
+                                        cs->subtyp = DIVA_IPAC_ISA;
+                                        cs->hw.diva.ctrl = 0;
+                                        cs->hw.diva.isac =
+                                                card->para[1] + DIVA_IPAC_DATA;
+                                        cs->hw.diva.hscx =
+                                                card->para[1] + DIVA_IPAC_DATA;
+                                        cs->hw.diva.isac_adr =
+                                                card->para[1] + DIVA_IPAC_ADR;
+                                        cs->hw.diva.hscx_adr =
+                                                card->para[1] + DIVA_IPAC_ADR;
+                                        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
+                                } else {
+                                        cs->subtyp = DIVA_ISA;
+                                        cs->hw.diva.ctrl =
+                                                card->para[1] + DIVA_ISA_CTRL;
+                                        cs->hw.diva.isac =
+                                                card->para[1] + DIVA_ISA_ISAC_DATA;
+                                        cs->hw.diva.hscx =
+                                                card->para[1] + DIVA_HSCX_DATA;
+                                        cs->hw.diva.isac_adr =
+                                                card->para[1] + DIVA_ISA_ISAC_ADR;
+                                        cs->hw.diva.hscx_adr =
+                                                card->para[1] + DIVA_HSCX_ADR;
+                                }
+                                return (1);             /* card found */
+                        } else {
+                                printk(KERN_ERR "Diva PnP: PnP error card found, no device\n");
+                                return(0);
+                        }
+                }
+                ipid++;
+                pnp_c=NULL;
+        } 
+
+        return (-1);    /* card not found; continue search */
+}
+
+#else   /* if !ISAPNP */
+
+static int __devinit setup_diva_isapnp(struct IsdnCard *card)
+{
+        return (-1);    /* card not found; continue search */
+}
+
+#endif  /* ISAPNP */
+
+#ifdef CONFIG_PCI
+static struct pci_dev *dev_diva __devinitdata = NULL;
+static struct pci_dev *dev_diva_u __devinitdata = NULL;
+static struct pci_dev *dev_diva201 __devinitdata = NULL;
+static struct pci_dev *dev_diva202 __devinitdata = NULL;
+
+static int __devinit setup_diva_pci(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+
+        cs->subtyp = 0;
+        if ((dev_diva = pci_find_device(PCI_VENDOR_ID_EICON,
+                PCI_DEVICE_ID_EICON_DIVA20, dev_diva))) {
+                if (pci_enable_device(dev_diva))
+                        return(0);
+                cs->subtyp = DIVA_PCI;
+                cs->irq = dev_diva->irq;
+                cs->hw.diva.cfg_reg = pci_resource_start(dev_diva, 2);
+        } else if ((dev_diva_u = pci_find_device(PCI_VENDOR_ID_EICON,
+                PCI_DEVICE_ID_EICON_DIVA20_U, dev_diva_u))) {
+                if (pci_enable_device(dev_diva_u))
+                        return(0);
+                cs->subtyp = DIVA_PCI;
+                cs->irq = dev_diva_u->irq;
+                cs->hw.diva.cfg_reg = pci_resource_start(dev_diva_u, 2);
+        } else if ((dev_diva201 = pci_find_device(PCI_VENDOR_ID_EICON,
+                PCI_DEVICE_ID_EICON_DIVA201, dev_diva201))) {
+                if (pci_enable_device(dev_diva201))
+                        return(0);
+                cs->subtyp = DIVA_IPAC_PCI;
+                cs->irq = dev_diva201->irq;
+                cs->hw.diva.pci_cfg =
+                        (ulong) ioremap(pci_resource_start(dev_diva201, 0), 4096);
+                cs->hw.diva.cfg_reg =
+                        (ulong) ioremap(pci_resource_start(dev_diva201, 1), 4096);
+        } else if ((dev_diva202 = pci_find_device(PCI_VENDOR_ID_EICON,
+                PCI_DEVICE_ID_EICON_DIVA202, dev_diva202))) {
+                if (pci_enable_device(dev_diva202))
+                        return(0);
+                cs->subtyp = DIVA_IPACX_PCI;
+                cs->irq = dev_diva202->irq;
+                cs->hw.diva.pci_cfg =
+                        (ulong) ioremap(pci_resource_start(dev_diva202, 0), 4096);
+                cs->hw.diva.cfg_reg =
+                        (ulong) ioremap(pci_resource_start(dev_diva202, 1), 4096);
+        } else {
+                return (-1);    /* card not found; continue search */
+        }
+
+        if (!cs->irq) {
+                printk(KERN_WARNING "Diva: No IRQ for PCI card found\n");
+                iounmap_diva(cs);
+                return(0);
+        }
+
+        if (!cs->hw.diva.cfg_reg) {
+                printk(KERN_WARNING "Diva: No IO-Adr for PCI card found\n");
+                iounmap_diva(cs);
+                return(0);
+        }
+        cs->irq_flags |= IRQF_SHARED;
+
+        if ((cs->subtyp == DIVA_IPAC_PCI) ||
+            (cs->subtyp == DIVA_IPACX_PCI)   ) {
+                cs->hw.diva.ctrl = 0;
+                cs->hw.diva.isac = 0;
+                cs->hw.diva.hscx = 0;
+                cs->hw.diva.isac_adr = 0;
+                cs->hw.diva.hscx_adr = 0;
+                test_and_set_bit(HW_IPAC, &cs->HW_Flags);
+        } else {
+                cs->hw.diva.ctrl = cs->hw.diva.cfg_reg + DIVA_PCI_CTRL;
+                cs->hw.diva.isac = cs->hw.diva.cfg_reg + DIVA_PCI_ISAC_DATA;
+                cs->hw.diva.hscx = cs->hw.diva.cfg_reg + DIVA_HSCX_DATA;
+                cs->hw.diva.isac_adr = cs->hw.diva.cfg_reg + DIVA_PCI_ISAC_ADR;
+                cs->hw.diva.hscx_adr = cs->hw.diva.cfg_reg + DIVA_HSCX_ADR;
+        }
+
+        return (1);             /* card found */
+}
+
+#else   /* if !CONFIG_PCI */
+
+static int __devinit setup_diva_pci(struct IsdnCard *card)
+{
+        return (-1);    /* card not found; continue search */
+}
+
+#endif  /* CONFIG_PCI */
+
+int __devinit
+setup_diva(struct IsdnCard *card)
+{
+        int rc, have_card = 0;
+        struct IsdnCardState *cs = card->cs;
+        char tmp[64];
+
+        strcpy(tmp, Diva_revision);
+        printk(KERN_INFO "HiSax: Eicon.Diehl Diva driver Rev. %s\n", HiSax_getrev(tmp));
+        if (cs->typ != ISDN_CTYPE_DIEHLDIVA)
+                return(0);
+        cs->hw.diva.status = 0;
+
+        rc = setup_diva_isa(card);
+        if (!rc)
+                return rc;
+        if (rc > 0) {
+                have_card = 1;
+                goto ready;
+        }
+
+        rc = setup_diva_isapnp(card);
+        if (!rc)
+                return rc;
+        if (rc > 0) {
+                have_card = 1;
+                goto ready;
+        }
+
+        rc = setup_diva_pci(card);
+        if (!rc)
+                return rc;
+        if (rc > 0)
+                have_card = 1;
+
+ready:
+        if (!have_card) {
+                printk(KERN_WARNING "Diva: No ISA, ISAPNP or PCI card found\n");
+                return(0);
+        }
+
+        return setup_diva_common(card->cs);
+}
diff --git a/drivers/isdn/hisax/elsa.c b/drivers/isdn/hisax/elsa.c
index fab3e4ea05..948a9b290f 100644
--- a/drivers/isdn/hisax/elsa.c
+++ b/drivers/isdn/hisax/elsa.c
@@ -30,8 +30,6 @@
 #include <linux/serial.h>
 #include <linux/serial_reg.h>
 
-extern const char *CardType[];
-
 static const char *Elsa_revision = "$Revision: 2.32.2.4 $";
 static const char *Elsa_Types[] =
 {"None", "PC", "PCC-8", "PCC-16", "PCF", "PCF-Pro",
@@ -832,8 +830,75 @@ probe_elsa(struct IsdnCardState *cs)
         return (CARD_portlist[i]);
 }
 
-static  struct pci_dev *dev_qs1000 __devinitdata = NULL;
-static  struct pci_dev *dev_qs3000 __devinitdata = NULL;
+static int __devinit
+setup_elsa_isa(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        u_char val;
+
+        cs->hw.elsa.base = card->para[0];
+        printk(KERN_INFO "Elsa: Microlink IO probing\n");
+        if (cs->hw.elsa.base) {
+                if (!(cs->subtyp = probe_elsa_adr(cs->hw.elsa.base,
+                                                  cs->typ))) {
+                        printk(KERN_WARNING
+                               "Elsa: no Elsa Microlink at %#lx\n",
+                               cs->hw.elsa.base);
+                        return (0);
+                }
+        } else
+                cs->hw.elsa.base = probe_elsa(cs);
+
+        if (!cs->hw.elsa.base) {
+                printk(KERN_WARNING
+                       "No Elsa Microlink found\n");
+                return (0);
+        }
+
+        cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
+        cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
+        cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
+        cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
+        cs->hw.elsa.itac = cs->hw.elsa.base + ELSA_ITAC;
+        cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
+        cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
+        cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
+        val = bytein(cs->hw.elsa.cfg);
+        if (cs->subtyp == ELSA_PC) {
+                const u_char CARD_IrqTab[8] =
+                {7, 3, 5, 9, 0, 0, 0, 0};
+                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PC) >> 2];
+        } else if (cs->subtyp == ELSA_PCC8) {
+                const u_char CARD_IrqTab[8] =
+                {7, 3, 5, 9, 0, 0, 0, 0};
+                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PCC8) >> 4];
+        } else {
+                const u_char CARD_IrqTab[8] =
+                {15, 10, 15, 3, 11, 5, 11, 9};
+                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX) >> 3];
+        }
+        val = bytein(cs->hw.elsa.ale) & ELSA_HW_RELEASE;
+        if (val < 3)
+                val |= 8;
+        val += 'A' - 3;
+        if (val == 'B' || val == 'C')
+                val ^= 1;
+        if ((cs->subtyp == ELSA_PCFPRO) && (val = 'G'))
+                val = 'C';
+        printk(KERN_INFO
+               "Elsa: %s found at %#lx Rev.:%c IRQ %d\n",
+               Elsa_Types[cs->subtyp],
+               cs->hw.elsa.base,
+               val, cs->irq);
+        val = bytein(cs->hw.elsa.ale) & ELSA_S0_POWER_BAD;
+        if (val) {
+                printk(KERN_WARNING
+                   "Elsa: Microlink S0 bus power bad\n");
+                cs->hw.elsa.status |= ELSA_BAD_PWR;
+        }
+
+        return (1);
+}
 
 #ifdef __ISAPNP__
 static struct isapnp_device_id elsa_ids[] __devinitdata = {
@@ -848,233 +913,194 @@ static struct isapnp_device_id elsa_ids[] __devinitdata = {
 
 static struct isapnp_device_id *ipid __devinitdata = &elsa_ids[0];
 static struct pnp_card *pnp_c __devinitdata = NULL;
-#endif
+#endif  /* __ISAPNP__ */
 
-int __devinit
-setup_elsa(struct IsdnCard *card)
+static int __devinit
+setup_elsa_isapnp(struct IsdnCard *card)
 {
-        int bytecnt;
-        u_char val;
         struct IsdnCardState *cs = card->cs;
-        char tmp[64];
 
-        strcpy(tmp, Elsa_revision);
-        printk(KERN_INFO "HiSax: Elsa driver Rev. %s\n", HiSax_getrev(tmp));
-        cs->hw.elsa.ctrl_reg = 0;
-        cs->hw.elsa.status = 0;
-        cs->hw.elsa.MFlag = 0;
-        cs->subtyp = 0;
-        if (cs->typ == ISDN_CTYPE_ELSA) {
-                cs->hw.elsa.base = card->para[0];
-                printk(KERN_INFO "Elsa: Microlink IO probing\n");
-                if (cs->hw.elsa.base) {
-                        if (!(cs->subtyp = probe_elsa_adr(cs->hw.elsa.base,
-                                                          cs->typ))) {
-                                printk(KERN_WARNING
-                                       "Elsa: no Elsa Microlink at %#lx\n",
-                                       cs->hw.elsa.base);
-                                return (0);
-                        }
-                } else
-                        cs->hw.elsa.base = probe_elsa(cs);
-                if (cs->hw.elsa.base) {
-                        cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
-                        cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
-                        cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
-                        cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
-                        cs->hw.elsa.itac = cs->hw.elsa.base + ELSA_ITAC;
-                        cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
-                        cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
-                        cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
-                        val = bytein(cs->hw.elsa.cfg);
-                        if (cs->subtyp == ELSA_PC) {
-                                const u_char CARD_IrqTab[8] =
-                                {7, 3, 5, 9, 0, 0, 0, 0};
-                                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PC) >> 2];
-                        } else if (cs->subtyp == ELSA_PCC8) {
-                                const u_char CARD_IrqTab[8] =
-                                {7, 3, 5, 9, 0, 0, 0, 0};
-                                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX_PCC8) >> 4];
-                        } else {
-                                const u_char CARD_IrqTab[8] =
-                                {15, 10, 15, 3, 11, 5, 11, 9};
-                                cs->irq = CARD_IrqTab[(val & ELSA_IRQ_IDX) >> 3];
-                        }
-                        val = bytein(cs->hw.elsa.ale) & ELSA_HW_RELEASE;
-                        if (val < 3)
-                                val |= 8;
-                        val += 'A' - 3;
-                        if (val == 'B' || val == 'C')
-                                val ^= 1;
-                        if ((cs->subtyp == ELSA_PCFPRO) && (val = 'G'))
-                                val = 'C';
-                        printk(KERN_INFO
-                               "Elsa: %s found at %#lx Rev.:%c IRQ %d\n",
-                               Elsa_Types[cs->subtyp],
-                               cs->hw.elsa.base,
-                               val, cs->irq);
-                        val = bytein(cs->hw.elsa.ale) & ELSA_S0_POWER_BAD;
-                        if (val) {
-                                printk(KERN_WARNING
-                                   "Elsa: Microlink S0 bus power bad\n");
-                                cs->hw.elsa.status |= ELSA_BAD_PWR;
-                        }
-                } else {
-                        printk(KERN_WARNING
-                               "No Elsa Microlink found\n");
-                        return (0);
-                }
-        } else if (cs->typ == ISDN_CTYPE_ELSA_PNP) {
 #ifdef __ISAPNP__
-                if (!card->para[1] && isapnp_present()) {
-                        struct pnp_dev *pnp_d;
-                        while(ipid->card_vendor) {
-                                if ((pnp_c = pnp_find_card(ipid->card_vendor,
-                                        ipid->card_device, pnp_c))) {
-                                        pnp_d = NULL;
-                                        if ((pnp_d = pnp_find_dev(pnp_c,
-                                                ipid->vendor, ipid->function, pnp_d))) {
-                                                int err;
-
-                                                printk(KERN_INFO "HiSax: %s detected\n",
-                                                        (char *)ipid->driver_data);
+        if (!card->para[1] && isapnp_present()) {
+                struct pnp_dev *pnp_d;
+                while(ipid->card_vendor) {
+                        if ((pnp_c = pnp_find_card(ipid->card_vendor,
+                                ipid->card_device, pnp_c))) {
+                                pnp_d = NULL;
+                                if ((pnp_d = pnp_find_dev(pnp_c,
+                                        ipid->vendor, ipid->function, pnp_d))) {
+                                        int err;
+
+                                        printk(KERN_INFO "HiSax: %s detected\n",
+                                                (char *)ipid->driver_data);
+                                        pnp_disable_dev(pnp_d);
+                                        err = pnp_activate_dev(pnp_d);
+                                        if (err<0) {
+                                                printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
+                                                        __FUNCTION__, err);
+                                                return(0);
+                                        }
+                                        card->para[1] = pnp_port_start(pnp_d, 0);
+                                        card->para[0] = pnp_irq(pnp_d, 0);
+
+                                        if (!card->para[0] || !card->para[1]) {
+                                                printk(KERN_ERR "Elsa PnP:some resources are missing %ld/%lx\n",
+                                                        card->para[0], card->para[1]);
                                                 pnp_disable_dev(pnp_d);
-                                                err = pnp_activate_dev(pnp_d);
-                                                if (err<0) {
-                                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-                                                                __FUNCTION__, err);
-                                                        return(0);
-                                                }
-                                                card->para[1] = pnp_port_start(pnp_d, 0);
-                                                card->para[0] = pnp_irq(pnp_d, 0);
-
-                                                if (!card->para[0] || !card->para[1]) {
-                                                        printk(KERN_ERR "Elsa PnP:some resources are missing %ld/%lx\n",
-                                                                card->para[0], card->para[1]);
-                                                        pnp_disable_dev(pnp_d);
-                                                        return(0);
-                                                }
-                                                if (ipid->function == ISAPNP_FUNCTION(0x133))
-                                                        cs->subtyp = ELSA_QS1000;
-                                                else
-                                                        cs->subtyp = ELSA_QS3000;
-                                                break;
-                                        } else {
-                                                printk(KERN_ERR "Elsa PnP: PnP error card found, no device\n");
                                                 return(0);
                                         }
+                                        if (ipid->function == ISAPNP_FUNCTION(0x133))
+                                                cs->subtyp = ELSA_QS1000;
+                                        else
+                                                cs->subtyp = ELSA_QS3000;
+                                        break;
+                                } else {
+                                        printk(KERN_ERR "Elsa PnP: PnP error card found, no device\n");
+                                        return(0);
                                 }
-                                ipid++;
-                                pnp_c=NULL;
-                        } 
-                        if (!ipid->card_vendor) {
-                                printk(KERN_INFO "Elsa PnP: no ISAPnP card found\n");
-                                return(0);
                         }
+                        ipid++;
+                        pnp_c=NULL;
+                } 
+                if (!ipid->card_vendor) {
+                        printk(KERN_INFO "Elsa PnP: no ISAPnP card found\n");
+                        return(0);
                 }
-#endif
-                if (card->para[1] && card->para[0]) { 
-                        cs->hw.elsa.base = card->para[1];
-                        cs->irq = card->para[0];
-                        if (!cs->subtyp)
-                                cs->subtyp = ELSA_QS1000;
-                } else {
-                        printk(KERN_ERR "Elsa PnP: no parameter\n");
-                }
-                cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
-                cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
-                cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
-                cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
-                cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
-                cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
-                cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
-                printk(KERN_INFO
-                       "Elsa: %s defined at %#lx IRQ %d\n",
-                       Elsa_Types[cs->subtyp],
-                       cs->hw.elsa.base,
-                       cs->irq);
-        } else if (cs->typ == ISDN_CTYPE_ELSA_PCMCIA) {
+        }
+#endif  /* __ISAPNP__ */
+
+        if (card->para[1] && card->para[0]) { 
                 cs->hw.elsa.base = card->para[1];
                 cs->irq = card->para[0];
-                val = readreg(cs->hw.elsa.base + 0, cs->hw.elsa.base + 2, IPAC_ID);
-                if ((val == 1) || (val == 2)) { /* IPAC version 1.1/1.2 */
-                        cs->subtyp = ELSA_PCMCIA_IPAC;
-                        cs->hw.elsa.ale = cs->hw.elsa.base + 0;
-                        cs->hw.elsa.isac = cs->hw.elsa.base + 2;
-                        cs->hw.elsa.hscx = cs->hw.elsa.base + 2;
-                        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-                } else {
-                        cs->subtyp = ELSA_PCMCIA;
-                        cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE_PCM;
-                        cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC_PCM;
-                        cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
-                }
-                cs->hw.elsa.timer = 0;
-                cs->hw.elsa.trig = 0;
-                cs->hw.elsa.ctrl = 0;
-                cs->irq_flags |= IRQF_SHARED;
-                printk(KERN_INFO
-                       "Elsa: %s defined at %#lx IRQ %d\n",
-                       Elsa_Types[cs->subtyp],
-                       cs->hw.elsa.base,
-                       cs->irq);
-        } else if (cs->typ == ISDN_CTYPE_ELSA_PCI) {
+                if (!cs->subtyp)
+                        cs->subtyp = ELSA_QS1000;
+        } else {
+                printk(KERN_ERR "Elsa PnP: no parameter\n");
+        }
+        cs->hw.elsa.cfg = cs->hw.elsa.base + ELSA_CONFIG;
+        cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE;
+        cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC;
+        cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
+        cs->hw.elsa.trig = cs->hw.elsa.base + ELSA_TRIG_IRQ;
+        cs->hw.elsa.timer = cs->hw.elsa.base + ELSA_START_TIMER;
+        cs->hw.elsa.ctrl = cs->hw.elsa.base + ELSA_CONTROL;
+        printk(KERN_INFO
+               "Elsa: %s defined at %#lx IRQ %d\n",
+               Elsa_Types[cs->subtyp],
+               cs->hw.elsa.base,
+               cs->irq);
+
+        return (1);
+}
+
+static void __devinit
+setup_elsa_pcmcia(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        u_char val;
+
+        cs->hw.elsa.base = card->para[1];
+        cs->irq = card->para[0];
+        val = readreg(cs->hw.elsa.base + 0, cs->hw.elsa.base + 2, IPAC_ID);
+        if ((val == 1) || (val == 2)) { /* IPAC version 1.1/1.2 */
+                cs->subtyp = ELSA_PCMCIA_IPAC;
+                cs->hw.elsa.ale = cs->hw.elsa.base + 0;
+                cs->hw.elsa.isac = cs->hw.elsa.base + 2;
+                cs->hw.elsa.hscx = cs->hw.elsa.base + 2;
+                test_and_set_bit(HW_IPAC, &cs->HW_Flags);
+        } else {
+                cs->subtyp = ELSA_PCMCIA;
+                cs->hw.elsa.ale = cs->hw.elsa.base + ELSA_ALE_PCM;
+                cs->hw.elsa.isac = cs->hw.elsa.base + ELSA_ISAC_PCM;
+                cs->hw.elsa.hscx = cs->hw.elsa.base + ELSA_HSCX;
+        }
+        cs->hw.elsa.timer = 0;
+        cs->hw.elsa.trig = 0;
+        cs->hw.elsa.ctrl = 0;
+        cs->irq_flags |= IRQF_SHARED;
+        printk(KERN_INFO
+               "Elsa: %s defined at %#lx IRQ %d\n",
+               Elsa_Types[cs->subtyp],
+               cs->hw.elsa.base,
+               cs->irq);
+}
+
 #ifdef CONFIG_PCI
-                cs->subtyp = 0;
-                if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
-                        PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
-                        if (pci_enable_device(dev_qs1000))
-                                return(0);
-                        cs->subtyp = ELSA_QS1000PCI;
-                        cs->irq = dev_qs1000->irq;
-                        cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
-                        cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
-                } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
-                        PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
-                        if (pci_enable_device(dev_qs3000))
-                                return(0);
-                        cs->subtyp = ELSA_QS3000PCI;
-                        cs->irq = dev_qs3000->irq;
-                        cs->hw.elsa.cfg = pci_resource_start(dev_qs3000, 1);
-                        cs->hw.elsa.base = pci_resource_start(dev_qs3000, 3);
-                } else {
-                        printk(KERN_WARNING "Elsa: No PCI card found\n");
+static  struct pci_dev *dev_qs1000 __devinitdata = NULL;
+static  struct pci_dev *dev_qs3000 __devinitdata = NULL;
+
+static int __devinit
+setup_elsa_pci(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+
+        cs->subtyp = 0;
+        if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+                PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
+                if (pci_enable_device(dev_qs1000))
                         return(0);
-                }
-                if (!cs->irq) {
-                        printk(KERN_WARNING "Elsa: No IRQ for PCI card found\n");
+                cs->subtyp = ELSA_QS1000PCI;
+                cs->irq = dev_qs1000->irq;
+                cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
+                cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
+        } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+                PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
+                if (pci_enable_device(dev_qs3000))
                         return(0);
-                }
+                cs->subtyp = ELSA_QS3000PCI;
+                cs->irq = dev_qs3000->irq;
+                cs->hw.elsa.cfg = pci_resource_start(dev_qs3000, 1);
+                cs->hw.elsa.base = pci_resource_start(dev_qs3000, 3);
+        } else {
+                printk(KERN_WARNING "Elsa: No PCI card found\n");
+                return(0);
+        }
+        if (!cs->irq) {
+                printk(KERN_WARNING "Elsa: No IRQ for PCI card found\n");
+                return(0);
+        }
+
+        if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
+                printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found\n");
+                return(0);
+        }
+        if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
+                printk(KERN_WARNING "Elsa: You may have a wrong PCI bios\n");
+                printk(KERN_WARNING "Elsa: If your system hangs now, read\n");
+                printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax\n");
+        }
+        cs->hw.elsa.ale  = cs->hw.elsa.base;
+        cs->hw.elsa.isac = cs->hw.elsa.base +1;
+        cs->hw.elsa.hscx = cs->hw.elsa.base +1; 
+        test_and_set_bit(HW_IPAC, &cs->HW_Flags);
+        cs->hw.elsa.timer = 0;
+        cs->hw.elsa.trig  = 0;
+        cs->irq_flags |= IRQF_SHARED;
+        printk(KERN_INFO
+               "Elsa: %s defined at %#lx/0x%x IRQ %d\n",
+               Elsa_Types[cs->subtyp],
+               cs->hw.elsa.base,
+               cs->hw.elsa.cfg,
+               cs->irq);
+
+        return (1);
+}
 
-                if (!(cs->hw.elsa.base && cs->hw.elsa.cfg)) {
-                        printk(KERN_WARNING "Elsa: No IO-Adr for PCI card found\n");
-                        return(0);
-                }
-                if ((cs->hw.elsa.cfg & 0xff) || (cs->hw.elsa.base & 0xf)) {
-                        printk(KERN_WARNING "Elsa: You may have a wrong PCI bios\n");
-                        printk(KERN_WARNING "Elsa: If your system hangs now, read\n");
-                        printk(KERN_WARNING "Elsa: Documentation/isdn/README.HiSax\n");
-                }
-                cs->hw.elsa.ale  = cs->hw.elsa.base;
-                cs->hw.elsa.isac = cs->hw.elsa.base +1;
-                cs->hw.elsa.hscx = cs->hw.elsa.base +1; 
-                test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-                cs->hw.elsa.timer = 0;
-                cs->hw.elsa.trig  = 0;
-                cs->irq_flags |= IRQF_SHARED;
-                printk(KERN_INFO
-                       "Elsa: %s defined at %#lx/0x%x IRQ %d\n",
-                       Elsa_Types[cs->subtyp],
-                       cs->hw.elsa.base,
-                       cs->hw.elsa.cfg,
-                       cs->irq);
 #else
-                printk(KERN_WARNING "Elsa: Elsa PCI and NO_PCI_BIOS\n");
-                printk(KERN_WARNING "Elsa: unable to config Elsa PCI\n");
-                return (0);
+
+static int __devinit
+setup_elsa_pci(struct IsdnCard *card)
+{
+        return (1);
+}
 #endif /* CONFIG_PCI */
-        } else 
-                return (0);
+
+static int __devinit
+setup_elsa_common(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        u_char val;
+        int bytecnt;
 
         switch (cs->subtyp) {
                 case ELSA_PC:
@@ -1104,8 +1130,7 @@ setup_elsa(struct IsdnCard *card)
            here, it would fail. */
         if (cs->typ != ISDN_CTYPE_ELSA_PCMCIA && !request_region(cs->hw.elsa.base, bytecnt, "elsa isdn")) {
                 printk(KERN_WARNING
-                       "HiSax: %s config port %#lx-%#lx already in use\n",
-                       CardType[card->typ],
+                       "HiSax: ELSA config port %#lx-%#lx already in use\n",
                        cs->hw.elsa.base,
                        cs->hw.elsa.base + bytecnt);
                 return (0);
@@ -1113,8 +1138,7 @@ setup_elsa(struct IsdnCard *card)
         if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI)) {
                 if (!request_region(cs->hw.elsa.cfg, 0x80, "elsa isdn pci")) {
                         printk(KERN_WARNING
-                               "HiSax: %s pci port %x-%x already in use\n",
-                                CardType[card->typ],
+                               "HiSax: ELSA pci port %x-%x already in use\n",
                                 cs->hw.elsa.cfg,
                                 cs->hw.elsa.cfg + 0x80);
                         release_region(cs->hw.elsa.base, bytecnt);
@@ -1186,3 +1210,41 @@ setup_elsa(struct IsdnCard *card)
         }
         return (1);
 }
+
+int __devinit
+setup_elsa(struct IsdnCard *card)
+{
+        int rc;
+        struct IsdnCardState *cs = card->cs;
+        char tmp[64];
+
+        strcpy(tmp, Elsa_revision);
+        printk(KERN_INFO "HiSax: Elsa driver Rev. %s\n", HiSax_getrev(tmp));
+        cs->hw.elsa.ctrl_reg = 0;
+        cs->hw.elsa.status = 0;
+        cs->hw.elsa.MFlag = 0;
+        cs->subtyp = 0;
+
+        if (cs->typ == ISDN_CTYPE_ELSA) {
+                rc = setup_elsa_isa(card);
+                if (!rc)
+                        return (0);
+
+        } else if (cs->typ == ISDN_CTYPE_ELSA_PNP) {
+                rc = setup_elsa_isapnp(card);
+                if (!rc)
+                        return (0);
+
+        } else if (cs->typ == ISDN_CTYPE_ELSA_PCMCIA)
+                setup_elsa_pcmcia(card);
+
+        else if (cs->typ == ISDN_CTYPE_ELSA_PCI) {
+                rc = setup_elsa_pci(card);
+                if (!rc)
+                        return (0);
+
+        } else 
+                return (0);
+
+        return setup_elsa_common(card);
+}
diff --git a/drivers/isdn/hisax/sedlbauer.c b/drivers/isdn/hisax/sedlbauer.c
index ad06f3cc60..03dfc32166 100644
--- a/drivers/isdn/hisax/sedlbauer.c
+++ b/drivers/isdn/hisax/sedlbauer.c
@@ -518,8 +518,6 @@ Sedl_card_msg(struct IsdnCardState *cs, int mt, void *arg)
         return(0);
 }
 
-static struct pci_dev *dev_sedl __devinitdata = NULL;
-
 #ifdef __ISAPNP__
 static struct isapnp_device_id sedl_ids[] __devinitdata = {
         { ISAPNP_VENDOR('S', 'A', 'G'), ISAPNP_FUNCTION(0x01),
@@ -533,15 +531,158 @@ static struct isapnp_device_id sedl_ids[] __devinitdata = {
 
 static struct isapnp_device_id *ipid __devinitdata = &sedl_ids[0];
 static struct pnp_card *pnp_c __devinitdata = NULL;
-#endif
+
+static int __devinit
+setup_sedlbauer_isapnp(struct IsdnCard *card, int *bytecnt)
+{
+        struct IsdnCardState *cs = card->cs;
+        struct pnp_dev *pnp_d;
+
+        if (!isapnp_present())
+                return -1;
+
+        while(ipid->card_vendor) {
+                if ((pnp_c = pnp_find_card(ipid->card_vendor,
+                        ipid->card_device, pnp_c))) {
+                        pnp_d = NULL;
+                        if ((pnp_d = pnp_find_dev(pnp_c,
+                                ipid->vendor, ipid->function, pnp_d))) {
+                                int err;
+
+                                printk(KERN_INFO "HiSax: %s detected\n",
+                                        (char *)ipid->driver_data);
+                                pnp_disable_dev(pnp_d);
+                                err = pnp_activate_dev(pnp_d);
+                                if (err<0) {
+                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
+                                                __FUNCTION__, err);
+                                        return(0);
+                                }
+                                card->para[1] = pnp_port_start(pnp_d, 0);
+                                card->para[0] = pnp_irq(pnp_d, 0);
+
+                                if (!card->para[0] || !card->para[1]) {
+                                        printk(KERN_ERR "Sedlbauer PnP:some resources are missing %ld/%lx\n",
+                                                card->para[0], card->para[1]);
+                                        pnp_disable_dev(pnp_d);
+                                        return(0);
+                                }
+                                cs->hw.sedl.cfg_reg = card->para[1];
+                                cs->irq = card->para[0];
+                                if (ipid->function == ISAPNP_FUNCTION(0x2)) {
+                                        cs->subtyp = SEDL_SPEED_FAX;
+                                        cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
+                                        *bytecnt = 16;
+                                } else {
+                                        cs->subtyp = SEDL_SPEED_CARD_WIN;
+                                        cs->hw.sedl.chip = SEDL_CHIP_TEST;
+                                }
+
+                                return (1);
+                        } else {
+                                printk(KERN_ERR "Sedlbauer PnP: PnP error card found, no device\n");
+                                return(0);
+                        }
+                }
+                ipid++;
+                pnp_c = NULL;
+        } 
+
+        printk(KERN_INFO "Sedlbauer PnP: no ISAPnP card found\n");
+        return -1;
+}
+#else
+
+static int __devinit
+setup_sedlbauer_isapnp(struct IsdnCard *card, int *bytecnt)
+{
+        return -1;
+}
+#endif /* __ISAPNP__ */
+
+#ifdef CONFIG_PCI
+static struct pci_dev *dev_sedl __devinitdata = NULL;
+
+static int __devinit
+setup_sedlbauer_pci(struct IsdnCard *card)
+{
+        struct IsdnCardState *cs = card->cs;
+        u16 sub_vendor_id, sub_id;
+
+        if ((dev_sedl = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                        PCI_DEVICE_ID_TIGERJET_100, dev_sedl))) {
+                if (pci_enable_device(dev_sedl))
+                        return(0);
+                cs->irq = dev_sedl->irq;
+                if (!cs->irq) {
+                        printk(KERN_WARNING "Sedlbauer: No IRQ for PCI card found\n");
+                        return(0);
+                }
+                cs->hw.sedl.cfg_reg = pci_resource_start(dev_sedl, 0);
+        } else {
+                printk(KERN_WARNING "Sedlbauer: No PCI card found\n");
+                return(0);
+        }
+        cs->irq_flags |= IRQF_SHARED;
+        cs->hw.sedl.bus = SEDL_BUS_PCI;
+        sub_vendor_id = dev_sedl->subsystem_vendor;
+        sub_id = dev_sedl->subsystem_device;
+        printk(KERN_INFO "Sedlbauer: PCI subvendor:%x subid %x\n",
+                sub_vendor_id, sub_id);
+        printk(KERN_INFO "Sedlbauer: PCI base adr %#x\n",
+                cs->hw.sedl.cfg_reg);
+        if (sub_id != PCI_SUB_ID_SEDLBAUER) {
+                printk(KERN_ERR "Sedlbauer: unknown sub id %#x\n", sub_id);
+                return(0);
+        }
+        if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PYRAMID) {
+                cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
+                cs->subtyp = SEDL_SPEEDFAX_PYRAMID;
+        } else if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PCI) {
+                cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
+                cs->subtyp = SEDL_SPEEDFAX_PCI;
+        } else if (sub_vendor_id == PCI_SUBVENDOR_HST_SAPHIR3) {
+                cs->hw.sedl.chip = SEDL_CHIP_IPAC;
+                cs->subtyp = HST_SAPHIR3;
+        } else if (sub_vendor_id == PCI_SUBVENDOR_SEDLBAUER_PCI) {
+                cs->hw.sedl.chip = SEDL_CHIP_IPAC;
+                cs->subtyp = SEDL_SPEED_PCI;
+        } else {
+                printk(KERN_ERR "Sedlbauer: unknown sub vendor id %#x\n",
+                        sub_vendor_id);
+                return(0);
+        }
+
+        cs->hw.sedl.reset_on = SEDL_ISAR_PCI_ISAR_RESET_ON;
+        cs->hw.sedl.reset_off = SEDL_ISAR_PCI_ISAR_RESET_OFF;
+        byteout(cs->hw.sedl.cfg_reg, 0xff);
+        byteout(cs->hw.sedl.cfg_reg, 0x00);
+        byteout(cs->hw.sedl.cfg_reg+ 2, 0xdd);
+        byteout(cs->hw.sedl.cfg_reg+ 5, 0); /* disable all IRQ */
+        byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
+        mdelay(2);
+        byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
+        mdelay(10);
+
+        return (1);
+}
+
+#else
+
+static int __devinit
+setup_sedlbauer_pci(struct IsdnCard *card)
+{
+        return (1);
+}
+
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_sedlbauer(struct IsdnCard *card)
 {
-        int bytecnt, ver, val;
+        int bytecnt = 8, ver, val, rc;
         struct IsdnCardState *cs = card->cs;
         char tmp[64];
-        u16 sub_vendor_id, sub_id;
 
         strcpy(tmp, Sedlbauer_revision);
         printk(KERN_INFO "HiSax: Sedlbauer driver Rev. %s\n", HiSax_getrev(tmp));
@@ -569,124 +710,21 @@ setup_sedlbauer(struct IsdnCard *card)
                         bytecnt = 16;
                 }
         } else {
-#ifdef __ISAPNP__
-                if (isapnp_present()) {
-                        struct pnp_dev *pnp_d;
-                        while(ipid->card_vendor) {
-                                if ((pnp_c = pnp_find_card(ipid->card_vendor,
-                                        ipid->card_device, pnp_c))) {
-                                        pnp_d = NULL;
-                                        if ((pnp_d = pnp_find_dev(pnp_c,
-                                                ipid->vendor, ipid->function, pnp_d))) {
-                                                int err;
-
-                                                printk(KERN_INFO "HiSax: %s detected\n",
-                                                        (char *)ipid->driver_data);
-                                                pnp_disable_dev(pnp_d);
-                                                err = pnp_activate_dev(pnp_d);
-                                                if (err<0) {
-                                                        printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-                                                                __FUNCTION__, err);
-                                                        return(0);
-                                                }
-                                                card->para[1] = pnp_port_start(pnp_d, 0);
-                                                card->para[0] = pnp_irq(pnp_d, 0);
-
-                                                if (!card->para[0] || !card->para[1]) {
-                                                        printk(KERN_ERR "Sedlbauer PnP:some resources are missing %ld/%lx\n",
-                                                                card->para[0], card->para[1]);
-                                                        pnp_disable_dev(pnp_d);
-                                                        return(0);
-                                                }
-                                                cs->hw.sedl.cfg_reg = card->para[1];
-                                                cs->irq = card->para[0];
-                                                if (ipid->function == ISAPNP_FUNCTION(0x2)) {
-                                                        cs->subtyp = SEDL_SPEED_FAX;
-                                                        cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
-                                                        bytecnt = 16;
-                                                } else {
-                                                        cs->subtyp = SEDL_SPEED_CARD_WIN;
-                                                        cs->hw.sedl.chip = SEDL_CHIP_TEST;
-                                                }
-                                                goto ready;
-                                        } else {
-                                                printk(KERN_ERR "Sedlbauer PnP: PnP error card found, no device\n");
-                                                return(0);
-                                        }
-                                }
-                                ipid++;
-                                pnp_c = NULL;
-                        } 
-                        if (!ipid->card_vendor) {
-                                printk(KERN_INFO "Sedlbauer PnP: no ISAPnP card found\n");
-                        }
-                }
-#endif
-/* Probe for Sedlbauer speed pci */
-#ifdef CONFIG_PCI
-                if ((dev_sedl = pci_find_device(PCI_VENDOR_ID_TIGERJET,
-                                PCI_DEVICE_ID_TIGERJET_100, dev_sedl))) {
-                        if (pci_enable_device(dev_sedl))
-                                return(0);
-                        cs->irq = dev_sedl->irq;
-                        if (!cs->irq) {
-                                printk(KERN_WARNING "Sedlbauer: No IRQ for PCI card found\n");
-                                return(0);
-                        }
-                        cs->hw.sedl.cfg_reg = pci_resource_start(dev_sedl, 0);
-                } else {
-                        printk(KERN_WARNING "Sedlbauer: No PCI card found\n");
-                        return(0);
-                }
-                cs->irq_flags |= IRQF_SHARED;
-                cs->hw.sedl.bus = SEDL_BUS_PCI;
-                sub_vendor_id = dev_sedl->subsystem_vendor;
-                sub_id = dev_sedl->subsystem_device;
-                printk(KERN_INFO "Sedlbauer: PCI subvendor:%x subid %x\n",
-                        sub_vendor_id, sub_id);
-                printk(KERN_INFO "Sedlbauer: PCI base adr %#x\n",
-                        cs->hw.sedl.cfg_reg);
-                if (sub_id != PCI_SUB_ID_SEDLBAUER) {
-                        printk(KERN_ERR "Sedlbauer: unknown sub id %#x\n", sub_id);
-                        return(0);
-                }
-                if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PYRAMID) {
-                        cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
-                        cs->subtyp = SEDL_SPEEDFAX_PYRAMID;
-                } else if (sub_vendor_id == PCI_SUBVENDOR_SPEEDFAX_PCI) {
-                        cs->hw.sedl.chip = SEDL_CHIP_ISAC_ISAR;
-                        cs->subtyp = SEDL_SPEEDFAX_PCI;
-                } else if (sub_vendor_id == PCI_SUBVENDOR_HST_SAPHIR3) {
-                        cs->hw.sedl.chip = SEDL_CHIP_IPAC;
-                        cs->subtyp = HST_SAPHIR3;
-                } else if (sub_vendor_id == PCI_SUBVENDOR_SEDLBAUER_PCI) {
-                        cs->hw.sedl.chip = SEDL_CHIP_IPAC;
-                        cs->subtyp = SEDL_SPEED_PCI;
-                } else {
-                        printk(KERN_ERR "Sedlbauer: unknown sub vendor id %#x\n",
-                                sub_vendor_id);
-                        return(0);
-                }
+                rc = setup_sedlbauer_isapnp(card, &bytecnt);
+                if (!rc)
+                        return (0);
+                if (rc > 0)
+                        goto ready;
+
+                /* Probe for Sedlbauer speed pci */
+                rc = setup_sedlbauer_pci(card);
+                if (!rc)
+                        return (0);
+
                 bytecnt = 256;
-                cs->hw.sedl.reset_on = SEDL_ISAR_PCI_ISAR_RESET_ON;
-                cs->hw.sedl.reset_off = SEDL_ISAR_PCI_ISAR_RESET_OFF;
-                byteout(cs->hw.sedl.cfg_reg, 0xff);
-                byteout(cs->hw.sedl.cfg_reg, 0x00);
-                byteout(cs->hw.sedl.cfg_reg+ 2, 0xdd);
-                byteout(cs->hw.sedl.cfg_reg+ 5, 0); /* disable all IRQ */
-                byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
-                mdelay(2);
-                byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
-                mdelay(10);
-#else
-                printk(KERN_WARNING "Sedlbauer: NO_PCI_BIOS\n");
-                return (0);
-#endif /* CONFIG_PCI */
         }       
 
-#ifdef __ISAPNP__
 ready:  
-#endif
 
         /* In case of the sedlbauer pcmcia card, this region is in use,
          * reserved for us by the card manager. So we do not check it
diff --git a/drivers/isdn/hisax/telespci.c b/drivers/isdn/hisax/telespci.c
index d09f6d033f..4393003ae1 100644
--- a/drivers/isdn/hisax/telespci.c
+++ b/drivers/isdn/hisax/telespci.c
@@ -295,11 +295,12 @@ setup_telespci(struct IsdnCard *card)
 #ifdef __BIG_ENDIAN
 #error "not running on big endian machines now"
 #endif
+
         strcpy(tmp, telespci_revision);
         printk(KERN_INFO "HiSax: Teles/PCI driver Rev. %s\n", HiSax_getrev(tmp));
         if (cs->typ != ISDN_CTYPE_TELESPCI)
                 return (0);
-#ifdef CONFIG_PCI
+
         if ((dev_tel = pci_find_device (PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, dev_tel))) {
                 if (pci_enable_device(dev_tel))
                         return(0);
@@ -317,11 +318,6 @@ setup_telespci(struct IsdnCard *card)
                 printk(KERN_WARNING "TelesPCI: No PCI card found\n");
                 return(0);
         }
-#else
-        printk(KERN_WARNING "HiSax: Teles/PCI and NO_PCI_BIOS\n");
-        printk(KERN_WARNING "HiSax: Teles/PCI unable to config\n");
-        return (0);
-#endif /* CONFIG_PCI */
 
         /* Initialize Zoran PCI controller */
         writel(0x00000000, cs->hw.teles0.membase + 0x28);
diff --git a/drivers/isdn/hisax/w6692.c b/drivers/isdn/hisax/w6692.c
index 3aeceaf976..39129b94f8 100644
--- a/drivers/isdn/hisax/w6692.c
+++ b/drivers/isdn/hisax/w6692.c
@@ -1009,7 +1009,7 @@ setup_w6692(struct IsdnCard *card)
         printk(KERN_INFO "HiSax: W6692 driver Rev. %s\n", HiSax_getrev(tmp));
         if (cs->typ != ISDN_CTYPE_W6692)
                 return (0);
-#ifdef CONFIG_PCI
+
         while (id_list[id_idx].vendor_id) {
                 dev_w6692 = pci_find_device(id_list[id_idx].vendor_id,
                                             id_list[id_idx].device_id,
@@ -1061,11 +1061,6 @@ setup_w6692(struct IsdnCard *card)
                        cs->hw.w6692.iobase + 255);
                 return (0);
         }
-#else
-        printk(KERN_WARNING "HiSax: W6692 and NO_PCI_BIOS\n");
-        printk(KERN_WARNING "HiSax: W6692 unable to config\n");
-        return (0);
-#endif                          /* CONFIG_PCI */
 
         printk(KERN_INFO
                "HiSax: %s config irq:%d I/O:%x\n",
diff --git a/drivers/isdn/hysdn/hysdn_init.c b/drivers/isdn/hysdn/hysdn_init.c
index 9e01748a17..b7cc5c2f08 100644
--- a/drivers/isdn/hysdn/hysdn_init.c
+++ b/drivers/isdn/hysdn/hysdn_init.c
@@ -20,10 +20,15 @@
 #include "hysdn_defs.h"
 
 static struct pci_device_id hysdn_pci_tbl[] = {
-        {PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_METRO},
-        {PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2},
-        {PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_ERGO},
-        {PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO},
+        { PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
+          PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_METRO, 0, 0, BD_METRO },
+        { PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
+          PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2, 0, 0, BD_CHAMP2 },
+        { PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
+          PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_ERGO, 0, 0, BD_ERGO },
+        { PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
+          PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO, 0, 0, BD_ERGO },
+
         { }                             /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(pci, hysdn_pci_tbl);
@@ -34,128 +39,7 @@ MODULE_LICENSE("GPL");
 static char *hysdn_init_revision = "$Revision: 1.6.6.6 $";
 static int cardmax;             /* number of found cards */
 hysdn_card *card_root = NULL;   /* pointer to first card */
-
-/**********************************************/
-/* table assigning PCI-sub ids to board types */
-/* the last entry contains all 0              */
-/**********************************************/
-static struct {
-        unsigned short subid;           /* PCI sub id */
-        unsigned char cardtyp;          /* card type assigned */
-} pci_subid_map[] = {
-
-        {
-                PCI_SUBDEVICE_ID_HYPERCOPE_METRO, BD_METRO
-        },
-        {
-                PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2, BD_CHAMP2
-        },
-        {
-                PCI_SUBDEVICE_ID_HYPERCOPE_ERGO, BD_ERGO
-        },
-        {
-                PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO, BD_ERGO
-        },
-        {
-                0, 0
-        }                       /* terminating entry */
-};
-
-
-/*********************************************************************/
-/* search_cards searches for available cards in the pci config data. */
-/* If a card is found, the card structure is allocated and the cards */
-/* ressources are reserved. cardmax is incremented.                  */
-/*********************************************************************/
-static void
-search_cards(void)
-{
-        struct pci_dev *akt_pcidev = NULL;
-        hysdn_card *card, *card_last;
-        int i;
-
-        card_root = NULL;
-        card_last = NULL;
-        while ((akt_pcidev = pci_find_device(PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
-                                             akt_pcidev)) != NULL) {
-                if (pci_enable_device(akt_pcidev))
-                        continue;
-
-                if (!(card = kzalloc(sizeof(hysdn_card), GFP_KERNEL))) {
-                        printk(KERN_ERR "HYSDN: unable to alloc device mem \n");
-                        return;
-                }
-                card->myid = cardmax;   /* set own id */
-                card->bus = akt_pcidev->bus->number;
-                card->devfn = akt_pcidev->devfn;        /* slot + function */
-                card->subsysid = akt_pcidev->subsystem_device;
-                card->irq = akt_pcidev->irq;
-                card->iobase = pci_resource_start(akt_pcidev, PCI_REG_PLX_IO_BASE);
-                card->plxbase = pci_resource_start(akt_pcidev, PCI_REG_PLX_MEM_BASE);
-                card->membase = pci_resource_start(akt_pcidev, PCI_REG_MEMORY_BASE);
-                card->brdtype = BD_NONE;        /* unknown */
-                card->debug_flags = DEF_DEB_FLAGS;      /* set default debug */
-                card->faxchans = 0;     /* default no fax channels */
-                card->bchans = 2;       /* and 2 b-channels */
-                for (i = 0; pci_subid_map[i].subid; i++)
-                        if (pci_subid_map[i].subid == card->subsysid) {
-                                card->brdtype = pci_subid_map[i].cardtyp;
-                                break;
-                        }
-                if (card->brdtype != BD_NONE) {
-                        if (ergo_inithardware(card)) {
-                                printk(KERN_WARNING "HYSDN: card at io 0x%04x already in use\n", card->iobase);
-                                kfree(card);
-                                continue;
-                        }
-                } else {
-                        printk(KERN_WARNING "HYSDN: unknown card id 0x%04x\n", card->subsysid);
-                        kfree(card);    /* release mem */
-                        continue;
-                }
-                cardmax++;
-                card->next = NULL;      /*end of chain */
-                if (card_last)
-                        card_last->next = card;         /* pointer to next card */
-                else
-                        card_root = card;
-                card_last = card;       /* new chain end */
-        }                       /* device found */
-}                               /* search_cards */
-
-/************************************************************************************/
-/* free_resources frees the acquired PCI resources and returns the allocated memory */
-/************************************************************************************/
-static void
-free_resources(void)
-{
-        hysdn_card *card;
-
-        while (card_root) {
-                card = card_root;
-                if (card->releasehardware)
-                        card->releasehardware(card);    /* free all hardware resources */
-                card_root = card_root->next;    /* remove card from chain */
-                kfree(card);    /* return mem */
-
-        }                       /* while card_root */
-}                               /* free_resources */
-
-/**************************************************************************/
-/* stop_cards disables (hardware resets) all cards and disables interrupt */
-/**************************************************************************/
-static void
-stop_cards(void)
-{
-        hysdn_card *card;
-
-        card = card_root;       /* first in chain */
-        while (card) {
-                if (card->stopcard)
-                        card->stopcard(card);
-                card = card->next;      /* remove card from chain */
-        }                       /* while card */
-}                               /* stop_cards */
+static hysdn_card *card_last = NULL;    /* pointer to first card */
 
 
 /****************************************************************************/
@@ -191,31 +75,138 @@ hysdn_getrev(const char *revision)
 /* and the module is added to the list in /proc/modules, otherwise an error */
 /* is assumed and the module will not be kept in memory.                    */
 /****************************************************************************/
+
+static int __devinit hysdn_pci_init_one(struct pci_dev *akt_pcidev,
+                                        const struct pci_device_id *ent)
+{
+        hysdn_card *card;
+        int rc;
+
+        rc = pci_enable_device(akt_pcidev);
+        if (rc)
+                return rc;
+
+        if (!(card = kzalloc(sizeof(hysdn_card), GFP_KERNEL))) {
+                printk(KERN_ERR "HYSDN: unable to alloc device mem \n");
+                rc = -ENOMEM;
+                goto err_out;
+        }
+        card->myid = cardmax;   /* set own id */
+        card->bus = akt_pcidev->bus->number;
+        card->devfn = akt_pcidev->devfn;        /* slot + function */
+        card->subsysid = akt_pcidev->subsystem_device;
+        card->irq = akt_pcidev->irq;
+        card->iobase = pci_resource_start(akt_pcidev, PCI_REG_PLX_IO_BASE);
+        card->plxbase = pci_resource_start(akt_pcidev, PCI_REG_PLX_MEM_BASE);
+        card->membase = pci_resource_start(akt_pcidev, PCI_REG_MEMORY_BASE);
+        card->brdtype = BD_NONE;        /* unknown */
+        card->debug_flags = DEF_DEB_FLAGS;      /* set default debug */
+        card->faxchans = 0;     /* default no fax channels */
+        card->bchans = 2;       /* and 2 b-channels */
+        card->brdtype = ent->driver_data;
+
+        if (ergo_inithardware(card)) {
+                printk(KERN_WARNING "HYSDN: card at io 0x%04x already in use\n", card->iobase);
+                rc = -EBUSY;
+                goto err_out_card;
+        }
+
+        cardmax++;
+        card->next = NULL;      /*end of chain */
+        if (card_last)
+                card_last->next = card;         /* pointer to next card */
+        else
+                card_root = card;
+        card_last = card;       /* new chain end */
+
+        pci_set_drvdata(akt_pcidev, card);
+        return 0;
+
+err_out_card:
+        kfree(card);
+err_out:
+        pci_disable_device(akt_pcidev);
+        return rc;
+}
+
+static void __devexit hysdn_pci_remove_one(struct pci_dev *akt_pcidev)
+{
+        hysdn_card *card = pci_get_drvdata(akt_pcidev);
+
+        pci_set_drvdata(akt_pcidev, NULL);
+
+        if (card->stopcard)
+                card->stopcard(card);
+
+#ifdef CONFIG_HYSDN_CAPI
+        hycapi_capi_release(card);
+#endif
+
+        if (card->releasehardware)
+                card->releasehardware(card);   /* free all hardware resources */
+
+        if (card == card_root) {
+                card_root = card_root->next;
+                if (!card_root)
+                        card_last = NULL;
+        } else {
+                hysdn_card *tmp = card_root;
+                while (tmp) {
+                        if (tmp->next == card)
+                                tmp->next = card->next;
+                        card_last = tmp;
+                        tmp = tmp->next;
+                }
+        }
+
+        kfree(card);
+        pci_disable_device(akt_pcidev);
+}
+
+static struct pci_driver hysdn_pci_driver = {
+        .name           = "hysdn",
+        .id_table       = hysdn_pci_tbl,
+        .probe          = hysdn_pci_init_one,
+        .remove         = __devexit_p(hysdn_pci_remove_one),
+};
+
+static int hysdn_have_procfs;
+
 static int __init
 hysdn_init(void)
 {
         char tmp[50];
+        int rc;
 
         strcpy(tmp, hysdn_init_revision);
         printk(KERN_NOTICE "HYSDN: module Rev: %s loaded\n", hysdn_getrev(tmp));
         strcpy(tmp, hysdn_net_revision);
         printk(KERN_NOTICE "HYSDN: network interface Rev: %s \n", hysdn_getrev(tmp));
-        search_cards();
+
+        rc = pci_register_driver(&hysdn_pci_driver);
+        if (rc)
+                return rc;
+
         printk(KERN_INFO "HYSDN: %d card(s) found.\n", cardmax);
 
-        if (hysdn_procconf_init()) {
-                free_resources();       /* proc file_sys not created */
-                return (-1);
-        }
+        if (!hysdn_procconf_init())
+                hysdn_have_procfs = 1;
+
 #ifdef CONFIG_HYSDN_CAPI
         if(cardmax > 0) {
                 if(hycapi_init()) {
                         printk(KERN_ERR "HYCAPI: init failed\n");
-                        return(-1);
+
+                        if (hysdn_have_procfs)
+                                hysdn_procconf_release();
+
+                        pci_unregister_driver(&hysdn_pci_driver);
+                        return -ESPIPE;
                 }
         }
 #endif /* CONFIG_HYSDN_CAPI */
-        return (0);             /* no error */
+
+        return 0;               /* no error */
 }                               /* init_module */
 
 
@@ -230,20 +221,15 @@ hysdn_init(void)
 static void __exit
 hysdn_exit(void)
 {
+        if (hysdn_have_procfs)
+                hysdn_procconf_release();
+
+        pci_unregister_driver(&hysdn_pci_driver);
+
 #ifdef CONFIG_HYSDN_CAPI
-        hysdn_card *card;
-#endif /* CONFIG_HYSDN_CAPI */
-        stop_cards();
-#ifdef CONFIG_HYSDN_CAPI
-        card = card_root;       /* first in chain */
-        while (card) {
-                hycapi_capi_release(card);
-                card = card->next;      /* remove card from chain */
-        }                       /* while card */
         hycapi_cleanup();
 #endif /* CONFIG_HYSDN_CAPI */
-        hysdn_procconf_release();
-        free_resources();
+
         printk(KERN_NOTICE "HYSDN: module unloaded\n");
 }                               /* cleanup_module */
 
diff --git a/drivers/kvm/Kconfig b/drivers/kvm/Kconfig
index 0a419a0de6..8749fa4ffc 100644
--- a/drivers/kvm/Kconfig
+++ b/drivers/kvm/Kconfig
@@ -17,6 +17,7 @@ if VIRTUALIZATION
 config KVM
         tristate "Kernel-based Virtual Machine (KVM) support"
         depends on X86 && EXPERIMENTAL
+        select PREEMPT_NOTIFIERS
         select ANON_INODES
         ---help---
           Support hosting fully virtualized guest machines using hardware
diff --git a/drivers/kvm/Makefile b/drivers/kvm/Makefile
index c0a789fa9d..e5a8f4d3e9 100644
--- a/drivers/kvm/Makefile
+++ b/drivers/kvm/Makefile
@@ -2,7 +2,7 @@
 # Makefile for Kernel-based Virtual Machine module
 #
 
-kvm-objs := kvm_main.o mmu.o x86_emulate.o
+kvm-objs := kvm_main.o mmu.o x86_emulate.o i8259.o irq.o lapic.o ioapic.o
 obj-$(CONFIG_KVM) += kvm.o
 kvm-intel-objs = vmx.o
 obj-$(CONFIG_KVM_INTEL) += kvm-intel.o
diff --git a/drivers/kvm/i8259.c b/drivers/kvm/i8259.c
new file mode 100644
index 0000000000..a679157bc5
--- /dev/null
+++ b/drivers/kvm/i8259.c
@@ -0,0 +1,450 @@
+/*
+ * 8259 interrupt controller emulation
+ *
+ * Copyright (c) 2003-2004 Fabrice Bellard
+ * Copyright (c) 2007 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * Authors:
+ *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
+ *   Port from Qemu.
+ */
+#include <linux/mm.h>
+#include "irq.h"
+
+/*
+ * set irq level. If an edge is detected, then the IRR is set to 1
+ */
+static inline void pic_set_irq1(struct kvm_kpic_state *s, int irq, int level)
+{
+        int mask;
+        mask = 1 << irq;
+        if (s->elcr & mask)     /* level triggered */
+                if (level) {
+                        s->irr |= mask;
+                        s->last_irr |= mask;
+                } else {
+                        s->irr &= ~mask;
+                        s->last_irr &= ~mask;
+                }
+        else    /* edge triggered */
+                if (level) {
+                        if ((s->last_irr & mask) == 0)
+                                s->irr |= mask;
+                        s->last_irr |= mask;
+                } else
+                        s->last_irr &= ~mask;
+}
+
+/*
+ * return the highest priority found in mask (highest = smallest
+ * number). Return 8 if no irq
+ */
+static inline int get_priority(struct kvm_kpic_state *s, int mask)
+{
+        int priority;
+        if (mask == 0)
+                return 8;
+        priority = 0;
+        while ((mask & (1 << ((priority + s->priority_add) & 7))) == 0)
+                priority++;
+        return priority;
+}
+
+/*
+ * return the pic wanted interrupt. return -1 if none
+ */
+static int pic_get_irq(struct kvm_kpic_state *s)
+{
+        int mask, cur_priority, priority;
+
+        mask = s->irr & ~s->imr;
+        priority = get_priority(s, mask);
+        if (priority == 8)
+                return -1;
+        /*
+         * compute current priority. If special fully nested mode on the
+         * master, the IRQ coming from the slave is not taken into account
+         * for the priority computation.
+         */
+        mask = s->isr;
+        if (s->special_fully_nested_mode && s == &s->pics_state->pics[0])
+                mask &= ~(1 << 2);
+        cur_priority = get_priority(s, mask);
+        if (priority < cur_priority)
+                /*
+                 * higher priority found: an irq should be generated
+                 */
+                return (priority + s->priority_add) & 7;
+        else
+                return -1;
+}
+
+/*
+ * raise irq to CPU if necessary. must be called every time the active
+ * irq may change
+ */
+static void pic_update_irq(struct kvm_pic *s)
+{
+        int irq2, irq;
+
+        irq2 = pic_get_irq(&s->pics[1]);
+        if (irq2 >= 0) {
+                /*
+                 * if irq request by slave pic, signal master PIC
+                 */
+                pic_set_irq1(&s->pics[0], 2, 1);
+                pic_set_irq1(&s->pics[0], 2, 0);
+        }
+        irq = pic_get_irq(&s->pics[0]);
+        if (irq >= 0)
+                s->irq_request(s->irq_request_opaque, 1);
+        else
+                s->irq_request(s->irq_request_opaque, 0);
+}
+
+void kvm_pic_update_irq(struct kvm_pic *s)
+{
+        pic_update_irq(s);
+}
+
+void kvm_pic_set_irq(void *opaque, int irq, int level)
+{
+        struct kvm_pic *s = opaque;
+
+        pic_set_irq1(&s->pics[irq >> 3], irq & 7, level);
+        pic_update_irq(s);
+}
+
+/*
+ * acknowledge interrupt 'irq'
+ */
+static inline void pic_intack(struct kvm_kpic_state *s, int irq)
+{
+        if (s->auto_eoi) {
+                if (s->rotate_on_auto_eoi)
+                        s->priority_add = (irq + 1) & 7;
+        } else
+                s->isr |= (1 << irq);
+        /*
+         * We don't clear a level sensitive interrupt here
+         */
+        if (!(s->elcr & (1 << irq)))
+                s->irr &= ~(1 << irq);
+}
+
+int kvm_pic_read_irq(struct kvm_pic *s)
+{
+        int irq, irq2, intno;
+
+        irq = pic_get_irq(&s->pics[0]);
+        if (irq >= 0) {
+                pic_intack(&s->pics[0], irq);
+                if (irq == 2) {
+                        irq2 = pic_get_irq(&s->pics[1]);
+                        if (irq2 >= 0)
+                                pic_intack(&s->pics[1], irq2);
+                        else
+                                /*
+                                 * spurious IRQ on slave controller
+                                 */
+                                irq2 = 7;
+                        intno = s->pics[1].irq_base + irq2;
+                        irq = irq2 + 8;
+                } else
+                        intno = s->pics[0].irq_base + irq;
+        } else {
+                /*
+                 * spurious IRQ on host controller
+                 */
+                irq = 7;
+                intno = s->pics[0].irq_base + irq;
+        }
+        pic_update_irq(s);
+
+        return intno;
+}
+
+static void pic_reset(void *opaque)
+{
+        struct kvm_kpic_state *s = opaque;
+
+        s->last_irr = 0;
+        s->irr = 0;
+        s->imr = 0;
+        s->isr = 0;
+        s->priority_add = 0;
+        s->irq_base = 0;
+        s->read_reg_select = 0;
+        s->poll = 0;
+        s->special_mask = 0;
+        s->init_state = 0;
+        s->auto_eoi = 0;
+        s->rotate_on_auto_eoi = 0;
+        s->special_fully_nested_mode = 0;
+        s->init4 = 0;
+}
+
+static void pic_ioport_write(void *opaque, u32 addr, u32 val)
+{
+        struct kvm_kpic_state *s = opaque;
+        int priority, cmd, irq;
+
+        addr &= 1;
+        if (addr == 0) {
+                if (val & 0x10) {
+                        pic_reset(s);   /* init */
+                        /*
+                         * deassert a pending interrupt
+                         */
+                        s->pics_state->irq_request(s->pics_state->
+                                                   irq_request_opaque, 0);
+                        s->init_state = 1;
+                        s->init4 = val & 1;
+                        if (val & 0x02)
+                                printk(KERN_ERR "single mode not supported");
+                        if (val & 0x08)
+                                printk(KERN_ERR
+                                       "level sensitive irq not supported");
+                } else if (val & 0x08) {
+                        if (val & 0x04)
+                                s->poll = 1;
+                        if (val & 0x02)
+                                s->read_reg_select = val & 1;
+                        if (val & 0x40)
+                                s->special_mask = (val >> 5) & 1;
+                } else {
+                        cmd = val >> 5;
+                        switch (cmd) {
+                        case 0:
+                        case 4:
+                                s->rotate_on_auto_eoi = cmd >> 2;
+                                break;
+                        case 1: /* end of interrupt */
+                        case 5:
+                                priority = get_priority(s, s->isr);
+                                if (priority != 8) {
+                                        irq = (priority + s->priority_add) & 7;
+                                        s->isr &= ~(1 << irq);
+                                        if (cmd == 5)
+                                                s->priority_add = (irq + 1) & 7;
+                                        pic_update_irq(s->pics_state);
+                                }
+                                break;
+                        case 3:
+                                irq = val & 7;
+                                s->isr &= ~(1 << irq);
+                                pic_update_irq(s->pics_state);
+                                break;
+                        case 6:
+                                s->priority_add = (val + 1) & 7;
+                                pic_update_irq(s->pics_state);
+                                break;
+                        case 7:
+                                irq = val & 7;
+                                s->isr &= ~(1 << irq);
+                                s->priority_add = (irq + 1) & 7;
+                                pic_update_irq(s->pics_state);
+                                break;
+                        default:
+                                break;  /* no operation */
+                        }
+                }
+        } else
+                switch (s->init_state) {
+                case 0:         /* normal mode */
+                        s->imr = val;
+                        pic_update_irq(s->pics_state);
+                        break;
+                case 1:
+                        s->irq_base = val & 0xf8;
+                        s->init_state = 2;
+                        break;
+                case 2:
+                        if (s->init4)
+                                s->init_state = 3;
+                        else
+                                s->init_state = 0;
+                        break;
+                case 3:
+                        s->special_fully_nested_mode = (val >> 4) & 1;
+                        s->auto_eoi = (val >> 1) & 1;
+                        s->init_state = 0;
+                        break;
+                }
+}
+
+static u32 pic_poll_read(struct kvm_kpic_state *s, u32 addr1)
+{
+        int ret;
+
+        ret = pic_get_irq(s);
+        if (ret >= 0) {
+                if (addr1 >> 7) {
+                        s->pics_state->pics[0].isr &= ~(1 << 2);
+                        s->pics_state->pics[0].irr &= ~(1 << 2);
+                }
+                s->irr &= ~(1 << ret);
+                s->isr &= ~(1 << ret);
+                if (addr1 >> 7 || ret != 2)
+                        pic_update_irq(s->pics_state);
+        } else {
+                ret = 0x07;
+                pic_update_irq(s->pics_state);
+        }
+
+        return ret;
+}
+
+static u32 pic_ioport_read(void *opaque, u32 addr1)
+{
+        struct kvm_kpic_state *s = opaque;
+        unsigned int addr;
+        int ret;
+
+        addr = addr1;
+        addr &= 1;
+        if (s->poll) {
+                ret = pic_poll_read(s, addr1);
+                s->poll = 0;
+        } else
+                if (addr == 0)
+                        if (s->read_reg_select)
+                                ret = s->isr;
+                        else
+                                ret = s->irr;
+                else
+                        ret = s->imr;
+        return ret;
+}
+
+static void elcr_ioport_write(void *opaque, u32 addr, u32 val)
+{
+        struct kvm_kpic_state *s = opaque;
+        s->elcr = val & s->elcr_mask;
+}
+
+static u32 elcr_ioport_read(void *opaque, u32 addr1)
+{
+        struct kvm_kpic_state *s = opaque;
+        return s->elcr;
+}
+
+static int picdev_in_range(struct kvm_io_device *this, gpa_t addr)
+{
+        switch (addr) {
+        case 0x20:
+        case 0x21:
+        case 0xa0:
+        case 0xa1:
+        case 0x4d0:
+        case 0x4d1:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static void picdev_write(struct kvm_io_device *this,
+                         gpa_t addr, int len, const void *val)
+{
+        struct kvm_pic *s = this->private;
+        unsigned char data = *(unsigned char *)val;
+
+        if (len != 1) {
+                if (printk_ratelimit())
+                        printk(KERN_ERR "PIC: non byte write\n");
+                return;
+        }
+        switch (addr) {
+        case 0x20:
+        case 0x21:
+        case 0xa0:
+        case 0xa1:
+                pic_ioport_write(&s->pics[addr >> 7], addr, data);
+                break;
+        case 0x4d0:
+        case 0x4d1:
+                elcr_ioport_write(&s->pics[addr & 1], addr, data);
+                break;
+        }
+}
+
+static void picdev_read(struct kvm_io_device *this,
+                        gpa_t addr, int len, void *val)
+{
+        struct kvm_pic *s = this->private;
+        unsigned char data = 0;
+
+        if (len != 1) {
+                if (printk_ratelimit())
+                        printk(KERN_ERR "PIC: non byte read\n");
+                return;
+        }
+        switch (addr) {
+        case 0x20:
+        case 0x21:
+        case 0xa0:
+        case 0xa1:
+                data = pic_ioport_read(&s->pics[addr >> 7], addr);
+                break;
+        case 0x4d0:
+        case 0x4d1:
+                data = elcr_ioport_read(&s->pics[addr & 1], addr);
+                break;
+        }
+        *(unsigned char *)val = data;
+}
+
+/*
+ * callback when PIC0 irq status changed
+ */
+static void pic_irq_request(void *opaque, int level)
+{
+        struct kvm *kvm = opaque;
+        struct kvm_vcpu *vcpu = kvm->vcpus[0];
+
+        pic_irqchip(kvm)->output = level;
+        if (vcpu)
+                kvm_vcpu_kick(vcpu);
+}
+
+struct kvm_pic *kvm_create_pic(struct kvm *kvm)
+{
+        struct kvm_pic *s;
+        s = kzalloc(sizeof(struct kvm_pic), GFP_KERNEL);
+        if (!s)
+                return NULL;
+        s->pics[0].elcr_mask = 0xf8;
+        s->pics[1].elcr_mask = 0xde;
+        s->irq_request = pic_irq_request;
+        s->irq_request_opaque = kvm;
+        s->pics[0].pics_state = s;
+        s->pics[1].pics_state = s;
+
+        /*
+         * Initialize PIO device
+         */
+        s->dev.read = picdev_read;
+        s->dev.write = picdev_write;
+        s->dev.in_range = picdev_in_range;
+        s->dev.private = s;
+        kvm_io_bus_register_dev(&kvm->pio_bus, &s->dev);
+        return s;
+}
diff --git a/drivers/kvm/ioapic.c b/drivers/kvm/ioapic.c
new file mode 100644
index 0000000000..c7992e667f
--- /dev/null
+++ b/drivers/kvm/ioapic.c
@@ -0,0 +1,388 @@
+/*
+ *  Copyright (C) 2001  MandrakeSoft S.A.
+ *
+ *    MandrakeSoft S.A.
+ *    43, rue d'Aboukir
+ *    75002 Paris - France
+ *    http://www.linux-mandrake.com/
+ *    http://www.mandrakesoft.com/
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ *  Yunhong Jiang <yunhong.jiang@intel.com>
+ *  Yaozu (Eddie) Dong <eddie.dong@intel.com>
+ *  Based on Xen 3.1 code.
+ */
+
+#include "kvm.h"
+#include <linux/kvm.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/smp.h>
+#include <linux/hrtimer.h>
+#include <linux/io.h>
+#include <asm/processor.h>
+#include <asm/msr.h>
+#include <asm/page.h>
+#include <asm/current.h>
+#include <asm/apicdef.h>
+#include <asm/io_apic.h>
+#include "irq.h"
+/* #define ioapic_debug(fmt,arg...) printk(KERN_WARNING fmt,##arg) */
+#define ioapic_debug(fmt, arg...)
+static void ioapic_deliver(struct kvm_ioapic *vioapic, int irq);
+
+static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
+                                          unsigned long addr,
+                                          unsigned long length)
+{
+        unsigned long result = 0;
+
+        switch (ioapic->ioregsel) {
+        case IOAPIC_REG_VERSION:
+                result = ((((IOAPIC_NUM_PINS - 1) & 0xff) << 16)
+                          | (IOAPIC_VERSION_ID & 0xff));
+                break;
+
+        case IOAPIC_REG_APIC_ID:
+        case IOAPIC_REG_ARB_ID:
+                result = ((ioapic->id & 0xf) << 24);
+                break;
+
+        default:
+                {
+                        u32 redir_index = (ioapic->ioregsel - 0x10) >> 1;
+                        u64 redir_content;
+
+                        ASSERT(redir_index < IOAPIC_NUM_PINS);
+
+                        redir_content = ioapic->redirtbl[redir_index].bits;
+                        result = (ioapic->ioregsel & 0x1) ?
+                            (redir_content >> 32) & 0xffffffff :
+                            redir_content & 0xffffffff;
+                        break;
+                }
+        }
+
+        return result;
+}
+
+static void ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx)
+{
+        union ioapic_redir_entry *pent;
+
+        pent = &ioapic->redirtbl[idx];
+
+        if (!pent->fields.mask) {
+                ioapic_deliver(ioapic, idx);
+                if (pent->fields.trig_mode == IOAPIC_LEVEL_TRIG)
+                        pent->fields.remote_irr = 1;
+        }
+        if (!pent->fields.trig_mode)
+                ioapic->irr &= ~(1 << idx);
+}
+
+static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)
+{
+        unsigned index;
+
+        switch (ioapic->ioregsel) {
+        case IOAPIC_REG_VERSION:
+                /* Writes are ignored. */
+                break;
+
+        case IOAPIC_REG_APIC_ID:
+                ioapic->id = (val >> 24) & 0xf;
+                break;
+
+        case IOAPIC_REG_ARB_ID:
+                break;
+
+        default:
+                index = (ioapic->ioregsel - 0x10) >> 1;
+
+                ioapic_debug("change redir index %x val %x", index, val);
+                if (index >= IOAPIC_NUM_PINS)
+                        return;
+                if (ioapic->ioregsel & 1) {
+                        ioapic->redirtbl[index].bits &= 0xffffffff;
+                        ioapic->redirtbl[index].bits |= (u64) val << 32;
+                } else {
+                        ioapic->redirtbl[index].bits &= ~0xffffffffULL;
+                        ioapic->redirtbl[index].bits |= (u32) val;
+                        ioapic->redirtbl[index].fields.remote_irr = 0;
+                }
+                if (ioapic->irr & (1 << index))
+                        ioapic_service(ioapic, index);
+                break;
+        }
+}
+
+static void ioapic_inj_irq(struct kvm_ioapic *ioapic,
+                           struct kvm_lapic *target,
+                           u8 vector, u8 trig_mode, u8 delivery_mode)
+{
+        ioapic_debug("irq %d trig %d deliv %d", vector, trig_mode,
+                     delivery_mode);
+
+        ASSERT((delivery_mode == dest_Fixed) ||
+               (delivery_mode == dest_LowestPrio));
+
+        kvm_apic_set_irq(target, vector, trig_mode);
+}
+
+static u32 ioapic_get_delivery_bitmask(struct kvm_ioapic *ioapic, u8 dest,
+                                       u8 dest_mode)
+{
+        u32 mask = 0;
+        int i;
+        struct kvm *kvm = ioapic->kvm;
+        struct kvm_vcpu *vcpu;
+
+        ioapic_debug("dest %d dest_mode %d", dest, dest_mode);
+
+        if (dest_mode == 0) {   /* Physical mode. */
+                if (dest == 0xFF) {     /* Broadcast. */
+                        for (i = 0; i < KVM_MAX_VCPUS; ++i)
+                                if (kvm->vcpus[i] && kvm->vcpus[i]->apic)
+                                        mask |= 1 << i;
+                        return mask;
+                }
+                for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                        vcpu = kvm->vcpus[i];
+                        if (!vcpu)
+                                continue;
+                        if (kvm_apic_match_physical_addr(vcpu->apic, dest)) {
+                                if (vcpu->apic)
+                                        mask = 1 << i;
+                                break;
+                        }
+                }
+        } else if (dest != 0)   /* Logical mode, MDA non-zero. */
+                for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                        vcpu = kvm->vcpus[i];
+                        if (!vcpu)
+                                continue;
+                        if (vcpu->apic &&
+                            kvm_apic_match_logical_addr(vcpu->apic, dest))
+                                mask |= 1 << vcpu->vcpu_id;
+                }
+        ioapic_debug("mask %x", mask);
+        return mask;
+}
+
+static void ioapic_deliver(struct kvm_ioapic *ioapic, int irq)
+{
+        u8 dest = ioapic->redirtbl[irq].fields.dest_id;
+        u8 dest_mode = ioapic->redirtbl[irq].fields.dest_mode;
+        u8 delivery_mode = ioapic->redirtbl[irq].fields.delivery_mode;
+        u8 vector = ioapic->redirtbl[irq].fields.vector;
+        u8 trig_mode = ioapic->redirtbl[irq].fields.trig_mode;
+        u32 deliver_bitmask;
+        struct kvm_lapic *target;
+        struct kvm_vcpu *vcpu;
+        int vcpu_id;
+
+        ioapic_debug("dest=%x dest_mode=%x delivery_mode=%x "
+                     "vector=%x trig_mode=%x",
+                     dest, dest_mode, delivery_mode, vector, trig_mode);
+
+        deliver_bitmask = ioapic_get_delivery_bitmask(ioapic, dest, dest_mode);
+        if (!deliver_bitmask) {
+                ioapic_debug("no target on destination");
+                return;
+        }
+
+        switch (delivery_mode) {
+        case dest_LowestPrio:
+                target =
+                    kvm_apic_round_robin(ioapic->kvm, vector, deliver_bitmask);
+                if (target != NULL)
+                        ioapic_inj_irq(ioapic, target, vector,
+                                       trig_mode, delivery_mode);
+                else
+                        ioapic_debug("null round robin: "
+                                     "mask=%x vector=%x delivery_mode=%x",
+                                     deliver_bitmask, vector, dest_LowestPrio);
+                break;
+        case dest_Fixed:
+                for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
+                        if (!(deliver_bitmask & (1 << vcpu_id)))
+                                continue;
+                        deliver_bitmask &= ~(1 << vcpu_id);
+                        vcpu = ioapic->kvm->vcpus[vcpu_id];
+                        if (vcpu) {
+                                target = vcpu->apic;
+                                ioapic_inj_irq(ioapic, target, vector,
+                                               trig_mode, delivery_mode);
+                        }
+                }
+                break;
+
+                /* TODO: NMI */
+        default:
+                printk(KERN_WARNING "Unsupported delivery mode %d\n",
+                       delivery_mode);
+                break;
+        }
+}
+
+void kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level)
+{
+        u32 old_irr = ioapic->irr;
+        u32 mask = 1 << irq;
+        union ioapic_redir_entry entry;
+
+        if (irq >= 0 && irq < IOAPIC_NUM_PINS) {
+                entry = ioapic->redirtbl[irq];
+                level ^= entry.fields.polarity;
+                if (!level)
+                        ioapic->irr &= ~mask;
+                else {
+                        ioapic->irr |= mask;
+                        if ((!entry.fields.trig_mode && old_irr != ioapic->irr)
+                            || !entry.fields.remote_irr)
+                                ioapic_service(ioapic, irq);
+                }
+        }
+}
+
+static int get_eoi_gsi(struct kvm_ioapic *ioapic, int vector)
+{
+        int i;
+
+        for (i = 0; i < IOAPIC_NUM_PINS; i++)
+                if (ioapic->redirtbl[i].fields.vector == vector)
+                        return i;
+        return -1;
+}
+
+void kvm_ioapic_update_eoi(struct kvm *kvm, int vector)
+{
+        struct kvm_ioapic *ioapic = kvm->vioapic;
+        union ioapic_redir_entry *ent;
+        int gsi;
+
+        gsi = get_eoi_gsi(ioapic, vector);
+        if (gsi == -1) {
+                printk(KERN_WARNING "Can't find redir item for %d EOI\n",
+                       vector);
+                return;
+        }
+
+        ent = &ioapic->redirtbl[gsi];
+        ASSERT(ent->fields.trig_mode == IOAPIC_LEVEL_TRIG);
+
+        ent->fields.remote_irr = 0;
+        if (!ent->fields.mask && (ioapic->irr & (1 << gsi)))
+                ioapic_deliver(ioapic, gsi);
+}
+
+static int ioapic_in_range(struct kvm_io_device *this, gpa_t addr)
+{
+        struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;
+
+        return ((addr >= ioapic->base_address &&
+                 (addr < ioapic->base_address + IOAPIC_MEM_LENGTH)));
+}
+
+static void ioapic_mmio_read(struct kvm_io_device *this, gpa_t addr, int len,
+                             void *val)
+{
+        struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;
+        u32 result;
+
+        ioapic_debug("addr %lx", (unsigned long)addr);
+        ASSERT(!(addr & 0xf));  /* check alignment */
+
+        addr &= 0xff;
+        switch (addr) {
+        case IOAPIC_REG_SELECT:
+                result = ioapic->ioregsel;
+                break;
+
+        case IOAPIC_REG_WINDOW:
+                result = ioapic_read_indirect(ioapic, addr, len);
+                break;
+
+        default:
+                result = 0;
+                break;
+        }
+        switch (len) {
+        case 8:
+                *(u64 *) val = result;
+                break;
+        case 1:
+        case 2:
+        case 4:
+                memcpy(val, (char *)&result, len);
+                break;
+        default:
+                printk(KERN_WARNING "ioapic: wrong length %d\n", len);
+        }
+}
+
+static void ioapic_mmio_write(struct kvm_io_device *this, gpa_t addr, int len,
+                              const void *val)
+{
+        struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;
+        u32 data;
+
+        ioapic_debug("ioapic_mmio_write addr=%lx len=%d val=%p\n",
+                     addr, len, val);
+        ASSERT(!(addr & 0xf));  /* check alignment */
+        if (len == 4 || len == 8)
+                data = *(u32 *) val;
+        else {
+                printk(KERN_WARNING "ioapic: Unsupported size %d\n", len);
+                return;
+        }
+
+        addr &= 0xff;
+        switch (addr) {
+        case IOAPIC_REG_SELECT:
+                ioapic->ioregsel = data;
+                break;
+
+        case IOAPIC_REG_WINDOW:
+                ioapic_write_indirect(ioapic, data);
+                break;
+
+        default:
+                break;
+        }
+}
+
+int kvm_ioapic_init(struct kvm *kvm)
+{
+        struct kvm_ioapic *ioapic;
+        int i;
+
+        ioapic = kzalloc(sizeof(struct kvm_ioapic), GFP_KERNEL);
+        if (!ioapic)
+                return -ENOMEM;
+        kvm->vioapic = ioapic;
+        for (i = 0; i < IOAPIC_NUM_PINS; i++)
+                ioapic->redirtbl[i].fields.mask = 1;
+        ioapic->base_address = IOAPIC_DEFAULT_BASE_ADDRESS;
+        ioapic->dev.read = ioapic_mmio_read;
+        ioapic->dev.write = ioapic_mmio_write;
+        ioapic->dev.in_range = ioapic_in_range;
+        ioapic->dev.private = ioapic;
+        ioapic->kvm = kvm;
+        kvm_io_bus_register_dev(&kvm->mmio_bus, &ioapic->dev);
+        return 0;
+}
diff --git a/drivers/kvm/irq.c b/drivers/kvm/irq.c
new file mode 100644
index 0000000000..7628c7ff62
--- /dev/null
+++ b/drivers/kvm/irq.c
@@ -0,0 +1,98 @@
+/*
+ * irq.c: API for in kernel interrupt controller
+ * Copyright (c) 2007, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ * Authors:
+ *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
+ *
+ */
+
+#include <linux/module.h>
+
+#include "kvm.h"
+#include "irq.h"
+
+/*
+ * check if there is pending interrupt without
+ * intack.
+ */
+int kvm_cpu_has_interrupt(struct kvm_vcpu *v)
+{
+        struct kvm_pic *s;
+
+        if (kvm_apic_has_interrupt(v) == -1) {  /* LAPIC */
+                if (kvm_apic_accept_pic_intr(v)) {
+                        s = pic_irqchip(v->kvm);        /* PIC */
+                        return s->output;
+                } else
+                        return 0;
+        }
+        return 1;
+}
+EXPORT_SYMBOL_GPL(kvm_cpu_has_interrupt);
+
+/*
+ * Read pending interrupt vector and intack.
+ */
+int kvm_cpu_get_interrupt(struct kvm_vcpu *v)
+{
+        struct kvm_pic *s;
+        int vector;
+
+        vector = kvm_get_apic_interrupt(v);     /* APIC */
+        if (vector == -1) {
+                if (kvm_apic_accept_pic_intr(v)) {
+                        s = pic_irqchip(v->kvm);
+                        s->output = 0;          /* PIC */
+                        vector = kvm_pic_read_irq(s);
+                }
+        }
+        return vector;
+}
+EXPORT_SYMBOL_GPL(kvm_cpu_get_interrupt);
+
+static void vcpu_kick_intr(void *info)
+{
+#ifdef DEBUG
+        struct kvm_vcpu *vcpu = (struct kvm_vcpu *)info;
+        printk(KERN_DEBUG "vcpu_kick_intr %p \n", vcpu);
+#endif
+}
+
+void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
+{
+        int ipi_pcpu = vcpu->cpu;
+
+        if (waitqueue_active(&vcpu->wq)) {
+                wake_up_interruptible(&vcpu->wq);
+                ++vcpu->stat.halt_wakeup;
+        }
+        if (vcpu->guest_mode)
+                smp_call_function_single(ipi_pcpu, vcpu_kick_intr, vcpu, 0, 0);
+}
+
+void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu)
+{
+        kvm_inject_apic_timer_irqs(vcpu);
+        /* TODO: PIT, RTC etc. */
+}
+EXPORT_SYMBOL_GPL(kvm_inject_pending_timer_irqs);
+
+void kvm_timer_intr_post(struct kvm_vcpu *vcpu, int vec)
+{
+        kvm_apic_timer_intr_post(vcpu, vec);
+        /* TODO: PIT, RTC etc. */
+}
+EXPORT_SYMBOL_GPL(kvm_timer_intr_post);
diff --git a/drivers/kvm/irq.h b/drivers/kvm/irq.h
new file mode 100644
index 0000000000..11fc014e2b
--- /dev/null
+++ b/drivers/kvm/irq.h
@@ -0,0 +1,165 @@
+/*
+ * irq.h: in kernel interrupt controller related definitions
+ * Copyright (c) 2007, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ * Authors:
+ *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
+ *
+ */
+
+#ifndef __IRQ_H
+#define __IRQ_H
+
+#include "kvm.h"
+
+typedef void irq_request_func(void *opaque, int level);
+
+struct kvm_kpic_state {
+        u8 last_irr;    /* edge detection */
+        u8 irr;         /* interrupt request register */
+        u8 imr;         /* interrupt mask register */
+        u8 isr;         /* interrupt service register */
+        u8 priority_add;        /* highest irq priority */
+        u8 irq_base;
+        u8 read_reg_select;
+        u8 poll;
+        u8 special_mask;
+        u8 init_state;
+        u8 auto_eoi;
+        u8 rotate_on_auto_eoi;
+        u8 special_fully_nested_mode;
+        u8 init4;               /* true if 4 byte init */
+        u8 elcr;                /* PIIX edge/trigger selection */
+        u8 elcr_mask;
+        struct kvm_pic *pics_state;
+};
+
+struct kvm_pic {
+        struct kvm_kpic_state pics[2]; /* 0 is master pic, 1 is slave pic */
+        irq_request_func *irq_request;
+        void *irq_request_opaque;
+        int output;             /* intr from master PIC */
+        struct kvm_io_device dev;
+};
+
+struct kvm_pic *kvm_create_pic(struct kvm *kvm);
+void kvm_pic_set_irq(void *opaque, int irq, int level);
+int kvm_pic_read_irq(struct kvm_pic *s);
+int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
+int kvm_cpu_has_interrupt(struct kvm_vcpu *v);
+void kvm_pic_update_irq(struct kvm_pic *s);
+
+#define IOAPIC_NUM_PINS  KVM_IOAPIC_NUM_PINS
+#define IOAPIC_VERSION_ID 0x11  /* IOAPIC version */
+#define IOAPIC_EDGE_TRIG  0
+#define IOAPIC_LEVEL_TRIG 1
+
+#define IOAPIC_DEFAULT_BASE_ADDRESS  0xfec00000
+#define IOAPIC_MEM_LENGTH            0x100
+
+/* Direct registers. */
+#define IOAPIC_REG_SELECT  0x00
+#define IOAPIC_REG_WINDOW  0x10
+#define IOAPIC_REG_EOI     0x40 /* IA64 IOSAPIC only */
+
+/* Indirect registers. */
+#define IOAPIC_REG_APIC_ID 0x00 /* x86 IOAPIC only */
+#define IOAPIC_REG_VERSION 0x01
+#define IOAPIC_REG_ARB_ID  0x02 /* x86 IOAPIC only */
+
+struct kvm_ioapic {
+        u64 base_address;
+        u32 ioregsel;
+        u32 id;
+        u32 irr;
+        u32 pad;
+        union ioapic_redir_entry {
+                u64 bits;
+                struct {
+                        u8 vector;
+                        u8 delivery_mode:3;
+                        u8 dest_mode:1;
+                        u8 delivery_status:1;
+                        u8 polarity:1;
+                        u8 remote_irr:1;
+                        u8 trig_mode:1;
+                        u8 mask:1;
+                        u8 reserve:7;
+                        u8 reserved[4];
+                        u8 dest_id;
+                } fields;
+        } redirtbl[IOAPIC_NUM_PINS];
+        struct kvm_io_device dev;
+        struct kvm *kvm;
+};
+
+struct kvm_lapic {
+        unsigned long base_address;
+        struct kvm_io_device dev;
+        struct {
+                atomic_t pending;
+                s64 period;     /* unit: ns */
+                u32 divide_count;
+                ktime_t last_update;
+                struct hrtimer dev;
+        } timer;
+        struct kvm_vcpu *vcpu;
+        struct page *regs_page;
+        void *regs;
+};
+
+#ifdef DEBUG
+#define ASSERT(x)                                                       \
+do {                                                                    \
+        if (!(x)) {                                                     \
+                printk(KERN_EMERG "assertion failed %s: %d: %s\n",      \
+                       __FILE__, __LINE__, #x);                         \
+                BUG();                                                  \
+        }                                                               \
+} while (0)
+#else
+#define ASSERT(x) do { } while (0)
+#endif
+
+void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
+int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu);
+int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu);
+int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu);
+int kvm_create_lapic(struct kvm_vcpu *vcpu);
+void kvm_lapic_reset(struct kvm_vcpu *vcpu);
+void kvm_free_apic(struct kvm_lapic *apic);
+u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu);
+void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8);
+void kvm_lapic_set_base(struct kvm_vcpu *vcpu, u64 value);
+struct kvm_lapic *kvm_apic_round_robin(struct kvm *kvm, u8 vector,
+                                       unsigned long bitmap);
+u64 kvm_get_apic_base(struct kvm_vcpu *vcpu);
+void kvm_set_apic_base(struct kvm_vcpu *vcpu, u64 data);
+int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest);
+void kvm_ioapic_update_eoi(struct kvm *kvm, int vector);
+int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda);
+int kvm_apic_set_irq(struct kvm_lapic *apic, u8 vec, u8 trig);
+void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu);
+int kvm_ioapic_init(struct kvm *kvm);
+void kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level);
+int kvm_lapic_enabled(struct kvm_vcpu *vcpu);
+int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu);
+void kvm_apic_timer_intr_post(struct kvm_vcpu *vcpu, int vec);
+void kvm_timer_intr_post(struct kvm_vcpu *vcpu, int vec);
+void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu);
+void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu);
+void kvm_migrate_apic_timer(struct kvm_vcpu *vcpu);
+
+#endif
diff --git a/drivers/kvm/kvm.h b/drivers/kvm/kvm.h
index 336be86c6f..ad0813843a 100644
--- a/drivers/kvm/kvm.h
+++ b/drivers/kvm/kvm.h
@@ -13,60 +13,38 @@
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/preempt.h>
 #include <asm/signal.h>
 
-#include "vmx.h"
 #include <linux/kvm.h>
 #include <linux/kvm_para.h>
 
-#define CR0_PE_MASK (1ULL << 0)
-#define CR0_MP_MASK (1ULL << 1)
-#define CR0_TS_MASK (1ULL << 3)
-#define CR0_NE_MASK (1ULL << 5)
-#define CR0_WP_MASK (1ULL << 16)
-#define CR0_NW_MASK (1ULL << 29)
-#define CR0_CD_MASK (1ULL << 30)
-#define CR0_PG_MASK (1ULL << 31)
-
-#define CR3_WPT_MASK (1ULL << 3)
-#define CR3_PCD_MASK (1ULL << 4)
-
-#define CR3_RESEVED_BITS 0x07ULL
-#define CR3_L_MODE_RESEVED_BITS (~((1ULL << 40) - 1) | 0x0fe7ULL)
-#define CR3_FLAGS_MASK ((1ULL << 5) - 1)
-
-#define CR4_VME_MASK (1ULL << 0)
-#define CR4_PSE_MASK (1ULL << 4)
-#define CR4_PAE_MASK (1ULL << 5)
-#define CR4_PGE_MASK (1ULL << 7)
-#define CR4_VMXE_MASK (1ULL << 13)
+#define CR3_PAE_RESERVED_BITS ((X86_CR3_PWT | X86_CR3_PCD) - 1)
+#define CR3_NONPAE_RESERVED_BITS ((PAGE_SIZE-1) & ~(X86_CR3_PWT | X86_CR3_PCD))
+#define CR3_L_MODE_RESERVED_BITS (CR3_NONPAE_RESERVED_BITS|0xFFFFFF0000000000ULL)
 
 #define KVM_GUEST_CR0_MASK \
-        (CR0_PG_MASK | CR0_PE_MASK | CR0_WP_MASK | CR0_NE_MASK \
-         | CR0_NW_MASK | CR0_CD_MASK)
+        (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE \
+         | X86_CR0_NW | X86_CR0_CD)
 #define KVM_VM_CR0_ALWAYS_ON \
-        (CR0_PG_MASK | CR0_PE_MASK | CR0_WP_MASK | CR0_NE_MASK | CR0_TS_MASK \
-         | CR0_MP_MASK)
+        (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP | X86_CR0_NE | X86_CR0_TS \
+         | X86_CR0_MP)
 #define KVM_GUEST_CR4_MASK \
-        (CR4_PSE_MASK | CR4_PAE_MASK | CR4_PGE_MASK | CR4_VMXE_MASK | CR4_VME_MASK)
-#define KVM_PMODE_VM_CR4_ALWAYS_ON (CR4_VMXE_MASK | CR4_PAE_MASK)
-#define KVM_RMODE_VM_CR4_ALWAYS_ON (CR4_VMXE_MASK | CR4_PAE_MASK | CR4_VME_MASK)
+        (X86_CR4_VME | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_PGE | X86_CR4_VMXE)
+#define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE | X86_CR4_VMXE)
+#define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME | X86_CR4_PAE | X86_CR4_VMXE)
 
 #define INVALID_PAGE (~(hpa_t)0)
 #define UNMAPPED_GVA (~(gpa_t)0)
 
 #define KVM_MAX_VCPUS 4
 #define KVM_ALIAS_SLOTS 4
-#define KVM_MEMORY_SLOTS 4
+#define KVM_MEMORY_SLOTS 8
 #define KVM_NUM_MMU_PAGES 1024
 #define KVM_MIN_FREE_MMU_PAGES 5
 #define KVM_REFILL_PAGES 25
 #define KVM_MAX_CPUID_ENTRIES 40
 
-#define FX_IMAGE_SIZE 512
-#define FX_IMAGE_ALIGN 16
-#define FX_BUF_SIZE (2 * FX_IMAGE_SIZE + FX_IMAGE_ALIGN)
-
 #define DE_VECTOR 0
 #define NM_VECTOR 7
 #define DF_VECTOR 8
@@ -158,15 +136,8 @@ struct kvm_mmu_page {
         };
 };
 
-struct vmcs {
-        u32 revision_id;
-        u32 abort;
-        char data[0];
-};
-
-#define vmx_msr_entry kvm_msr_entry
-
 struct kvm_vcpu;
+extern struct kmem_cache *kvm_vcpu_cache;
 
 /*
  * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
@@ -260,6 +231,7 @@ struct kvm_stat {
         u32 signal_exits;
         u32 irq_window_exits;
         u32 halt_exits;
+        u32 halt_wakeup;
         u32 request_irq_exits;
         u32 irq_exits;
         u32 light_exits;
@@ -328,21 +300,17 @@ void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
 
 struct kvm_vcpu {
         struct kvm *kvm;
-        union {
-                struct vmcs *vmcs;
-                struct vcpu_svm *svm;
-        };
+        struct preempt_notifier preempt_notifier;
+        int vcpu_id;
         struct mutex mutex;
         int   cpu;
-        int   launched;
         u64 host_tsc;
         struct kvm_run *run;
         int interrupt_window_open;
         int guest_mode;
         unsigned long requests;
         unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */
-#define NR_IRQ_WORDS KVM_IRQ_BITMAP_SIZE(unsigned long)
-        unsigned long irq_pending[NR_IRQ_WORDS];
+        DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS);
         unsigned long regs[NR_VCPU_REGS]; /* for rsp: vcpu_load_rsp_rip() */
         unsigned long rip;      /* needs vcpu_load_rsp_rip() */
 
@@ -357,15 +325,15 @@ struct kvm_vcpu {
         u64 pdptrs[4]; /* pae */
         u64 shadow_efer;
         u64 apic_base;
+        struct kvm_lapic *apic;    /* kernel irqchip context */
+#define VCPU_MP_STATE_RUNNABLE          0
+#define VCPU_MP_STATE_UNINITIALIZED     1
+#define VCPU_MP_STATE_INIT_RECEIVED     2
+#define VCPU_MP_STATE_SIPI_RECEIVED     3
+#define VCPU_MP_STATE_HALTED            4
+        int mp_state;
+        int sipi_vector;
         u64 ia32_misc_enable_msr;
-        int nmsrs;
-        int save_nmsrs;
-        int msr_offset_efer;
-#ifdef CONFIG_X86_64
-        int msr_offset_kernel_gs_base;
-#endif
-        struct vmx_msr_entry *guest_msrs;
-        struct vmx_msr_entry *host_msrs;
 
         struct kvm_mmu mmu;
 
@@ -379,16 +347,10 @@ struct kvm_vcpu {
 
         struct kvm_guest_debug guest_debug;
 
-        char fx_buf[FX_BUF_SIZE];
-        char *host_fx_image;
-        char *guest_fx_image;
+        struct i387_fxsave_struct host_fx_image;
+        struct i387_fxsave_struct guest_fx_image;
         int fpu_active;
         int guest_fpu_loaded;
-        struct vmx_host_state {
-                int loaded;
-                u16 fs_sel, gs_sel, ldt_sel;
-                int fs_gs_ldt_reload_needed;
-        } vmx_host_state;
 
         int mmio_needed;
         int mmio_read_completed;
@@ -399,6 +361,7 @@ struct kvm_vcpu {
         gva_t mmio_fault_cr2;
         struct kvm_pio_request pio;
         void *pio_data;
+        wait_queue_head_t wq;
 
         int sigset_active;
         sigset_t sigset;
@@ -436,7 +399,7 @@ struct kvm_memory_slot {
 };
 
 struct kvm {
-        spinlock_t lock; /* protects everything except vcpus */
+        struct mutex lock; /* protects everything except vcpus */
         int naliases;
         struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
         int nmemslots;
@@ -447,39 +410,59 @@ struct kvm {
         struct list_head active_mmu_pages;
         int n_free_mmu_pages;
         struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
-        int nvcpus;
-        struct kvm_vcpu vcpus[KVM_MAX_VCPUS];
-        int memory_config_version;
-        int busy;
+        struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
         unsigned long rmap_overflow;
         struct list_head vm_list;
         struct file *filp;
         struct kvm_io_bus mmio_bus;
         struct kvm_io_bus pio_bus;
+        struct kvm_pic *vpic;
+        struct kvm_ioapic *vioapic;
+        int round_robin_prev_vcpu;
 };
 
+static inline struct kvm_pic *pic_irqchip(struct kvm *kvm)
+{
+        return kvm->vpic;
+}
+
+static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
+{
+        return kvm->vioapic;
+}
+
+static inline int irqchip_in_kernel(struct kvm *kvm)
+{
+        return pic_irqchip(kvm) != 0;
+}
+
 struct descriptor_table {
         u16 limit;
         unsigned long base;
 } __attribute__((packed));
 
-struct kvm_arch_ops {
+struct kvm_x86_ops {
         int (*cpu_has_kvm_support)(void);          /* __init */
         int (*disabled_by_bios)(void);             /* __init */
         void (*hardware_enable)(void *dummy);      /* __init */
         void (*hardware_disable)(void *dummy);
+        void (*check_processor_compatibility)(void *rtn);
         int (*hardware_setup)(void);               /* __init */
         void (*hardware_unsetup)(void);            /* __exit */
 
-        int (*vcpu_create)(struct kvm_vcpu *vcpu);
+        /* Create, but do not attach this VCPU */
+        struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id);
         void (*vcpu_free)(struct kvm_vcpu *vcpu);
+        void (*vcpu_reset)(struct kvm_vcpu *vcpu);
 
-        void (*vcpu_load)(struct kvm_vcpu *vcpu);
+        void (*prepare_guest_switch)(struct kvm_vcpu *vcpu);
+        void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu);
         void (*vcpu_put)(struct kvm_vcpu *vcpu);
         void (*vcpu_decache)(struct kvm_vcpu *vcpu);
 
         int (*set_guest_debug)(struct kvm_vcpu *vcpu,
                                struct kvm_debug_guest *dbg);
+        void (*guest_debug_pre)(struct kvm_vcpu *vcpu);
         int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata);
         int (*set_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
         u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg);
@@ -505,27 +488,43 @@ struct kvm_arch_ops {
         unsigned long (*get_rflags)(struct kvm_vcpu *vcpu);
         void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
 
-        void (*invlpg)(struct kvm_vcpu *vcpu, gva_t addr);
         void (*tlb_flush)(struct kvm_vcpu *vcpu);
         void (*inject_page_fault)(struct kvm_vcpu *vcpu,
                                   unsigned long addr, u32 err_code);
 
         void (*inject_gp)(struct kvm_vcpu *vcpu, unsigned err_code);
 
-        int (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run);
-        int (*vcpu_setup)(struct kvm_vcpu *vcpu);
+        void (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run);
+        int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu);
         void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
         void (*patch_hypercall)(struct kvm_vcpu *vcpu,
                                 unsigned char *hypercall_addr);
+        int (*get_irq)(struct kvm_vcpu *vcpu);
+        void (*set_irq)(struct kvm_vcpu *vcpu, int vec);
+        void (*inject_pending_irq)(struct kvm_vcpu *vcpu);
+        void (*inject_pending_vectors)(struct kvm_vcpu *vcpu,
+                                       struct kvm_run *run);
 };
 
-extern struct kvm_arch_ops *kvm_arch_ops;
+extern struct kvm_x86_ops *kvm_x86_ops;
+
+/* The guest did something we don't support. */
+#define pr_unimpl(vcpu, fmt, ...)                                       \
+ do {                                                                   \
+        if (printk_ratelimit())                                         \
+                printk(KERN_ERR "kvm: %i: cpu%i " fmt,                  \
+                       current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
+ } while(0)
 
 #define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
 #define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
 
-int kvm_init_arch(struct kvm_arch_ops *ops, struct module *module);
-void kvm_exit_arch(void);
+int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
+void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
+
+int kvm_init_x86(struct kvm_x86_ops *ops, unsigned int vcpu_size,
+                  struct module *module);
+void kvm_exit_x86(void);
 
 int kvm_mmu_module_init(void);
 void kvm_mmu_module_exit(void);
@@ -545,8 +544,6 @@ static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
 hpa_t gva_to_hpa(struct kvm_vcpu *vcpu, gva_t gva);
 struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);
 
-void kvm_emulator_want_group7_invlpg(void);
-
 extern hpa_t bad_page_address;
 
 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
@@ -561,6 +558,7 @@ enum emulation_result {
 
 int emulate_instruction(struct kvm_vcpu *vcpu, struct kvm_run *run,
                         unsigned long cr2, u16 error_code);
+void kvm_report_emulation_failure(struct kvm_vcpu *cvpu, const char *context);
 void realmode_lgdt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
 void realmode_lidt(struct kvm_vcpu *vcpu, u16 size, unsigned long address);
 void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw,
@@ -574,9 +572,11 @@ int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
 
 struct x86_emulate_ctxt;
 
-int kvm_setup_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
-                  int size, unsigned long count, int string, int down,
-                  gva_t address, int rep, unsigned port);
+int kvm_emulate_pio (struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
+                     int size, unsigned port);
+int kvm_emulate_pio_string(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
+                           int size, unsigned long count, int down,
+                            gva_t address, int rep, unsigned port);
 void kvm_emulate_cpuid(struct kvm_vcpu *vcpu);
 int kvm_emulate_halt(struct kvm_vcpu *vcpu);
 int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address);
@@ -590,34 +590,33 @@ void set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0);
 void set_cr3(struct kvm_vcpu *vcpu, unsigned long cr0);
 void set_cr4(struct kvm_vcpu *vcpu, unsigned long cr0);
 void set_cr8(struct kvm_vcpu *vcpu, unsigned long cr0);
+unsigned long get_cr8(struct kvm_vcpu *vcpu);
 void lmsw(struct kvm_vcpu *vcpu, unsigned long msw);
+void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l);
 
 int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata);
 int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data);
 
 void fx_init(struct kvm_vcpu *vcpu);
 
-void load_msrs(struct vmx_msr_entry *e, int n);
-void save_msrs(struct vmx_msr_entry *e, int n);
 void kvm_resched(struct kvm_vcpu *vcpu);
 void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
 void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
 void kvm_flush_remote_tlbs(struct kvm *kvm);
 
-int kvm_read_guest(struct kvm_vcpu *vcpu,
-               gva_t addr,
-               unsigned long size,
-               void *dest);
-
-int kvm_write_guest(struct kvm_vcpu *vcpu,
-                gva_t addr,
-                unsigned long size,
-                void *data);
+int emulator_read_std(unsigned long addr,
+                      void *val,
+                      unsigned int bytes,
+                      struct kvm_vcpu *vcpu);
+int emulator_write_emulated(unsigned long addr,
+                            const void *val,
+                            unsigned int bytes,
+                            struct kvm_vcpu *vcpu);
 
 unsigned long segment_base(u16 selector);
 
 void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
-                       const u8 *old, const u8 *new, int bytes);
+                       const u8 *new, int bytes);
 int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva);
 void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
 int kvm_mmu_load(struct kvm_vcpu *vcpu);
@@ -656,17 +655,17 @@ static inline int is_long_mode(struct kvm_vcpu *vcpu)
 
 static inline int is_pae(struct kvm_vcpu *vcpu)
 {
-        return vcpu->cr4 & CR4_PAE_MASK;
+        return vcpu->cr4 & X86_CR4_PAE;
 }
 
 static inline int is_pse(struct kvm_vcpu *vcpu)
 {
-        return vcpu->cr4 & CR4_PSE_MASK;
+        return vcpu->cr4 & X86_CR4_PSE;
 }
 
 static inline int is_paging(struct kvm_vcpu *vcpu)
 {
-        return vcpu->cr0 & CR0_PG_MASK;
+        return vcpu->cr0 & X86_CR0_PG;
 }
 
 static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
@@ -746,12 +745,12 @@ static inline unsigned long read_msr(unsigned long msr)
 }
 #endif
 
-static inline void fx_save(void *image)
+static inline void fx_save(struct i387_fxsave_struct *image)
 {
         asm ("fxsave (%0)":: "r" (image));
 }
 
-static inline void fx_restore(void *image)
+static inline void fx_restore(struct i387_fxsave_struct *image)
 {
         asm ("fxrstor (%0)":: "r" (image));
 }
diff --git a/drivers/kvm/kvm_main.c b/drivers/kvm/kvm_main.c
index cd0557954e..353e58527d 100644
--- a/drivers/kvm/kvm_main.c
+++ b/drivers/kvm/kvm_main.c
@@ -18,6 +18,7 @@
 #include "kvm.h"
 #include "x86_emulate.h"
 #include "segment_descriptor.h"
+#include "irq.h"
 
 #include <linux/kvm.h>
 #include <linux/module.h>
@@ -37,6 +38,7 @@
 #include <linux/cpumask.h>
 #include <linux/smp.h>
 #include <linux/anon_inodes.h>
+#include <linux/profile.h>
 
 #include <asm/processor.h>
 #include <asm/msr.h>
@@ -52,9 +54,11 @@ static LIST_HEAD(vm_list);
 
 static cpumask_t cpus_hardware_enabled;
 
-struct kvm_arch_ops *kvm_arch_ops;
+struct kvm_x86_ops *kvm_x86_ops;
+struct kmem_cache *kvm_vcpu_cache;
+EXPORT_SYMBOL_GPL(kvm_vcpu_cache);
 
-static void hardware_disable(void *ignored);
+static __read_mostly struct preempt_ops kvm_preempt_ops;
 
 #define STAT_OFFSET(x) offsetof(struct kvm_vcpu, stat.x)
 
@@ -73,6 +77,7 @@ static struct kvm_stats_debugfs_item {
         { "signal_exits", STAT_OFFSET(signal_exits) },
         { "irq_window", STAT_OFFSET(irq_window_exits) },
         { "halt_exits", STAT_OFFSET(halt_exits) },
+        { "halt_wakeup", STAT_OFFSET(halt_wakeup) },
         { "request_irq", STAT_OFFSET(request_irq_exits) },
         { "irq_exits", STAT_OFFSET(irq_exits) },
         { "light_exits", STAT_OFFSET(light_exits) },
@@ -84,10 +89,17 @@ static struct dentry *debugfs_dir;
 
 #define MAX_IO_MSRS 256
 
-#define CR0_RESEVED_BITS 0xffffffff1ffaffc0ULL
-#define LMSW_GUEST_MASK 0x0eULL
-#define CR4_RESEVED_BITS (~((1ULL << 11) - 1))
-#define CR8_RESEVED_BITS (~0x0fULL)
+#define CR0_RESERVED_BITS                                               \
+        (~(unsigned long)(X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS \
+                          | X86_CR0_ET | X86_CR0_NE | X86_CR0_WP | X86_CR0_AM \
+                          | X86_CR0_NW | X86_CR0_CD | X86_CR0_PG))
+#define CR4_RESERVED_BITS                                               \
+        (~(unsigned long)(X86_CR4_VME | X86_CR4_PVI | X86_CR4_TSD | X86_CR4_DE\
+                          | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_MCE     \
+                          | X86_CR4_PGE | X86_CR4_PCE | X86_CR4_OSFXSR  \
+                          | X86_CR4_OSXMMEXCPT | X86_CR4_VMXE))
+
+#define CR8_RESERVED_BITS (~(unsigned long)X86_CR8_TPR)
 #define EFER_RESERVED_BITS 0xfffffffffffff2fe
 
 #ifdef CONFIG_X86_64
@@ -139,82 +151,14 @@ static inline int valid_vcpu(int n)
         return likely(n >= 0 && n < KVM_MAX_VCPUS);
 }
 
-int kvm_read_guest(struct kvm_vcpu *vcpu, gva_t addr, unsigned long size,
-                   void *dest)
-{
-        unsigned char *host_buf = dest;
-        unsigned long req_size = size;
-
-        while (size) {
-                hpa_t paddr;
-                unsigned now;
-                unsigned offset;
-                hva_t guest_buf;
-
-                paddr = gva_to_hpa(vcpu, addr);
-
-                if (is_error_hpa(paddr))
-                        break;
-
-                guest_buf = (hva_t)kmap_atomic(
-                                        pfn_to_page(paddr >> PAGE_SHIFT),
-                                        KM_USER0);
-                offset = addr & ~PAGE_MASK;
-                guest_buf |= offset;
-                now = min(size, PAGE_SIZE - offset);
-                memcpy(host_buf, (void*)guest_buf, now);
-                host_buf += now;
-                addr += now;
-                size -= now;
-                kunmap_atomic((void *)(guest_buf & PAGE_MASK), KM_USER0);
-        }
-        return req_size - size;
-}
-EXPORT_SYMBOL_GPL(kvm_read_guest);
-
-int kvm_write_guest(struct kvm_vcpu *vcpu, gva_t addr, unsigned long size,
-                    void *data)
-{
-        unsigned char *host_buf = data;
-        unsigned long req_size = size;
-
-        while (size) {
-                hpa_t paddr;
-                unsigned now;
-                unsigned offset;
-                hva_t guest_buf;
-                gfn_t gfn;
-
-                paddr = gva_to_hpa(vcpu, addr);
-
-                if (is_error_hpa(paddr))
-                        break;
-
-                gfn = vcpu->mmu.gva_to_gpa(vcpu, addr) >> PAGE_SHIFT;
-                mark_page_dirty(vcpu->kvm, gfn);
-                guest_buf = (hva_t)kmap_atomic(
-                                pfn_to_page(paddr >> PAGE_SHIFT), KM_USER0);
-                offset = addr & ~PAGE_MASK;
-                guest_buf |= offset;
-                now = min(size, PAGE_SIZE - offset);
-                memcpy((void*)guest_buf, host_buf, now);
-                host_buf += now;
-                addr += now;
-                size -= now;
-                kunmap_atomic((void *)(guest_buf & PAGE_MASK), KM_USER0);
-        }
-        return req_size - size;
-}
-EXPORT_SYMBOL_GPL(kvm_write_guest);
-
 void kvm_load_guest_fpu(struct kvm_vcpu *vcpu)
 {
         if (!vcpu->fpu_active || vcpu->guest_fpu_loaded)
                 return;
 
         vcpu->guest_fpu_loaded = 1;
-        fx_save(vcpu->host_fx_image);
-        fx_restore(vcpu->guest_fx_image);
+        fx_save(&vcpu->host_fx_image);
+        fx_restore(&vcpu->guest_fx_image);
 }
 EXPORT_SYMBOL_GPL(kvm_load_guest_fpu);
 
@@ -224,8 +168,8 @@ void kvm_put_guest_fpu(struct kvm_vcpu *vcpu)
                 return;
 
         vcpu->guest_fpu_loaded = 0;
-        fx_save(vcpu->guest_fx_image);
-        fx_restore(vcpu->host_fx_image);
+        fx_save(&vcpu->guest_fx_image);
+        fx_restore(&vcpu->host_fx_image);
 }
 EXPORT_SYMBOL_GPL(kvm_put_guest_fpu);
 
@@ -234,13 +178,21 @@ EXPORT_SYMBOL_GPL(kvm_put_guest_fpu);
  */
 static void vcpu_load(struct kvm_vcpu *vcpu)
 {
+        int cpu;
+
         mutex_lock(&vcpu->mutex);
-        kvm_arch_ops->vcpu_load(vcpu);
+        cpu = get_cpu();
+        preempt_notifier_register(&vcpu->preempt_notifier);
+        kvm_x86_ops->vcpu_load(vcpu, cpu);
+        put_cpu();
 }
 
 static void vcpu_put(struct kvm_vcpu *vcpu)
 {
-        kvm_arch_ops->vcpu_put(vcpu);
+        preempt_disable();
+        kvm_x86_ops->vcpu_put(vcpu);
+        preempt_notifier_unregister(&vcpu->preempt_notifier);
+        preempt_enable();
         mutex_unlock(&vcpu->mutex);
 }
 
@@ -261,8 +213,10 @@ void kvm_flush_remote_tlbs(struct kvm *kvm)
         atomic_set(&completed, 0);
         cpus_clear(cpus);
         needed = 0;
-        for (i = 0; i < kvm->nvcpus; ++i) {
-                vcpu = &kvm->vcpus[i];
+        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                vcpu = kvm->vcpus[i];
+                if (!vcpu)
+                        continue;
                 if (test_and_set_bit(KVM_TLB_FLUSH, &vcpu->requests))
                         continue;
                 cpu = vcpu->cpu;
@@ -286,37 +240,79 @@ void kvm_flush_remote_tlbs(struct kvm *kvm)
         }
 }
 
+int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id)
+{
+        struct page *page;
+        int r;
+
+        mutex_init(&vcpu->mutex);
+        vcpu->cpu = -1;
+        vcpu->mmu.root_hpa = INVALID_PAGE;
+        vcpu->kvm = kvm;
+        vcpu->vcpu_id = id;
+        if (!irqchip_in_kernel(kvm) || id == 0)
+                vcpu->mp_state = VCPU_MP_STATE_RUNNABLE;
+        else
+                vcpu->mp_state = VCPU_MP_STATE_UNINITIALIZED;
+        init_waitqueue_head(&vcpu->wq);
+
+        page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+        if (!page) {
+                r = -ENOMEM;
+                goto fail;
+        }
+        vcpu->run = page_address(page);
+
+        page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+        if (!page) {
+                r = -ENOMEM;
+                goto fail_free_run;
+        }
+        vcpu->pio_data = page_address(page);
+
+        r = kvm_mmu_create(vcpu);
+        if (r < 0)
+                goto fail_free_pio_data;
+
+        return 0;
+
+fail_free_pio_data:
+        free_page((unsigned long)vcpu->pio_data);
+fail_free_run:
+        free_page((unsigned long)vcpu->run);
+fail:
+        return -ENOMEM;
+}
+EXPORT_SYMBOL_GPL(kvm_vcpu_init);
+
+void kvm_vcpu_uninit(struct kvm_vcpu *vcpu)
+{
+        kvm_mmu_destroy(vcpu);
+        if (vcpu->apic)
+                hrtimer_cancel(&vcpu->apic->timer.dev);
+        kvm_free_apic(vcpu->apic);
+        free_page((unsigned long)vcpu->pio_data);
+        free_page((unsigned long)vcpu->run);
+}
+EXPORT_SYMBOL_GPL(kvm_vcpu_uninit);
+
 static struct kvm *kvm_create_vm(void)
 {
         struct kvm *kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
-        int i;
 
         if (!kvm)
                 return ERR_PTR(-ENOMEM);
 
         kvm_io_bus_init(&kvm->pio_bus);
-        spin_lock_init(&kvm->lock);
+        mutex_init(&kvm->lock);
         INIT_LIST_HEAD(&kvm->active_mmu_pages);
         kvm_io_bus_init(&kvm->mmio_bus);
-        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                struct kvm_vcpu *vcpu = &kvm->vcpus[i];
-
-                mutex_init(&vcpu->mutex);
-                vcpu->cpu = -1;
-                vcpu->kvm = kvm;
-                vcpu->mmu.root_hpa = INVALID_PAGE;
-        }
         spin_lock(&kvm_lock);
         list_add(&kvm->vm_list, &vm_list);
         spin_unlock(&kvm_lock);
         return kvm;
 }
 
-static int kvm_dev_open(struct inode *inode, struct file *filp)
-{
-        return 0;
-}
-
 /*
  * Free any memory in @free but not in @dont.
  */
@@ -353,7 +349,7 @@ static void free_pio_guest_pages(struct kvm_vcpu *vcpu)
 {
         int i;
 
-        for (i = 0; i < 2; ++i)
+        for (i = 0; i < ARRAY_SIZE(vcpu->pio.guest_pages); ++i)
                 if (vcpu->pio.guest_pages[i]) {
                         __free_page(vcpu->pio.guest_pages[i]);
                         vcpu->pio.guest_pages[i] = NULL;
@@ -362,30 +358,11 @@ static void free_pio_guest_pages(struct kvm_vcpu *vcpu)
 
 static void kvm_unload_vcpu_mmu(struct kvm_vcpu *vcpu)
 {
-        if (!vcpu->vmcs)
-                return;
-
         vcpu_load(vcpu);
         kvm_mmu_unload(vcpu);
         vcpu_put(vcpu);
 }
 
-static void kvm_free_vcpu(struct kvm_vcpu *vcpu)
-{
-        if (!vcpu->vmcs)
-                return;
-
-        vcpu_load(vcpu);
-        kvm_mmu_destroy(vcpu);
-        vcpu_put(vcpu);
-        kvm_arch_ops->vcpu_free(vcpu);
-        free_page((unsigned long)vcpu->run);
-        vcpu->run = NULL;
-        free_page((unsigned long)vcpu->pio_data);
-        vcpu->pio_data = NULL;
-        free_pio_guest_pages(vcpu);
-}
-
 static void kvm_free_vcpus(struct kvm *kvm)
 {
         unsigned int i;
@@ -394,14 +371,15 @@ static void kvm_free_vcpus(struct kvm *kvm)
          * Unpin any mmu pages first.
          */
         for (i = 0; i < KVM_MAX_VCPUS; ++i)
-                kvm_unload_vcpu_mmu(&kvm->vcpus[i]);
-        for (i = 0; i < KVM_MAX_VCPUS; ++i)
-                kvm_free_vcpu(&kvm->vcpus[i]);
-}
+                if (kvm->vcpus[i])
+                        kvm_unload_vcpu_mmu(kvm->vcpus[i]);
+        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                if (kvm->vcpus[i]) {
+                        kvm_x86_ops->vcpu_free(kvm->vcpus[i]);
+                        kvm->vcpus[i] = NULL;
+                }
+        }
 
-static int kvm_dev_release(struct inode *inode, struct file *filp)
-{
-        return 0;
 }
 
 static void kvm_destroy_vm(struct kvm *kvm)
@@ -411,6 +389,8 @@ static void kvm_destroy_vm(struct kvm *kvm)
         spin_unlock(&kvm_lock);
         kvm_io_bus_destroy(&kvm->pio_bus);
         kvm_io_bus_destroy(&kvm->mmio_bus);
+        kfree(kvm->vpic);
+        kfree(kvm->vioapic);
         kvm_free_vcpus(kvm);
         kvm_free_physmem(kvm);
         kfree(kvm);
@@ -426,7 +406,7 @@ static int kvm_vm_release(struct inode *inode, struct file *filp)
 
 static void inject_gp(struct kvm_vcpu *vcpu)
 {
-        kvm_arch_ops->inject_gp(vcpu, 0);
+        kvm_x86_ops->inject_gp(vcpu, 0);
 }
 
 /*
@@ -437,58 +417,60 @@ static int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3)
         gfn_t pdpt_gfn = cr3 >> PAGE_SHIFT;
         unsigned offset = ((cr3 & (PAGE_SIZE-1)) >> 5) << 2;
         int i;
-        u64 pdpte;
         u64 *pdpt;
         int ret;
         struct page *page;
+        u64 pdpte[ARRAY_SIZE(vcpu->pdptrs)];
 
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&vcpu->kvm->lock);
         page = gfn_to_page(vcpu->kvm, pdpt_gfn);
-        /* FIXME: !page - emulate? 0xff? */
+        if (!page) {
+                ret = 0;
+                goto out;
+        }
+
         pdpt = kmap_atomic(page, KM_USER0);
+        memcpy(pdpte, pdpt+offset, sizeof(pdpte));
+        kunmap_atomic(pdpt, KM_USER0);
 
-        ret = 1;
-        for (i = 0; i < 4; ++i) {
-                pdpte = pdpt[offset + i];
-                if ((pdpte & 1) && (pdpte & 0xfffffff0000001e6ull)) {
+        for (i = 0; i < ARRAY_SIZE(pdpte); ++i) {
+                if ((pdpte[i] & 1) && (pdpte[i] & 0xfffffff0000001e6ull)) {
                         ret = 0;
                         goto out;
                 }
         }
+        ret = 1;
 
-        for (i = 0; i < 4; ++i)
-                vcpu->pdptrs[i] = pdpt[offset + i];
-
+        memcpy(vcpu->pdptrs, pdpte, sizeof(vcpu->pdptrs));
 out:
-        kunmap_atomic(pdpt, KM_USER0);
-        spin_unlock(&vcpu->kvm->lock);
+        mutex_unlock(&vcpu->kvm->lock);
 
         return ret;
 }
 
 void set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 {
-        if (cr0 & CR0_RESEVED_BITS) {
+        if (cr0 & CR0_RESERVED_BITS) {
                 printk(KERN_DEBUG "set_cr0: 0x%lx #GP, reserved bits 0x%lx\n",
                        cr0, vcpu->cr0);
                 inject_gp(vcpu);
                 return;
         }
 
-        if ((cr0 & CR0_NW_MASK) && !(cr0 & CR0_CD_MASK)) {
+        if ((cr0 & X86_CR0_NW) && !(cr0 & X86_CR0_CD)) {
                 printk(KERN_DEBUG "set_cr0: #GP, CD == 0 && NW == 1\n");
                 inject_gp(vcpu);
                 return;
         }
 
-        if ((cr0 & CR0_PG_MASK) && !(cr0 & CR0_PE_MASK)) {
+        if ((cr0 & X86_CR0_PG) && !(cr0 & X86_CR0_PE)) {
                 printk(KERN_DEBUG "set_cr0: #GP, set PG flag "
                        "and a clear PE flag\n");
                 inject_gp(vcpu);
                 return;
         }
 
-        if (!is_paging(vcpu) && (cr0 & CR0_PG_MASK)) {
+        if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) {
 #ifdef CONFIG_X86_64
                 if ((vcpu->shadow_efer & EFER_LME)) {
                         int cs_db, cs_l;
@@ -499,7 +481,7 @@ void set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
                                 inject_gp(vcpu);
                                 return;
                         }
-                        kvm_arch_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);
+                        kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);
                         if (cs_l) {
                                 printk(KERN_DEBUG "set_cr0: #GP, start paging "
                                        "in long mode while CS.L == 1\n");
@@ -518,12 +500,12 @@ void set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 
         }
 
-        kvm_arch_ops->set_cr0(vcpu, cr0);
+        kvm_x86_ops->set_cr0(vcpu, cr0);
         vcpu->cr0 = cr0;
 
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&vcpu->kvm->lock);
         kvm_mmu_reset_context(vcpu);
-        spin_unlock(&vcpu->kvm->lock);
+        mutex_unlock(&vcpu->kvm->lock);
         return;
 }
 EXPORT_SYMBOL_GPL(set_cr0);
@@ -536,62 +518,72 @@ EXPORT_SYMBOL_GPL(lmsw);
 
 void set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
 {
-        if (cr4 & CR4_RESEVED_BITS) {
+        if (cr4 & CR4_RESERVED_BITS) {
                 printk(KERN_DEBUG "set_cr4: #GP, reserved bits\n");
                 inject_gp(vcpu);
                 return;
         }
 
         if (is_long_mode(vcpu)) {
-                if (!(cr4 & CR4_PAE_MASK)) {
+                if (!(cr4 & X86_CR4_PAE)) {
                         printk(KERN_DEBUG "set_cr4: #GP, clearing PAE while "
                                "in long mode\n");
                         inject_gp(vcpu);
                         return;
                 }
-        } else if (is_paging(vcpu) && !is_pae(vcpu) && (cr4 & CR4_PAE_MASK)
+        } else if (is_paging(vcpu) && !is_pae(vcpu) && (cr4 & X86_CR4_PAE)
                    && !load_pdptrs(vcpu, vcpu->cr3)) {
                 printk(KERN_DEBUG "set_cr4: #GP, pdptrs reserved bits\n");
                 inject_gp(vcpu);
+                return;
         }
 
-        if (cr4 & CR4_VMXE_MASK) {
+        if (cr4 & X86_CR4_VMXE) {
                 printk(KERN_DEBUG "set_cr4: #GP, setting VMXE\n");
                 inject_gp(vcpu);
                 return;
         }
-        kvm_arch_ops->set_cr4(vcpu, cr4);
-        spin_lock(&vcpu->kvm->lock);
+        kvm_x86_ops->set_cr4(vcpu, cr4);
+        vcpu->cr4 = cr4;
+        mutex_lock(&vcpu->kvm->lock);
         kvm_mmu_reset_context(vcpu);
-        spin_unlock(&vcpu->kvm->lock);
+        mutex_unlock(&vcpu->kvm->lock);
 }
 EXPORT_SYMBOL_GPL(set_cr4);
 
 void set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
 {
         if (is_long_mode(vcpu)) {
-                if (cr3 & CR3_L_MODE_RESEVED_BITS) {
+                if (cr3 & CR3_L_MODE_RESERVED_BITS) {
                         printk(KERN_DEBUG "set_cr3: #GP, reserved bits\n");
                         inject_gp(vcpu);
                         return;
                 }
         } else {
-                if (cr3 & CR3_RESEVED_BITS) {
-                        printk(KERN_DEBUG "set_cr3: #GP, reserved bits\n");
-                        inject_gp(vcpu);
-                        return;
-                }
-                if (is_paging(vcpu) && is_pae(vcpu) &&
-                    !load_pdptrs(vcpu, cr3)) {
-                        printk(KERN_DEBUG "set_cr3: #GP, pdptrs "
-                               "reserved bits\n");
-                        inject_gp(vcpu);
-                        return;
+                if (is_pae(vcpu)) {
+                        if (cr3 & CR3_PAE_RESERVED_BITS) {
+                                printk(KERN_DEBUG
+                                       "set_cr3: #GP, reserved bits\n");
+                                inject_gp(vcpu);
+                                return;
+                        }
+                        if (is_paging(vcpu) && !load_pdptrs(vcpu, cr3)) {
+                                printk(KERN_DEBUG "set_cr3: #GP, pdptrs "
+                                       "reserved bits\n");
+                                inject_gp(vcpu);
+                                return;
+                        }
+                } else {
+                        if (cr3 & CR3_NONPAE_RESERVED_BITS) {
+                                printk(KERN_DEBUG
+                                       "set_cr3: #GP, reserved bits\n");
+                                inject_gp(vcpu);
+                                return;
+                        }
                 }
         }
 
-        vcpu->cr3 = cr3;
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&vcpu->kvm->lock);
         /*
          * Does the new cr3 value map to physical memory? (Note, we
          * catch an invalid cr3 even in real-mode, because it would
@@ -603,46 +595,73 @@ void set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
          */
         if (unlikely(!gfn_to_memslot(vcpu->kvm, cr3 >> PAGE_SHIFT)))
                 inject_gp(vcpu);
-        else
+        else {
+                vcpu->cr3 = cr3;
                 vcpu->mmu.new_cr3(vcpu);
-        spin_unlock(&vcpu->kvm->lock);
+        }
+        mutex_unlock(&vcpu->kvm->lock);
 }
 EXPORT_SYMBOL_GPL(set_cr3);
 
 void set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8)
 {
-        if ( cr8 & CR8_RESEVED_BITS) {
+        if (cr8 & CR8_RESERVED_BITS) {
                 printk(KERN_DEBUG "set_cr8: #GP, reserved bits 0x%lx\n", cr8);
                 inject_gp(vcpu);
                 return;
         }
-        vcpu->cr8 = cr8;
+        if (irqchip_in_kernel(vcpu->kvm))
+                kvm_lapic_set_tpr(vcpu, cr8);
+        else
+                vcpu->cr8 = cr8;
 }
 EXPORT_SYMBOL_GPL(set_cr8);
 
-void fx_init(struct kvm_vcpu *vcpu)
+unsigned long get_cr8(struct kvm_vcpu *vcpu)
+{
+        if (irqchip_in_kernel(vcpu->kvm))
+                return kvm_lapic_get_cr8(vcpu);
+        else
+                return vcpu->cr8;
+}
+EXPORT_SYMBOL_GPL(get_cr8);
+
+u64 kvm_get_apic_base(struct kvm_vcpu *vcpu)
 {
-        struct __attribute__ ((__packed__)) fx_image_s {
-                u16 control; //fcw
-                u16 status; //fsw
-                u16 tag; // ftw
-                u16 opcode; //fop
-                u64 ip; // fpu ip
-                u64 operand;// fpu dp
-                u32 mxcsr;
-                u32 mxcsr_mask;
+        if (irqchip_in_kernel(vcpu->kvm))
+                return vcpu->apic_base;
+        else
+                return vcpu->apic_base;
+}
+EXPORT_SYMBOL_GPL(kvm_get_apic_base);
 
-        } *fx_image;
+void kvm_set_apic_base(struct kvm_vcpu *vcpu, u64 data)
+{
+        /* TODO: reserve bits check */
+        if (irqchip_in_kernel(vcpu->kvm))
+                kvm_lapic_set_base(vcpu, data);
+        else
+                vcpu->apic_base = data;
+}
+EXPORT_SYMBOL_GPL(kvm_set_apic_base);
+
+void fx_init(struct kvm_vcpu *vcpu)
+{
+        unsigned after_mxcsr_mask;
 
-        fx_save(vcpu->host_fx_image);
+        /* Initialize guest FPU by resetting ours and saving into guest's */
+        preempt_disable();
+        fx_save(&vcpu->host_fx_image);
         fpu_init();
-        fx_save(vcpu->guest_fx_image);
-        fx_restore(vcpu->host_fx_image);
+        fx_save(&vcpu->guest_fx_image);
+        fx_restore(&vcpu->host_fx_image);
+        preempt_enable();
 
-        fx_image = (struct fx_image_s *)vcpu->guest_fx_image;
-        fx_image->mxcsr = 0x1f80;
-        memset(vcpu->guest_fx_image + sizeof(struct fx_image_s),
-               0, FX_IMAGE_SIZE - sizeof(struct fx_image_s));
+        vcpu->cr0 |= X86_CR0_ET;
+        after_mxcsr_mask = offsetof(struct i387_fxsave_struct, st_space);
+        vcpu->guest_fx_image.mxcsr = 0x1f80;
+        memset((void *)&vcpu->guest_fx_image + after_mxcsr_mask,
+               0, sizeof(struct i387_fxsave_struct) - after_mxcsr_mask);
 }
 EXPORT_SYMBOL_GPL(fx_init);
 
@@ -661,7 +680,6 @@ static int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
         unsigned long i;
         struct kvm_memory_slot *memslot;
         struct kvm_memory_slot old, new;
-        int memory_config_version;
 
         r = -EINVAL;
         /* General sanity checks */
@@ -681,10 +699,8 @@ static int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
         if (!npages)
                 mem->flags &= ~KVM_MEM_LOG_DIRTY_PAGES;
 
-raced:
-        spin_lock(&kvm->lock);
+        mutex_lock(&kvm->lock);
 
-        memory_config_version = kvm->memory_config_version;
         new = old = *memslot;
 
         new.base_gfn = base_gfn;
@@ -707,11 +723,6 @@ raced:
                       (base_gfn >= s->base_gfn + s->npages)))
                         goto out_unlock;
         }
-        /*
-         * Do memory allocations outside lock.  memory_config_version will
-         * detect any races.
-         */
-        spin_unlock(&kvm->lock);
 
         /* Deallocate if slot is being removed */
         if (!npages)
@@ -728,14 +739,14 @@ raced:
                 new.phys_mem = vmalloc(npages * sizeof(struct page *));
 
                 if (!new.phys_mem)
-                        goto out_free;
+                        goto out_unlock;
 
                 memset(new.phys_mem, 0, npages * sizeof(struct page *));
                 for (i = 0; i < npages; ++i) {
                         new.phys_mem[i] = alloc_page(GFP_HIGHUSER
                                                      | __GFP_ZERO);
                         if (!new.phys_mem[i])
-                                goto out_free;
+                                goto out_unlock;
                         set_page_private(new.phys_mem[i],0);
                 }
         }
@@ -746,39 +757,25 @@ raced:
 
                 new.dirty_bitmap = vmalloc(dirty_bytes);
                 if (!new.dirty_bitmap)
-                        goto out_free;
+                        goto out_unlock;
                 memset(new.dirty_bitmap, 0, dirty_bytes);
         }
 
-        spin_lock(&kvm->lock);
-
-        if (memory_config_version != kvm->memory_config_version) {
-                spin_unlock(&kvm->lock);
-                kvm_free_physmem_slot(&new, &old);
-                goto raced;
-        }
-
-        r = -EAGAIN;
-        if (kvm->busy)
-                goto out_unlock;
-
         if (mem->slot >= kvm->nmemslots)
                 kvm->nmemslots = mem->slot + 1;
 
         *memslot = new;
-        ++kvm->memory_config_version;
 
         kvm_mmu_slot_remove_write_access(kvm, mem->slot);
         kvm_flush_remote_tlbs(kvm);
 
-        spin_unlock(&kvm->lock);
+        mutex_unlock(&kvm->lock);
 
         kvm_free_physmem_slot(&old, &new);
         return 0;
 
 out_unlock:
-        spin_unlock(&kvm->lock);
-out_free:
+        mutex_unlock(&kvm->lock);
         kvm_free_physmem_slot(&new, &old);
 out:
         return r;
@@ -795,14 +792,8 @@ static int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
         int n;
         unsigned long any = 0;
 
-        spin_lock(&kvm->lock);
+        mutex_lock(&kvm->lock);
 
-        /*
-         * Prevent changes to guest memory configuration even while the lock
-         * is not taken.
-         */
-        ++kvm->busy;
-        spin_unlock(&kvm->lock);
         r = -EINVAL;
         if (log->slot >= KVM_MEMORY_SLOTS)
                 goto out;
@@ -821,18 +812,17 @@ static int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
         if (copy_to_user(log->dirty_bitmap, memslot->dirty_bitmap, n))
                 goto out;
 
-        spin_lock(&kvm->lock);
-        kvm_mmu_slot_remove_write_access(kvm, log->slot);
-        kvm_flush_remote_tlbs(kvm);
-        memset(memslot->dirty_bitmap, 0, n);
-        spin_unlock(&kvm->lock);
+        /* If nothing is dirty, don't bother messing with page tables. */
+        if (any) {
+                kvm_mmu_slot_remove_write_access(kvm, log->slot);
+                kvm_flush_remote_tlbs(kvm);
+                memset(memslot->dirty_bitmap, 0, n);
+        }
 
         r = 0;
 
 out:
-        spin_lock(&kvm->lock);
-        --kvm->busy;
-        spin_unlock(&kvm->lock);
+        mutex_unlock(&kvm->lock);
         return r;
 }
 
@@ -862,7 +852,7 @@ static int kvm_vm_ioctl_set_memory_alias(struct kvm *kvm,
             < alias->target_phys_addr)
                 goto out;
 
-        spin_lock(&kvm->lock);
+        mutex_lock(&kvm->lock);
 
         p = &kvm->aliases[alias->slot];
         p->base_gfn = alias->guest_phys_addr >> PAGE_SHIFT;
@@ -876,7 +866,7 @@ static int kvm_vm_ioctl_set_memory_alias(struct kvm *kvm,
 
         kvm_mmu_zap_all(kvm);
 
-        spin_unlock(&kvm->lock);
+        mutex_unlock(&kvm->lock);
 
         return 0;
 
@@ -884,6 +874,63 @@ out:
         return r;
 }
 
+static int kvm_vm_ioctl_get_irqchip(struct kvm *kvm, struct kvm_irqchip *chip)
+{
+        int r;
+
+        r = 0;
+        switch (chip->chip_id) {
+        case KVM_IRQCHIP_PIC_MASTER:
+                memcpy (&chip->chip.pic,
+                        &pic_irqchip(kvm)->pics[0],
+                        sizeof(struct kvm_pic_state));
+                break;
+        case KVM_IRQCHIP_PIC_SLAVE:
+                memcpy (&chip->chip.pic,
+                        &pic_irqchip(kvm)->pics[1],
+                        sizeof(struct kvm_pic_state));
+                break;
+        case KVM_IRQCHIP_IOAPIC:
+                memcpy (&chip->chip.ioapic,
+                        ioapic_irqchip(kvm),
+                        sizeof(struct kvm_ioapic_state));
+                break;
+        default:
+                r = -EINVAL;
+                break;
+        }
+        return r;
+}
+
+static int kvm_vm_ioctl_set_irqchip(struct kvm *kvm, struct kvm_irqchip *chip)
+{
+        int r;
+
+        r = 0;
+        switch (chip->chip_id) {
+        case KVM_IRQCHIP_PIC_MASTER:
+                memcpy (&pic_irqchip(kvm)->pics[0],
+                        &chip->chip.pic,
+                        sizeof(struct kvm_pic_state));
+                break;
+        case KVM_IRQCHIP_PIC_SLAVE:
+                memcpy (&pic_irqchip(kvm)->pics[1],
+                        &chip->chip.pic,
+                        sizeof(struct kvm_pic_state));
+                break;
+        case KVM_IRQCHIP_IOAPIC:
+                memcpy (ioapic_irqchip(kvm),
+                        &chip->chip.ioapic,
+                        sizeof(struct kvm_ioapic_state));
+                break;
+        default:
+                r = -EINVAL;
+                break;
+        }
+        kvm_pic_update_irq(pic_irqchip(kvm));
+        return r;
+}
+
 static gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn)
 {
         int i;
@@ -930,37 +977,26 @@ struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn)
 }
 EXPORT_SYMBOL_GPL(gfn_to_page);
 
+/* WARNING: Does not work on aliased pages. */
 void mark_page_dirty(struct kvm *kvm, gfn_t gfn)
 {
-        int i;
         struct kvm_memory_slot *memslot;
-        unsigned long rel_gfn;
 
-        for (i = 0; i < kvm->nmemslots; ++i) {
-                memslot = &kvm->memslots[i];
-
-                if (gfn >= memslot->base_gfn
-                    && gfn < memslot->base_gfn + memslot->npages) {
+        memslot = __gfn_to_memslot(kvm, gfn);
+        if (memslot && memslot->dirty_bitmap) {
+                unsigned long rel_gfn = gfn - memslot->base_gfn;
 
-                        if (!memslot->dirty_bitmap)
-                                return;
-
-                        rel_gfn = gfn - memslot->base_gfn;
-
-                        /* avoid RMW */
-                        if (!test_bit(rel_gfn, memslot->dirty_bitmap))
-                                set_bit(rel_gfn, memslot->dirty_bitmap);
-                        return;
-                }
+                /* avoid RMW */
+                if (!test_bit(rel_gfn, memslot->dirty_bitmap))
+                        set_bit(rel_gfn, memslot->dirty_bitmap);
         }
 }
 
-static int emulator_read_std(unsigned long addr,
+int emulator_read_std(unsigned long addr,
                              void *val,
                              unsigned int bytes,
-                             struct x86_emulate_ctxt *ctxt)
+                             struct kvm_vcpu *vcpu)
 {
-        struct kvm_vcpu *vcpu = ctxt->vcpu;
         void *data = val;
 
         while (bytes) {
@@ -990,26 +1026,42 @@ static int emulator_read_std(unsigned long addr,
 
         return X86EMUL_CONTINUE;
 }
+EXPORT_SYMBOL_GPL(emulator_read_std);
 
 static int emulator_write_std(unsigned long addr,
                               const void *val,
                               unsigned int bytes,
-                              struct x86_emulate_ctxt *ctxt)
+                              struct kvm_vcpu *vcpu)
 {
-        printk(KERN_ERR "emulator_write_std: addr %lx n %d\n",
-               addr, bytes);
+        pr_unimpl(vcpu, "emulator_write_std: addr %lx n %d\n", addr, bytes);
         return X86EMUL_UNHANDLEABLE;
 }
 
+/*
+ * Only apic need an MMIO device hook, so shortcut now..
+ */
+static struct kvm_io_device *vcpu_find_pervcpu_dev(struct kvm_vcpu *vcpu,
+                                                gpa_t addr)
+{
+        struct kvm_io_device *dev;
+
+        if (vcpu->apic) {
+                dev = &vcpu->apic->dev;
+                if (dev->in_range(dev, addr))
+                        return dev;
+        }
+        return NULL;
+}
+
 static struct kvm_io_device *vcpu_find_mmio_dev(struct kvm_vcpu *vcpu,
                                                 gpa_t addr)
 {
-        /*
-         * Note that its important to have this wrapper function because
-         * in the very near future we will be checking for MMIOs against
-         * the LAPIC as well as the general MMIO bus
-         */
-        return kvm_io_bus_find_dev(&vcpu->kvm->mmio_bus, addr);
+        struct kvm_io_device *dev;
+
+        dev = vcpu_find_pervcpu_dev(vcpu, addr);
+        if (dev == NULL)
+                dev = kvm_io_bus_find_dev(&vcpu->kvm->mmio_bus, addr);
+        return dev;
 }
 
 static struct kvm_io_device *vcpu_find_pio_dev(struct kvm_vcpu *vcpu,
@@ -1021,9 +1073,8 @@ static struct kvm_io_device *vcpu_find_pio_dev(struct kvm_vcpu *vcpu,
 static int emulator_read_emulated(unsigned long addr,
                                   void *val,
                                   unsigned int bytes,
-                                  struct x86_emulate_ctxt *ctxt)
+                                  struct kvm_vcpu *vcpu)
 {
-        struct kvm_vcpu      *vcpu = ctxt->vcpu;
         struct kvm_io_device *mmio_dev;
         gpa_t                 gpa;
 
@@ -1031,7 +1082,7 @@ static int emulator_read_emulated(unsigned long addr,
                 memcpy(val, vcpu->mmio_data, bytes);
                 vcpu->mmio_read_completed = 0;
                 return X86EMUL_CONTINUE;
-        } else if (emulator_read_std(addr, val, bytes, ctxt)
+        } else if (emulator_read_std(addr, val, bytes, vcpu)
                    == X86EMUL_CONTINUE)
                 return X86EMUL_CONTINUE;
 
@@ -1061,7 +1112,6 @@ static int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
 {
         struct page *page;
         void *virt;
-        unsigned offset = offset_in_page(gpa);
 
         if (((gpa + bytes - 1) >> PAGE_SHIFT) != (gpa >> PAGE_SHIFT))
                 return 0;
@@ -1070,7 +1120,7 @@ static int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
                 return 0;
         mark_page_dirty(vcpu->kvm, gpa >> PAGE_SHIFT);
         virt = kmap_atomic(page, KM_USER0);
-        kvm_mmu_pte_write(vcpu, gpa, virt + offset, val, bytes);
+        kvm_mmu_pte_write(vcpu, gpa, val, bytes);
         memcpy(virt + offset_in_page(gpa), val, bytes);
         kunmap_atomic(virt, KM_USER0);
         return 1;
@@ -1079,14 +1129,13 @@ static int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
 static int emulator_write_emulated_onepage(unsigned long addr,
                                            const void *val,
                                            unsigned int bytes,
-                                           struct x86_emulate_ctxt *ctxt)
+                                           struct kvm_vcpu *vcpu)
 {
-        struct kvm_vcpu      *vcpu = ctxt->vcpu;
         struct kvm_io_device *mmio_dev;
         gpa_t                 gpa = vcpu->mmu.gva_to_gpa(vcpu, addr);
 
         if (gpa == UNMAPPED_GVA) {
-                kvm_arch_ops->inject_page_fault(vcpu, addr, 2);
+                kvm_x86_ops->inject_page_fault(vcpu, addr, 2);
                 return X86EMUL_PROPAGATE_FAULT;
         }
 
@@ -1111,31 +1160,32 @@ static int emulator_write_emulated_onepage(unsigned long addr,
         return X86EMUL_CONTINUE;
 }
 
-static int emulator_write_emulated(unsigned long addr,
+int emulator_write_emulated(unsigned long addr,
                                    const void *val,
                                    unsigned int bytes,
-                                   struct x86_emulate_ctxt *ctxt)
+                                   struct kvm_vcpu *vcpu)
 {
         /* Crossing a page boundary? */
         if (((addr + bytes - 1) ^ addr) & PAGE_MASK) {
                 int rc, now;
 
                 now = -addr & ~PAGE_MASK;
-                rc = emulator_write_emulated_onepage(addr, val, now, ctxt);
+                rc = emulator_write_emulated_onepage(addr, val, now, vcpu);
                 if (rc != X86EMUL_CONTINUE)
                         return rc;
                 addr += now;
                 val += now;
                 bytes -= now;
         }
-        return emulator_write_emulated_onepage(addr, val, bytes, ctxt);
+        return emulator_write_emulated_onepage(addr, val, bytes, vcpu);
 }
+EXPORT_SYMBOL_GPL(emulator_write_emulated);
 
 static int emulator_cmpxchg_emulated(unsigned long addr,
                                      const void *old,
                                      const void *new,
                                      unsigned int bytes,
-                                     struct x86_emulate_ctxt *ctxt)
+                                     struct kvm_vcpu *vcpu)
 {
         static int reported;
 
@@ -1143,12 +1193,12 @@ static int emulator_cmpxchg_emulated(unsigned long addr,
                 reported = 1;
                 printk(KERN_WARNING "kvm: emulating exchange as write\n");
         }
-        return emulator_write_emulated(addr, new, bytes, ctxt);
+        return emulator_write_emulated(addr, new, bytes, vcpu);
 }
 
 static unsigned long get_segment_base(struct kvm_vcpu *vcpu, int seg)
 {
-        return kvm_arch_ops->get_segment_base(vcpu, seg);
+        return kvm_x86_ops->get_segment_base(vcpu, seg);
 }
 
 int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address)
@@ -1158,10 +1208,8 @@ int emulate_invlpg(struct kvm_vcpu *vcpu, gva_t address)
 
 int emulate_clts(struct kvm_vcpu *vcpu)
 {
-        unsigned long cr0;
-
-        cr0 = vcpu->cr0 & ~CR0_TS_MASK;
-        kvm_arch_ops->set_cr0(vcpu, cr0);
+        vcpu->cr0 &= ~X86_CR0_TS;
+        kvm_x86_ops->set_cr0(vcpu, vcpu->cr0);
         return X86EMUL_CONTINUE;
 }
 
@@ -1171,11 +1219,10 @@ int emulator_get_dr(struct x86_emulate_ctxt* ctxt, int dr, unsigned long *dest)
 
         switch (dr) {
         case 0 ... 3:
-                *dest = kvm_arch_ops->get_dr(vcpu, dr);
+                *dest = kvm_x86_ops->get_dr(vcpu, dr);
                 return X86EMUL_CONTINUE;
         default:
-                printk(KERN_DEBUG "%s: unexpected dr %u\n",
-                       __FUNCTION__, dr);
+                pr_unimpl(vcpu, "%s: unexpected dr %u\n", __FUNCTION__, dr);
                 return X86EMUL_UNHANDLEABLE;
         }
 }
@@ -1185,7 +1232,7 @@ int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr, unsigned long value)
         unsigned long mask = (ctxt->mode == X86EMUL_MODE_PROT64) ? ~0ULL : ~0U;
         int exception;
 
-        kvm_arch_ops->set_dr(ctxt->vcpu, dr, value & mask, &exception);
+        kvm_x86_ops->set_dr(ctxt->vcpu, dr, value & mask, &exception);
         if (exception) {
                 /* FIXME: better handling */
                 return X86EMUL_UNHANDLEABLE;
@@ -1193,25 +1240,25 @@ int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr, unsigned long value)
         return X86EMUL_CONTINUE;
 }
 
-static void report_emulation_failure(struct x86_emulate_ctxt *ctxt)
+void kvm_report_emulation_failure(struct kvm_vcpu *vcpu, const char *context)
 {
         static int reported;
         u8 opcodes[4];
-        unsigned long rip = ctxt->vcpu->rip;
+        unsigned long rip = vcpu->rip;
         unsigned long rip_linear;
 
-        rip_linear = rip + get_segment_base(ctxt->vcpu, VCPU_SREG_CS);
+        rip_linear = rip + get_segment_base(vcpu, VCPU_SREG_CS);
 
         if (reported)
                 return;
 
-        emulator_read_std(rip_linear, (void *)opcodes, 4, ctxt);
+        emulator_read_std(rip_linear, (void *)opcodes, 4, vcpu);
 
-        printk(KERN_ERR "emulation failed but !mmio_needed?"
-               " rip %lx %02x %02x %02x %02x\n",
-               rip, opcodes[0], opcodes[1], opcodes[2], opcodes[3]);
+        printk(KERN_ERR "emulation failed (%s) rip %lx %02x %02x %02x %02x\n",
+               context, rip, opcodes[0], opcodes[1], opcodes[2], opcodes[3]);
         reported = 1;
 }
+EXPORT_SYMBOL_GPL(kvm_report_emulation_failure);
 
 struct x86_emulate_ops emulate_ops = {
         .read_std            = emulator_read_std,
@@ -1231,12 +1278,12 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
         int cs_db, cs_l;
 
         vcpu->mmio_fault_cr2 = cr2;
-        kvm_arch_ops->cache_regs(vcpu);
+        kvm_x86_ops->cache_regs(vcpu);
 
-        kvm_arch_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);
+        kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l);
 
         emulate_ctxt.vcpu = vcpu;
-        emulate_ctxt.eflags = kvm_arch_ops->get_rflags(vcpu);
+        emulate_ctxt.eflags = kvm_x86_ops->get_rflags(vcpu);
         emulate_ctxt.cr2 = cr2;
         emulate_ctxt.mode = (emulate_ctxt.eflags & X86_EFLAGS_VM)
                 ? X86EMUL_MODE_REAL : cs_l
@@ -1259,9 +1306,13 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
         emulate_ctxt.fs_base = get_segment_base(vcpu, VCPU_SREG_FS);
 
         vcpu->mmio_is_write = 0;
+        vcpu->pio.string = 0;
         r = x86_emulate_memop(&emulate_ctxt, &emulate_ops);
+        if (vcpu->pio.string)
+                return EMULATE_DO_MMIO;
 
         if ((r || vcpu->mmio_is_write) && run) {
+                run->exit_reason = KVM_EXIT_MMIO;
                 run->mmio.phys_addr = vcpu->mmio_phys_addr;
                 memcpy(run->mmio.data, vcpu->mmio_data, 8);
                 run->mmio.len = vcpu->mmio_size;
@@ -1272,14 +1323,14 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
                 if (kvm_mmu_unprotect_page_virt(vcpu, cr2))
                         return EMULATE_DONE;
                 if (!vcpu->mmio_needed) {
-                        report_emulation_failure(&emulate_ctxt);
+                        kvm_report_emulation_failure(vcpu, "mmio");
                         return EMULATE_FAIL;
                 }
                 return EMULATE_DO_MMIO;
         }
 
-        kvm_arch_ops->decache_regs(vcpu);
-        kvm_arch_ops->set_rflags(vcpu, emulate_ctxt.eflags);
+        kvm_x86_ops->decache_regs(vcpu);
+        kvm_x86_ops->set_rflags(vcpu, emulate_ctxt.eflags);
 
         if (vcpu->mmio_is_write) {
                 vcpu->mmio_needed = 0;
@@ -1290,14 +1341,45 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
 }
 EXPORT_SYMBOL_GPL(emulate_instruction);
 
-int kvm_emulate_halt(struct kvm_vcpu *vcpu)
+/*
+ * The vCPU has executed a HLT instruction with in-kernel mode enabled.
+ */
+static void kvm_vcpu_block(struct kvm_vcpu *vcpu)
 {
-        if (vcpu->irq_summary)
-                return 1;
+        DECLARE_WAITQUEUE(wait, current);
 
-        vcpu->run->exit_reason = KVM_EXIT_HLT;
+        add_wait_queue(&vcpu->wq, &wait);
+
+        /*
+         * We will block until either an interrupt or a signal wakes us up
+         */
+        while (!kvm_cpu_has_interrupt(vcpu)
+               && !signal_pending(current)
+               && vcpu->mp_state != VCPU_MP_STATE_RUNNABLE
+               && vcpu->mp_state != VCPU_MP_STATE_SIPI_RECEIVED) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                vcpu_put(vcpu);
+                schedule();
+                vcpu_load(vcpu);
+        }
+
+        __set_current_state(TASK_RUNNING);
+        remove_wait_queue(&vcpu->wq, &wait);
+}
+
+int kvm_emulate_halt(struct kvm_vcpu *vcpu)
+{
         ++vcpu->stat.halt_exits;
-        return 0;
+        if (irqchip_in_kernel(vcpu->kvm)) {
+                vcpu->mp_state = VCPU_MP_STATE_HALTED;
+                kvm_vcpu_block(vcpu);
+                if (vcpu->mp_state != VCPU_MP_STATE_RUNNABLE)
+                        return -EINTR;
+                return 1;
+        } else {
+                vcpu->run->exit_reason = KVM_EXIT_HLT;
+                return 0;
+        }
 }
 EXPORT_SYMBOL_GPL(kvm_emulate_halt);
 
@@ -1305,7 +1387,7 @@ int kvm_hypercall(struct kvm_vcpu *vcpu, struct kvm_run *run)
 {
         unsigned long nr, a0, a1, a2, a3, a4, a5, ret;
 
-        kvm_arch_ops->cache_regs(vcpu);
+        kvm_x86_ops->cache_regs(vcpu);
         ret = -KVM_EINVAL;
 #ifdef CONFIG_X86_64
         if (is_long_mode(vcpu)) {
@@ -1329,6 +1411,7 @@ int kvm_hypercall(struct kvm_vcpu *vcpu, struct kvm_run *run)
         }
         switch (nr) {
         default:
+                run->hypercall.nr = nr;
                 run->hypercall.args[0] = a0;
                 run->hypercall.args[1] = a1;
                 run->hypercall.args[2] = a2;
@@ -1337,11 +1420,11 @@ int kvm_hypercall(struct kvm_vcpu *vcpu, struct kvm_run *run)
                 run->hypercall.args[5] = a5;
                 run->hypercall.ret = ret;
                 run->hypercall.longmode = is_long_mode(vcpu);
-                kvm_arch_ops->decache_regs(vcpu);
+                kvm_x86_ops->decache_regs(vcpu);
                 return 0;
         }
         vcpu->regs[VCPU_REGS_RAX] = ret;
-        kvm_arch_ops->decache_regs(vcpu);
+        kvm_x86_ops->decache_regs(vcpu);
         return 1;
 }
 EXPORT_SYMBOL_GPL(kvm_hypercall);
@@ -1355,26 +1438,26 @@ void realmode_lgdt(struct kvm_vcpu *vcpu, u16 limit, unsigned long base)
 {
         struct descriptor_table dt = { limit, base };
 
-        kvm_arch_ops->set_gdt(vcpu, &dt);
+        kvm_x86_ops->set_gdt(vcpu, &dt);
 }
 
 void realmode_lidt(struct kvm_vcpu *vcpu, u16 limit, unsigned long base)
 {
         struct descriptor_table dt = { limit, base };
 
-        kvm_arch_ops->set_idt(vcpu, &dt);
+        kvm_x86_ops->set_idt(vcpu, &dt);
 }
 
 void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw,
                    unsigned long *rflags)
 {
         lmsw(vcpu, msw);
-        *rflags = kvm_arch_ops->get_rflags(vcpu);
+        *rflags = kvm_x86_ops->get_rflags(vcpu);
 }
 
 unsigned long realmode_get_cr(struct kvm_vcpu *vcpu, int cr)
 {
-        kvm_arch_ops->decache_cr4_guest_bits(vcpu);
+        kvm_x86_ops->decache_cr4_guest_bits(vcpu);
         switch (cr) {
         case 0:
                 return vcpu->cr0;
@@ -1396,7 +1479,7 @@ void realmode_set_cr(struct kvm_vcpu *vcpu, int cr, unsigned long val,
         switch (cr) {
         case 0:
                 set_cr0(vcpu, mk_cr_64(vcpu->cr0, val));
-                *rflags = kvm_arch_ops->get_rflags(vcpu);
+                *rflags = kvm_x86_ops->get_rflags(vcpu);
                 break;
         case 2:
                 vcpu->cr2 = val;
@@ -1439,7 +1522,7 @@ static int vcpu_register_para(struct kvm_vcpu *vcpu, gpa_t para_state_gpa)
 
         mark_page_dirty(vcpu->kvm, para_state_gpa >> PAGE_SHIFT);
         para_state_page = pfn_to_page(para_state_hpa >> PAGE_SHIFT);
-        para_state = kmap_atomic(para_state_page, KM_USER0);
+        para_state = kmap(para_state_page);
 
         printk(KERN_DEBUG "....  guest version: %d\n", para_state->guest_version);
         printk(KERN_DEBUG "....           size: %d\n", para_state->size);
@@ -1470,12 +1553,12 @@ static int vcpu_register_para(struct kvm_vcpu *vcpu, gpa_t para_state_gpa)
         mark_page_dirty(vcpu->kvm, hypercall_gpa >> PAGE_SHIFT);
         hypercall = kmap_atomic(pfn_to_page(hypercall_hpa >> PAGE_SHIFT),
                                 KM_USER1) + (hypercall_hpa & ~PAGE_MASK);
-        kvm_arch_ops->patch_hypercall(vcpu, hypercall);
+        kvm_x86_ops->patch_hypercall(vcpu, hypercall);
         kunmap_atomic(hypercall, KM_USER1);
 
         para_state->ret = 0;
 err_kunmap_skip:
-        kunmap_atomic(para_state, KM_USER0);
+        kunmap(para_state_page);
         return 0;
 err_gp:
         return 1;
@@ -1511,7 +1594,7 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
                 data = 3;
                 break;
         case MSR_IA32_APICBASE:
-                data = vcpu->apic_base;
+                data = kvm_get_apic_base(vcpu);
                 break;
         case MSR_IA32_MISC_ENABLE:
                 data = vcpu->ia32_misc_enable_msr;
@@ -1522,7 +1605,7 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
                 break;
 #endif
         default:
-                printk(KERN_ERR "kvm: unhandled rdmsr: 0x%x\n", msr);
+                pr_unimpl(vcpu, "unhandled rdmsr: 0x%x\n", msr);
                 return 1;
         }
         *pdata = data;
@@ -1537,7 +1620,7 @@ EXPORT_SYMBOL_GPL(kvm_get_msr_common);
  */
 int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
 {
-        return kvm_arch_ops->get_msr(vcpu, msr_index, pdata);
+        return kvm_x86_ops->get_msr(vcpu, msr_index, pdata);
 }
 
 #ifdef CONFIG_X86_64
@@ -1558,7 +1641,7 @@ static void set_efer(struct kvm_vcpu *vcpu, u64 efer)
                 return;
         }
 
-        kvm_arch_ops->set_efer(vcpu, efer);
+        kvm_x86_ops->set_efer(vcpu, efer);
 
         efer &= ~EFER_LMA;
         efer |= vcpu->shadow_efer & EFER_LMA;
@@ -1577,11 +1660,11 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data)
                 break;
 #endif
         case MSR_IA32_MC0_STATUS:
-                printk(KERN_WARNING "%s: MSR_IA32_MC0_STATUS 0x%llx, nop\n",
+                pr_unimpl(vcpu, "%s: MSR_IA32_MC0_STATUS 0x%llx, nop\n",
                        __FUNCTION__, data);
                 break;
         case MSR_IA32_MCG_STATUS:
-                printk(KERN_WARNING "%s: MSR_IA32_MCG_STATUS 0x%llx, nop\n",
+                pr_unimpl(vcpu, "%s: MSR_IA32_MCG_STATUS 0x%llx, nop\n",
                         __FUNCTION__, data);
                 break;
         case MSR_IA32_UCODE_REV:
@@ -1589,7 +1672,7 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data)
         case 0x200 ... 0x2ff: /* MTRRs */
                 break;
         case MSR_IA32_APICBASE:
-                vcpu->apic_base = data;
+                kvm_set_apic_base(vcpu, data);
                 break;
         case MSR_IA32_MISC_ENABLE:
                 vcpu->ia32_misc_enable_msr = data;
@@ -1601,7 +1684,7 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data)
                 return vcpu_register_para(vcpu, data);
 
         default:
-                printk(KERN_ERR "kvm: unhandled wrmsr: 0x%x\n", msr);
+                pr_unimpl(vcpu, "unhandled wrmsr: 0x%x\n", msr);
                 return 1;
         }
         return 0;
@@ -1615,44 +1698,24 @@ EXPORT_SYMBOL_GPL(kvm_set_msr_common);
  */
 int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
 {
-        return kvm_arch_ops->set_msr(vcpu, msr_index, data);
+        return kvm_x86_ops->set_msr(vcpu, msr_index, data);
 }
 
 void kvm_resched(struct kvm_vcpu *vcpu)
 {
         if (!need_resched())
                 return;
-        vcpu_put(vcpu);
         cond_resched();
-        vcpu_load(vcpu);
 }
 EXPORT_SYMBOL_GPL(kvm_resched);
 
-void load_msrs(struct vmx_msr_entry *e, int n)
-{
-        int i;
-
-        for (i = 0; i < n; ++i)
-                wrmsrl(e[i].index, e[i].data);
-}
-EXPORT_SYMBOL_GPL(load_msrs);
-
-void save_msrs(struct vmx_msr_entry *e, int n)
-{
-        int i;
-
-        for (i = 0; i < n; ++i)
-                rdmsrl(e[i].index, e[i].data);
-}
-EXPORT_SYMBOL_GPL(save_msrs);
-
 void kvm_emulate_cpuid(struct kvm_vcpu *vcpu)
 {
         int i;
         u32 function;
         struct kvm_cpuid_entry *e, *best;
 
-        kvm_arch_ops->cache_regs(vcpu);
+        kvm_x86_ops->cache_regs(vcpu);
         function = vcpu->regs[VCPU_REGS_RAX];
         vcpu->regs[VCPU_REGS_RAX] = 0;
         vcpu->regs[VCPU_REGS_RBX] = 0;
@@ -1678,8 +1741,8 @@ void kvm_emulate_cpuid(struct kvm_vcpu *vcpu)
                 vcpu->regs[VCPU_REGS_RCX] = best->ecx;
                 vcpu->regs[VCPU_REGS_RDX] = best->edx;
         }
-        kvm_arch_ops->decache_regs(vcpu);
-        kvm_arch_ops->skip_emulated_instruction(vcpu);
+        kvm_x86_ops->decache_regs(vcpu);
+        kvm_x86_ops->skip_emulated_instruction(vcpu);
 }
 EXPORT_SYMBOL_GPL(kvm_emulate_cpuid);
 
@@ -1690,11 +1753,9 @@ static int pio_copy_data(struct kvm_vcpu *vcpu)
         unsigned bytes;
         int nr_pages = vcpu->pio.guest_pages[1] ? 2 : 1;
 
-        kvm_arch_ops->vcpu_put(vcpu);
         q = vmap(vcpu->pio.guest_pages, nr_pages, VM_READ|VM_WRITE,
                  PAGE_KERNEL);
         if (!q) {
-                kvm_arch_ops->vcpu_load(vcpu);
                 free_pio_guest_pages(vcpu);
                 return -ENOMEM;
         }
@@ -1706,7 +1767,6 @@ static int pio_copy_data(struct kvm_vcpu *vcpu)
                 memcpy(p, q, bytes);
         q -= vcpu->pio.guest_page_offset;
         vunmap(q);
-        kvm_arch_ops->vcpu_load(vcpu);
         free_pio_guest_pages(vcpu);
         return 0;
 }
@@ -1717,7 +1777,7 @@ static int complete_pio(struct kvm_vcpu *vcpu)
         long delta;
         int r;
 
-        kvm_arch_ops->cache_regs(vcpu);
+        kvm_x86_ops->cache_regs(vcpu);
 
         if (!io->string) {
                 if (io->in)
@@ -1727,7 +1787,7 @@ static int complete_pio(struct kvm_vcpu *vcpu)
                 if (io->in) {
                         r = pio_copy_data(vcpu);
                         if (r) {
-                                kvm_arch_ops->cache_regs(vcpu);
+                                kvm_x86_ops->cache_regs(vcpu);
                                 return r;
                         }
                 }
@@ -1750,79 +1810,109 @@ static int complete_pio(struct kvm_vcpu *vcpu)
                         vcpu->regs[VCPU_REGS_RSI] += delta;
         }
 
-        kvm_arch_ops->decache_regs(vcpu);
+        kvm_x86_ops->decache_regs(vcpu);
 
         io->count -= io->cur_count;
         io->cur_count = 0;
 
-        if (!io->count)
-                kvm_arch_ops->skip_emulated_instruction(vcpu);
         return 0;
 }
 
-void kernel_pio(struct kvm_io_device *pio_dev, struct kvm_vcpu *vcpu)
+static void kernel_pio(struct kvm_io_device *pio_dev,
+                       struct kvm_vcpu *vcpu,
+                       void *pd)
 {
         /* TODO: String I/O for in kernel device */
 
+        mutex_lock(&vcpu->kvm->lock);
         if (vcpu->pio.in)
                 kvm_iodevice_read(pio_dev, vcpu->pio.port,
                                   vcpu->pio.size,
-                                  vcpu->pio_data);
+                                  pd);
         else
                 kvm_iodevice_write(pio_dev, vcpu->pio.port,
                                    vcpu->pio.size,
-                                   vcpu->pio_data);
+                                   pd);
+        mutex_unlock(&vcpu->kvm->lock);
+}
+
+static void pio_string_write(struct kvm_io_device *pio_dev,
+                             struct kvm_vcpu *vcpu)
+{
+        struct kvm_pio_request *io = &vcpu->pio;
+        void *pd = vcpu->pio_data;
+        int i;
+
+        mutex_lock(&vcpu->kvm->lock);
+        for (i = 0; i < io->cur_count; i++) {
+                kvm_iodevice_write(pio_dev, io->port,
+                                   io->size,
+                                   pd);
+                pd += io->size;
+        }
+        mutex_unlock(&vcpu->kvm->lock);
 }
 
-int kvm_setup_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
-                  int size, unsigned long count, int string, int down,
+int kvm_emulate_pio (struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
+                  int size, unsigned port)
+{
+        struct kvm_io_device *pio_dev;
+
+        vcpu->run->exit_reason = KVM_EXIT_IO;
+        vcpu->run->io.direction = in ? KVM_EXIT_IO_IN : KVM_EXIT_IO_OUT;
+        vcpu->run->io.size = vcpu->pio.size = size;
+        vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
+        vcpu->run->io.count = vcpu->pio.count = vcpu->pio.cur_count = 1;
+        vcpu->run->io.port = vcpu->pio.port = port;
+        vcpu->pio.in = in;
+        vcpu->pio.string = 0;
+        vcpu->pio.down = 0;
+        vcpu->pio.guest_page_offset = 0;
+        vcpu->pio.rep = 0;
+
+        kvm_x86_ops->cache_regs(vcpu);
+        memcpy(vcpu->pio_data, &vcpu->regs[VCPU_REGS_RAX], 4);
+        kvm_x86_ops->decache_regs(vcpu);
+
+        kvm_x86_ops->skip_emulated_instruction(vcpu);
+
+        pio_dev = vcpu_find_pio_dev(vcpu, port);
+        if (pio_dev) {
+                kernel_pio(pio_dev, vcpu, vcpu->pio_data);
+                complete_pio(vcpu);
+                return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(kvm_emulate_pio);
+
+int kvm_emulate_pio_string(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
+                  int size, unsigned long count, int down,
                   gva_t address, int rep, unsigned port)
 {
         unsigned now, in_page;
-        int i;
+        int i, ret = 0;
         int nr_pages = 1;
         struct page *page;
         struct kvm_io_device *pio_dev;
 
         vcpu->run->exit_reason = KVM_EXIT_IO;
         vcpu->run->io.direction = in ? KVM_EXIT_IO_IN : KVM_EXIT_IO_OUT;
-        vcpu->run->io.size = size;
+        vcpu->run->io.size = vcpu->pio.size = size;
         vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
-        vcpu->run->io.count = count;
-        vcpu->run->io.port = port;
-        vcpu->pio.count = count;
-        vcpu->pio.cur_count = count;
-        vcpu->pio.size = size;
+        vcpu->run->io.count = vcpu->pio.count = vcpu->pio.cur_count = count;
+        vcpu->run->io.port = vcpu->pio.port = port;
         vcpu->pio.in = in;
-        vcpu->pio.port = port;
-        vcpu->pio.string = string;
+        vcpu->pio.string = 1;
         vcpu->pio.down = down;
         vcpu->pio.guest_page_offset = offset_in_page(address);
         vcpu->pio.rep = rep;
 
-        pio_dev = vcpu_find_pio_dev(vcpu, port);
-        if (!string) {
-                kvm_arch_ops->cache_regs(vcpu);
-                memcpy(vcpu->pio_data, &vcpu->regs[VCPU_REGS_RAX], 4);
-                kvm_arch_ops->decache_regs(vcpu);
-                if (pio_dev) {
-                        kernel_pio(pio_dev, vcpu);
-                        complete_pio(vcpu);
-                        return 1;
-                }
-                return 0;
-        }
-        /* TODO: String I/O for in kernel device */
-        if (pio_dev)
-                printk(KERN_ERR "kvm_setup_pio: no string io support\n");
-
         if (!count) {
-                kvm_arch_ops->skip_emulated_instruction(vcpu);
+                kvm_x86_ops->skip_emulated_instruction(vcpu);
                 return 1;
         }
 
-        now = min(count, PAGE_SIZE / size);
-
         if (!down)
                 in_page = PAGE_SIZE - offset_in_page(address);
         else
@@ -1841,20 +1931,23 @@ int kvm_setup_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
                 /*
                  * String I/O in reverse.  Yuck.  Kill the guest, fix later.
                  */
-                printk(KERN_ERR "kvm: guest string pio down\n");
+                pr_unimpl(vcpu, "guest string pio down\n");
                 inject_gp(vcpu);
                 return 1;
         }
         vcpu->run->io.count = now;
         vcpu->pio.cur_count = now;
 
+        if (vcpu->pio.cur_count == vcpu->pio.count)
+                kvm_x86_ops->skip_emulated_instruction(vcpu);
+
         for (i = 0; i < nr_pages; ++i) {
-                spin_lock(&vcpu->kvm->lock);
+                mutex_lock(&vcpu->kvm->lock);
                 page = gva_to_page(vcpu, address + i * PAGE_SIZE);
                 if (page)
                         get_page(page);
                 vcpu->pio.guest_pages[i] = page;
-                spin_unlock(&vcpu->kvm->lock);
+                mutex_unlock(&vcpu->kvm->lock);
                 if (!page) {
                         inject_gp(vcpu);
                         free_pio_guest_pages(vcpu);
@@ -1862,11 +1955,145 @@ int kvm_setup_pio(struct kvm_vcpu *vcpu, struct kvm_run *run, int in,
                 }
         }
 
-        if (!vcpu->pio.in)
-                return pio_copy_data(vcpu);
-        return 0;
+        pio_dev = vcpu_find_pio_dev(vcpu, port);
+        if (!vcpu->pio.in) {
+                /* string PIO write */
+                ret = pio_copy_data(vcpu);
+                if (ret >= 0 && pio_dev) {
+                        pio_string_write(pio_dev, vcpu);
+                        complete_pio(vcpu);
+                        if (vcpu->pio.count == 0)
+                                ret = 1;
+                }
+        } else if (pio_dev)
+                pr_unimpl(vcpu, "no string pio read support yet, "
+                       "port %x size %d count %ld\n",
+                        port, size, count);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(kvm_emulate_pio_string);
+
+/*
+ * Check if userspace requested an interrupt window, and that the
+ * interrupt window is open.
+ *
+ * No need to exit to userspace if we already have an interrupt queued.
+ */
+static int dm_request_for_irq_injection(struct kvm_vcpu *vcpu,
+                                          struct kvm_run *kvm_run)
+{
+        return (!vcpu->irq_summary &&
+                kvm_run->request_interrupt_window &&
+                vcpu->interrupt_window_open &&
+                (kvm_x86_ops->get_rflags(vcpu) & X86_EFLAGS_IF));
+}
+
+static void post_kvm_run_save(struct kvm_vcpu *vcpu,
+                              struct kvm_run *kvm_run)
+{
+        kvm_run->if_flag = (kvm_x86_ops->get_rflags(vcpu) & X86_EFLAGS_IF) != 0;
+        kvm_run->cr8 = get_cr8(vcpu);
+        kvm_run->apic_base = kvm_get_apic_base(vcpu);
+        if (irqchip_in_kernel(vcpu->kvm))
+                kvm_run->ready_for_interrupt_injection = 1;
+        else
+                kvm_run->ready_for_interrupt_injection =
+                                        (vcpu->interrupt_window_open &&
+                                         vcpu->irq_summary == 0);
+}
+
+static int __vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+{
+        int r;
+
+        if (unlikely(vcpu->mp_state == VCPU_MP_STATE_SIPI_RECEIVED)) {
+                printk("vcpu %d received sipi with vector # %x\n",
+                       vcpu->vcpu_id, vcpu->sipi_vector);
+                kvm_lapic_reset(vcpu);
+                kvm_x86_ops->vcpu_reset(vcpu);
+                vcpu->mp_state = VCPU_MP_STATE_RUNNABLE;
+        }
+
+preempted:
+        if (vcpu->guest_debug.enabled)
+                kvm_x86_ops->guest_debug_pre(vcpu);
+
+again:
+        r = kvm_mmu_reload(vcpu);
+        if (unlikely(r))
+                goto out;
+
+        preempt_disable();
+
+        kvm_x86_ops->prepare_guest_switch(vcpu);
+        kvm_load_guest_fpu(vcpu);
+
+        local_irq_disable();
+
+        if (signal_pending(current)) {
+                local_irq_enable();
+                preempt_enable();
+                r = -EINTR;
+                kvm_run->exit_reason = KVM_EXIT_INTR;
+                ++vcpu->stat.signal_exits;
+                goto out;
+        }
+
+        if (irqchip_in_kernel(vcpu->kvm))
+                kvm_x86_ops->inject_pending_irq(vcpu);
+        else if (!vcpu->mmio_read_completed)
+                kvm_x86_ops->inject_pending_vectors(vcpu, kvm_run);
+
+        vcpu->guest_mode = 1;
+
+        if (vcpu->requests)
+                if (test_and_clear_bit(KVM_TLB_FLUSH, &vcpu->requests))
+                        kvm_x86_ops->tlb_flush(vcpu);
+
+        kvm_x86_ops->run(vcpu, kvm_run);
+
+        vcpu->guest_mode = 0;
+        local_irq_enable();
+
+        ++vcpu->stat.exits;
+
+        preempt_enable();
+
+        /*
+         * Profile KVM exit RIPs:
+         */
+        if (unlikely(prof_on == KVM_PROFILING)) {
+                kvm_x86_ops->cache_regs(vcpu);
+                profile_hit(KVM_PROFILING, (void *)vcpu->rip);
+        }
+
+        r = kvm_x86_ops->handle_exit(kvm_run, vcpu);
+
+        if (r > 0) {
+                if (dm_request_for_irq_injection(vcpu, kvm_run)) {
+                        r = -EINTR;
+                        kvm_run->exit_reason = KVM_EXIT_INTR;
+                        ++vcpu->stat.request_irq_exits;
+                        goto out;
+                }
+                if (!need_resched()) {
+                        ++vcpu->stat.light_exits;
+                        goto again;
+                }
+        }
+
+out:
+        if (r > 0) {
+                kvm_resched(vcpu);
+                goto preempted;
+        }
+
+        post_kvm_run_save(vcpu, kvm_run);
+
+        return r;
 }
-EXPORT_SYMBOL_GPL(kvm_setup_pio);
+
 
 static int kvm_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
@@ -1875,11 +2102,18 @@ static int kvm_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
         vcpu_load(vcpu);
 
+        if (unlikely(vcpu->mp_state == VCPU_MP_STATE_UNINITIALIZED)) {
+                kvm_vcpu_block(vcpu);
+                vcpu_put(vcpu);
+                return -EAGAIN;
+        }
+
         if (vcpu->sigset_active)
                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 
         /* re-sync apic's tpr */
-        vcpu->cr8 = kvm_run->cr8;
+        if (!irqchip_in_kernel(vcpu->kvm))
+                set_cr8(vcpu, kvm_run->cr8);
 
         if (vcpu->pio.cur_count) {
                 r = complete_pio(vcpu);
@@ -1897,19 +2131,18 @@ static int kvm_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                         /*
                          * Read-modify-write.  Back to userspace.
                          */
-                        kvm_run->exit_reason = KVM_EXIT_MMIO;
                         r = 0;
                         goto out;
                 }
         }
 
         if (kvm_run->exit_reason == KVM_EXIT_HYPERCALL) {
-                kvm_arch_ops->cache_regs(vcpu);
+                kvm_x86_ops->cache_regs(vcpu);
                 vcpu->regs[VCPU_REGS_RAX] = kvm_run->hypercall.ret;
-                kvm_arch_ops->decache_regs(vcpu);
+                kvm_x86_ops->decache_regs(vcpu);
         }
 
-        r = kvm_arch_ops->run(vcpu, kvm_run);
+        r = __vcpu_run(vcpu, kvm_run);
 
 out:
         if (vcpu->sigset_active)
@@ -1924,7 +2157,7 @@ static int kvm_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu,
 {
         vcpu_load(vcpu);
 
-        kvm_arch_ops->cache_regs(vcpu);
+        kvm_x86_ops->cache_regs(vcpu);
 
         regs->rax = vcpu->regs[VCPU_REGS_RAX];
         regs->rbx = vcpu->regs[VCPU_REGS_RBX];
@@ -1946,7 +2179,7 @@ static int kvm_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu,
 #endif
 
         regs->rip = vcpu->rip;
-        regs->rflags = kvm_arch_ops->get_rflags(vcpu);
+        regs->rflags = kvm_x86_ops->get_rflags(vcpu);
 
         /*
          * Don't leak debug flags in case they were set for guest debugging
@@ -1984,9 +2217,9 @@ static int kvm_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu,
 #endif
 
         vcpu->rip = regs->rip;
-        kvm_arch_ops->set_rflags(vcpu, regs->rflags);
+        kvm_x86_ops->set_rflags(vcpu, regs->rflags);
 
-        kvm_arch_ops->decache_regs(vcpu);
+        kvm_x86_ops->decache_regs(vcpu);
 
         vcpu_put(vcpu);
 
@@ -1996,13 +2229,14 @@ static int kvm_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu,
 static void get_segment(struct kvm_vcpu *vcpu,
                         struct kvm_segment *var, int seg)
 {
-        return kvm_arch_ops->get_segment(vcpu, var, seg);
+        return kvm_x86_ops->get_segment(vcpu, var, seg);
 }
 
 static int kvm_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
                                     struct kvm_sregs *sregs)
 {
         struct descriptor_table dt;
+        int pending_vec;
 
         vcpu_load(vcpu);
 
@@ -2016,24 +2250,31 @@ static int kvm_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
         get_segment(vcpu, &sregs->tr, VCPU_SREG_TR);
         get_segment(vcpu, &sregs->ldt, VCPU_SREG_LDTR);
 
-        kvm_arch_ops->get_idt(vcpu, &dt);
+        kvm_x86_ops->get_idt(vcpu, &dt);
         sregs->idt.limit = dt.limit;
         sregs->idt.base = dt.base;
-        kvm_arch_ops->get_gdt(vcpu, &dt);
+        kvm_x86_ops->get_gdt(vcpu, &dt);
         sregs->gdt.limit = dt.limit;
         sregs->gdt.base = dt.base;
 
-        kvm_arch_ops->decache_cr4_guest_bits(vcpu);
+        kvm_x86_ops->decache_cr4_guest_bits(vcpu);
         sregs->cr0 = vcpu->cr0;
         sregs->cr2 = vcpu->cr2;
         sregs->cr3 = vcpu->cr3;
         sregs->cr4 = vcpu->cr4;
-        sregs->cr8 = vcpu->cr8;
+        sregs->cr8 = get_cr8(vcpu);
         sregs->efer = vcpu->shadow_efer;
-        sregs->apic_base = vcpu->apic_base;
-
-        memcpy(sregs->interrupt_bitmap, vcpu->irq_pending,
-               sizeof sregs->interrupt_bitmap);
+        sregs->apic_base = kvm_get_apic_base(vcpu);
+
+        if (irqchip_in_kernel(vcpu->kvm)) {
+                memset(sregs->interrupt_bitmap, 0,
+                       sizeof sregs->interrupt_bitmap);
+                pending_vec = kvm_x86_ops->get_irq(vcpu);
+                if (pending_vec >= 0)
+                        set_bit(pending_vec, (unsigned long *)sregs->interrupt_bitmap);
+        } else
+                memcpy(sregs->interrupt_bitmap, vcpu->irq_pending,
+                       sizeof sregs->interrupt_bitmap);
 
         vcpu_put(vcpu);
 
@@ -2043,56 +2284,69 @@ static int kvm_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 static void set_segment(struct kvm_vcpu *vcpu,
                         struct kvm_segment *var, int seg)
 {
-        return kvm_arch_ops->set_segment(vcpu, var, seg);
+        return kvm_x86_ops->set_segment(vcpu, var, seg);
 }
 
 static int kvm_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
                                     struct kvm_sregs *sregs)
 {
         int mmu_reset_needed = 0;
-        int i;
+        int i, pending_vec, max_bits;
         struct descriptor_table dt;
 
         vcpu_load(vcpu);
 
         dt.limit = sregs->idt.limit;
         dt.base = sregs->idt.base;
-        kvm_arch_ops->set_idt(vcpu, &dt);
+        kvm_x86_ops->set_idt(vcpu, &dt);
         dt.limit = sregs->gdt.limit;
         dt.base = sregs->gdt.base;
-        kvm_arch_ops->set_gdt(vcpu, &dt);
+        kvm_x86_ops->set_gdt(vcpu, &dt);
 
         vcpu->cr2 = sregs->cr2;
         mmu_reset_needed |= vcpu->cr3 != sregs->cr3;
         vcpu->cr3 = sregs->cr3;
 
-        vcpu->cr8 = sregs->cr8;
+        set_cr8(vcpu, sregs->cr8);
 
         mmu_reset_needed |= vcpu->shadow_efer != sregs->efer;
 #ifdef CONFIG_X86_64
-        kvm_arch_ops->set_efer(vcpu, sregs->efer);
+        kvm_x86_ops->set_efer(vcpu, sregs->efer);
 #endif
-        vcpu->apic_base = sregs->apic_base;
+        kvm_set_apic_base(vcpu, sregs->apic_base);
 
-        kvm_arch_ops->decache_cr4_guest_bits(vcpu);
+        kvm_x86_ops->decache_cr4_guest_bits(vcpu);
 
         mmu_reset_needed |= vcpu->cr0 != sregs->cr0;
-        kvm_arch_ops->set_cr0(vcpu, sregs->cr0);
+        vcpu->cr0 = sregs->cr0;
+        kvm_x86_ops->set_cr0(vcpu, sregs->cr0);
 
         mmu_reset_needed |= vcpu->cr4 != sregs->cr4;
-        kvm_arch_ops->set_cr4(vcpu, sregs->cr4);
+        kvm_x86_ops->set_cr4(vcpu, sregs->cr4);
         if (!is_long_mode(vcpu) && is_pae(vcpu))
                 load_pdptrs(vcpu, vcpu->cr3);
 
         if (mmu_reset_needed)
                 kvm_mmu_reset_context(vcpu);
 
-        memcpy(vcpu->irq_pending, sregs->interrupt_bitmap,
-               sizeof vcpu->irq_pending);
-        vcpu->irq_summary = 0;
-        for (i = 0; i < NR_IRQ_WORDS; ++i)
-                if (vcpu->irq_pending[i])
-                        __set_bit(i, &vcpu->irq_summary);
+        if (!irqchip_in_kernel(vcpu->kvm)) {
+                memcpy(vcpu->irq_pending, sregs->interrupt_bitmap,
+                       sizeof vcpu->irq_pending);
+                vcpu->irq_summary = 0;
+                for (i = 0; i < ARRAY_SIZE(vcpu->irq_pending); ++i)
+                        if (vcpu->irq_pending[i])
+                                __set_bit(i, &vcpu->irq_summary);
+        } else {
+                max_bits = (sizeof sregs->interrupt_bitmap) << 3;
+                pending_vec = find_first_bit(
+                        (const unsigned long *)sregs->interrupt_bitmap,
+                        max_bits);
+                /* Only pending external irq is handled here */
+                if (pending_vec < max_bits) {
+                        kvm_x86_ops->set_irq(vcpu, pending_vec);
+                        printk("Set back pending irq %d\n", pending_vec);
+                }
+        }
 
         set_segment(vcpu, &sregs->cs, VCPU_SREG_CS);
         set_segment(vcpu, &sregs->ds, VCPU_SREG_DS);
@@ -2109,6 +2363,16 @@ static int kvm_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
         return 0;
 }
 
+void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l)
+{
+        struct kvm_segment cs;
+
+        get_segment(vcpu, &cs, VCPU_SREG_CS);
+        *db = cs.db;
+        *l = cs.l;
+}
+EXPORT_SYMBOL_GPL(kvm_get_cs_db_l_bits);
+
 /*
  * List of msr numbers which we expose to userspace through KVM_GET_MSRS
  * and KVM_SET_MSRS, and KVM_GET_MSR_INDEX_LIST.
@@ -2236,13 +2500,13 @@ static int kvm_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
         gpa_t gpa;
 
         vcpu_load(vcpu);
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&vcpu->kvm->lock);
         gpa = vcpu->mmu.gva_to_gpa(vcpu, vaddr);
         tr->physical_address = gpa;
         tr->valid = gpa != UNMAPPED_GVA;
         tr->writeable = 1;
         tr->usermode = 0;
-        spin_unlock(&vcpu->kvm->lock);
+        mutex_unlock(&vcpu->kvm->lock);
         vcpu_put(vcpu);
 
         return 0;
@@ -2253,6 +2517,8 @@ static int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu,
 {
         if (irq->irq < 0 || irq->irq >= 256)
                 return -EINVAL;
+        if (irqchip_in_kernel(vcpu->kvm))
+                return -ENXIO;
         vcpu_load(vcpu);
 
         set_bit(irq->irq, vcpu->irq_pending);
@@ -2270,7 +2536,7 @@ static int kvm_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
 
         vcpu_load(vcpu);
 
-        r = kvm_arch_ops->set_guest_debug(vcpu, dbg);
+        r = kvm_x86_ops->set_guest_debug(vcpu, dbg);
 
         vcpu_put(vcpu);
 
@@ -2285,7 +2551,6 @@ static struct page *kvm_vcpu_nopage(struct vm_area_struct *vma,
         unsigned long pgoff;
         struct page *page;
 
-        *type = VM_FAULT_MINOR;
         pgoff = ((address - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
         if (pgoff == 0)
                 page = virt_to_page(vcpu->run);
@@ -2294,6 +2559,9 @@ static struct page *kvm_vcpu_nopage(struct vm_area_struct *vma,
         else
                 return NOPAGE_SIGBUS;
         get_page(page);
+        if (type != NULL)
+                *type = VM_FAULT_MINOR;
+
         return page;
 }
 
@@ -2346,74 +2614,52 @@ static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, int n)
 {
         int r;
         struct kvm_vcpu *vcpu;
-        struct page *page;
 
-        r = -EINVAL;
         if (!valid_vcpu(n))
-                goto out;
-
-        vcpu = &kvm->vcpus[n];
-
-        mutex_lock(&vcpu->mutex);
-
-        if (vcpu->vmcs) {
-                mutex_unlock(&vcpu->mutex);
-                return -EEXIST;
-        }
-
-        page = alloc_page(GFP_KERNEL | __GFP_ZERO);
-        r = -ENOMEM;
-        if (!page)
-                goto out_unlock;
-        vcpu->run = page_address(page);
-
-        page = alloc_page(GFP_KERNEL | __GFP_ZERO);
-        r = -ENOMEM;
-        if (!page)
-                goto out_free_run;
-        vcpu->pio_data = page_address(page);
+                return -EINVAL;
 
-        vcpu->host_fx_image = (char*)ALIGN((hva_t)vcpu->fx_buf,
-                                           FX_IMAGE_ALIGN);
-        vcpu->guest_fx_image = vcpu->host_fx_image + FX_IMAGE_SIZE;
-        vcpu->cr0 = 0x10;
+        vcpu = kvm_x86_ops->vcpu_create(kvm, n);
+        if (IS_ERR(vcpu))
+                return PTR_ERR(vcpu);
 
-        r = kvm_arch_ops->vcpu_create(vcpu);
-        if (r < 0)
-                goto out_free_vcpus;
+        preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
 
-        r = kvm_mmu_create(vcpu);
-        if (r < 0)
-                goto out_free_vcpus;
+        /* We do fxsave: this must be aligned. */
+        BUG_ON((unsigned long)&vcpu->host_fx_image & 0xF);
 
-        kvm_arch_ops->vcpu_load(vcpu);
+        vcpu_load(vcpu);
         r = kvm_mmu_setup(vcpu);
-        if (r >= 0)
-                r = kvm_arch_ops->vcpu_setup(vcpu);
         vcpu_put(vcpu);
-
         if (r < 0)
-                goto out_free_vcpus;
+                goto free_vcpu;
 
+        mutex_lock(&kvm->lock);
+        if (kvm->vcpus[n]) {
+                r = -EEXIST;
+                mutex_unlock(&kvm->lock);
+                goto mmu_unload;
+        }
+        kvm->vcpus[n] = vcpu;
+        mutex_unlock(&kvm->lock);
+
+        /* Now it's all set up, let userspace reach it */
         r = create_vcpu_fd(vcpu);
         if (r < 0)
-                goto out_free_vcpus;
+                goto unlink;
+        return r;
 
-        spin_lock(&kvm_lock);
-        if (n >= kvm->nvcpus)
-                kvm->nvcpus = n + 1;
-        spin_unlock(&kvm_lock);
+unlink:
+        mutex_lock(&kvm->lock);
+        kvm->vcpus[n] = NULL;
+        mutex_unlock(&kvm->lock);
 
-        return r;
+mmu_unload:
+        vcpu_load(vcpu);
+        kvm_mmu_unload(vcpu);
+        vcpu_put(vcpu);
 
-out_free_vcpus:
-        kvm_free_vcpu(vcpu);
-out_free_run:
-        free_page((unsigned long)vcpu->run);
-        vcpu->run = NULL;
-out_unlock:
-        mutex_unlock(&vcpu->mutex);
-out:
+free_vcpu:
+        kvm_x86_ops->vcpu_free(vcpu);
         return r;
 }
 
@@ -2493,7 +2739,7 @@ struct fxsave {
 
 static int kvm_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 {
-        struct fxsave *fxsave = (struct fxsave *)vcpu->guest_fx_image;
+        struct fxsave *fxsave = (struct fxsave *)&vcpu->guest_fx_image;
 
         vcpu_load(vcpu);
 
@@ -2513,7 +2759,7 @@ static int kvm_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 
 static int kvm_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 {
-        struct fxsave *fxsave = (struct fxsave *)vcpu->guest_fx_image;
+        struct fxsave *fxsave = (struct fxsave *)&vcpu->guest_fx_image;
 
         vcpu_load(vcpu);
 
@@ -2531,6 +2777,27 @@ static int kvm_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
         return 0;
 }
 
+static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
+                                    struct kvm_lapic_state *s)
+{
+        vcpu_load(vcpu);
+        memcpy(s->regs, vcpu->apic->regs, sizeof *s);
+        vcpu_put(vcpu);
+
+        return 0;
+}
+
+static int kvm_vcpu_ioctl_set_lapic(struct kvm_vcpu *vcpu,
+                                    struct kvm_lapic_state *s)
+{
+        vcpu_load(vcpu);
+        memcpy(vcpu->apic->regs, s->regs, sizeof *s);
+        kvm_apic_post_state_restore(vcpu);
+        vcpu_put(vcpu);
+
+        return 0;
+}
+
 static long kvm_vcpu_ioctl(struct file *filp,
                            unsigned int ioctl, unsigned long arg)
 {
@@ -2700,6 +2967,31 @@ static long kvm_vcpu_ioctl(struct file *filp,
                 r = 0;
                 break;
         }
+        case KVM_GET_LAPIC: {
+                struct kvm_lapic_state lapic;
+
+                memset(&lapic, 0, sizeof lapic);
+                r = kvm_vcpu_ioctl_get_lapic(vcpu, &lapic);
+                if (r)
+                        goto out;
+                r = -EFAULT;
+                if (copy_to_user(argp, &lapic, sizeof lapic))
+                        goto out;
+                r = 0;
+                break;
+        }
+        case KVM_SET_LAPIC: {
+                struct kvm_lapic_state lapic;
+
+                r = -EFAULT;
+                if (copy_from_user(&lapic, argp, sizeof lapic))
+                        goto out;
+                r = kvm_vcpu_ioctl_set_lapic(vcpu, &lapic);;
+                if (r)
+                        goto out;
+                r = 0;
+                break;
+        }
         default:
                 ;
         }
@@ -2753,6 +3045,75 @@ static long kvm_vm_ioctl(struct file *filp,
                         goto out;
                 break;
         }
+        case KVM_CREATE_IRQCHIP:
+                r = -ENOMEM;
+                kvm->vpic = kvm_create_pic(kvm);
+                if (kvm->vpic) {
+                        r = kvm_ioapic_init(kvm);
+                        if (r) {
+                                kfree(kvm->vpic);
+                                kvm->vpic = NULL;
+                                goto out;
+                        }
+                }
+                else
+                        goto out;
+                break;
+        case KVM_IRQ_LINE: {
+                struct kvm_irq_level irq_event;
+
+                r = -EFAULT;
+                if (copy_from_user(&irq_event, argp, sizeof irq_event))
+                        goto out;
+                if (irqchip_in_kernel(kvm)) {
+                        mutex_lock(&kvm->lock);
+                        if (irq_event.irq < 16)
+                                kvm_pic_set_irq(pic_irqchip(kvm),
+                                        irq_event.irq,
+                                        irq_event.level);
+                        kvm_ioapic_set_irq(kvm->vioapic,
+                                        irq_event.irq,
+                                        irq_event.level);
+                        mutex_unlock(&kvm->lock);
+                        r = 0;
+                }
+                break;
+        }
+        case KVM_GET_IRQCHIP: {
+                /* 0: PIC master, 1: PIC slave, 2: IOAPIC */
+                struct kvm_irqchip chip;
+
+                r = -EFAULT;
+                if (copy_from_user(&chip, argp, sizeof chip))
+                        goto out;
+                r = -ENXIO;
+                if (!irqchip_in_kernel(kvm))
+                        goto out;
+                r = kvm_vm_ioctl_get_irqchip(kvm, &chip);
+                if (r)
+                        goto out;
+                r = -EFAULT;
+                if (copy_to_user(argp, &chip, sizeof chip))
+                        goto out;
+                r = 0;
+                break;
+        }
+        case KVM_SET_IRQCHIP: {
+                /* 0: PIC master, 1: PIC slave, 2: IOAPIC */
+                struct kvm_irqchip chip;
+
+                r = -EFAULT;
+                if (copy_from_user(&chip, argp, sizeof chip))
+                        goto out;
+                r = -ENXIO;
+                if (!irqchip_in_kernel(kvm))
+                        goto out;
+                r = kvm_vm_ioctl_set_irqchip(kvm, &chip);
+                if (r)
+                        goto out;
+                r = 0;
+                break;
+        }
         default:
                 ;
         }
@@ -2768,12 +3129,14 @@ static struct page *kvm_vm_nopage(struct vm_area_struct *vma,
         unsigned long pgoff;
         struct page *page;
 
-        *type = VM_FAULT_MINOR;
         pgoff = ((address - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
         page = gfn_to_page(kvm, pgoff);
         if (!page)
                 return NOPAGE_SIGBUS;
         get_page(page);
+        if (type != NULL)
+                *type = VM_FAULT_MINOR;
+
         return page;
 }
 
@@ -2861,12 +3224,20 @@ static long kvm_dev_ioctl(struct file *filp,
                 r = 0;
                 break;
         }
-        case KVM_CHECK_EXTENSION:
-                /*
-                 * No extensions defined at present.
-                 */
-                r = 0;
+        case KVM_CHECK_EXTENSION: {
+                int ext = (long)argp;
+
+                switch (ext) {
+                case KVM_CAP_IRQCHIP:
+                case KVM_CAP_HLT:
+                        r = 1;
+                        break;
+                default:
+                        r = 0;
+                        break;
+                }
                 break;
+        }
         case KVM_GET_VCPU_MMAP_SIZE:
                 r = -EINVAL;
                 if (arg)
@@ -2881,8 +3252,6 @@ out:
 }
 
 static struct file_operations kvm_chardev_ops = {
-        .open           = kvm_dev_open,
-        .release        = kvm_dev_release,
         .unlocked_ioctl = kvm_dev_ioctl,
         .compat_ioctl   = kvm_dev_ioctl,
 };
@@ -2893,25 +3262,6 @@ static struct miscdevice kvm_dev = {
         &kvm_chardev_ops,
 };
 
-static int kvm_reboot(struct notifier_block *notifier, unsigned long val,
-                       void *v)
-{
-        if (val == SYS_RESTART) {
-                /*
-                 * Some (well, at least mine) BIOSes hang on reboot if
-                 * in vmx root mode.
-                 */
-                printk(KERN_INFO "kvm: exiting hardware virtualization\n");
-                on_each_cpu(hardware_disable, NULL, 0, 1);
-        }
-        return NOTIFY_OK;
-}
-
-static struct notifier_block kvm_reboot_notifier = {
-        .notifier_call = kvm_reboot,
-        .priority = 0,
-};
-
 /*
  * Make sure that a cpu that is being hot-unplugged does not have any vcpus
  * cached on it.
@@ -2925,7 +3275,9 @@ static void decache_vcpus_on_cpu(int cpu)
         spin_lock(&kvm_lock);
         list_for_each_entry(vm, &vm_list, vm_list)
                 for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                        vcpu = &vm->vcpus[i];
+                        vcpu = vm->vcpus[i];
+                        if (!vcpu)
+                                continue;
                         /*
                          * If the vcpu is locked, then it is running on some
                          * other cpu and therefore it is not cached on the
@@ -2936,7 +3288,7 @@ static void decache_vcpus_on_cpu(int cpu)
                          */
                         if (mutex_trylock(&vcpu->mutex)) {
                                 if (vcpu->cpu == cpu) {
-                                        kvm_arch_ops->vcpu_decache(vcpu);
+                                        kvm_x86_ops->vcpu_decache(vcpu);
                                         vcpu->cpu = -1;
                                 }
                                 mutex_unlock(&vcpu->mutex);
@@ -2952,7 +3304,7 @@ static void hardware_enable(void *junk)
         if (cpu_isset(cpu, cpus_hardware_enabled))
                 return;
         cpu_set(cpu, cpus_hardware_enabled);
-        kvm_arch_ops->hardware_enable(NULL);
+        kvm_x86_ops->hardware_enable(NULL);
 }
 
 static void hardware_disable(void *junk)
@@ -2963,7 +3315,7 @@ static void hardware_disable(void *junk)
                 return;
         cpu_clear(cpu, cpus_hardware_enabled);
         decache_vcpus_on_cpu(cpu);
-        kvm_arch_ops->hardware_disable(NULL);
+        kvm_x86_ops->hardware_disable(NULL);
 }
 
 static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
@@ -2994,6 +3346,25 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
         return NOTIFY_OK;
 }
 
+static int kvm_reboot(struct notifier_block *notifier, unsigned long val,
+                       void *v)
+{
+        if (val == SYS_RESTART) {
+                /*
+                 * Some (well, at least mine) BIOSes hang on reboot if
+                 * in vmx root mode.
+                 */
+                printk(KERN_INFO "kvm: exiting hardware virtualization\n");
+                on_each_cpu(hardware_disable, NULL, 0, 1);
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block kvm_reboot_notifier = {
+        .notifier_call = kvm_reboot,
+        .priority = 0,
+};
+
 void kvm_io_bus_init(struct kvm_io_bus *bus)
 {
         memset(bus, 0, sizeof(*bus));
@@ -3047,18 +3418,15 @@ static u64 stat_get(void *_offset)
         spin_lock(&kvm_lock);
         list_for_each_entry(kvm, &vm_list, vm_list)
                 for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                        vcpu = &kvm->vcpus[i];
-                        total += *(u32 *)((void *)vcpu + offset);
+                        vcpu = kvm->vcpus[i];
+                        if (vcpu)
+                                total += *(u32 *)((void *)vcpu + offset);
                 }
         spin_unlock(&kvm_lock);
         return total;
 }
 
-static void stat_set(void *offset, u64 val)
-{
-}
-
-DEFINE_SIMPLE_ATTRIBUTE(stat_fops, stat_get, stat_set, "%llu\n");
+DEFINE_SIMPLE_ATTRIBUTE(stat_fops, stat_get, NULL, "%llu\n");
 
 static __init void kvm_init_debug(void)
 {
@@ -3105,11 +3473,34 @@ static struct sys_device kvm_sysdev = {
 
 hpa_t bad_page_address;
 
-int kvm_init_arch(struct kvm_arch_ops *ops, struct module *module)
+static inline
+struct kvm_vcpu *preempt_notifier_to_vcpu(struct preempt_notifier *pn)
+{
+        return container_of(pn, struct kvm_vcpu, preempt_notifier);
+}
+
+static void kvm_sched_in(struct preempt_notifier *pn, int cpu)
+{
+        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
+
+        kvm_x86_ops->vcpu_load(vcpu, cpu);
+}
+
+static void kvm_sched_out(struct preempt_notifier *pn,
+                          struct task_struct *next)
+{
+        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
+
+        kvm_x86_ops->vcpu_put(vcpu);
+}
+
+int kvm_init_x86(struct kvm_x86_ops *ops, unsigned int vcpu_size,
+                  struct module *module)
 {
         int r;
+        int cpu;
 
-        if (kvm_arch_ops) {
+        if (kvm_x86_ops) {
                 printk(KERN_ERR "kvm: already loaded the other module\n");
                 return -EEXIST;
         }
@@ -3123,12 +3514,20 @@ int kvm_init_arch(struct kvm_arch_ops *ops, struct module *module)
                 return -EOPNOTSUPP;
         }
 
-        kvm_arch_ops = ops;
+        kvm_x86_ops = ops;
 
-        r = kvm_arch_ops->hardware_setup();
+        r = kvm_x86_ops->hardware_setup();
         if (r < 0)
                 goto out;
 
+        for_each_online_cpu(cpu) {
+                smp_call_function_single(cpu,
+                                kvm_x86_ops->check_processor_compatibility,
+                                &r, 0, 1);
+                if (r < 0)
+                        goto out_free_0;
+        }
+
         on_each_cpu(hardware_enable, NULL, 0, 1);
         r = register_cpu_notifier(&kvm_cpu_notifier);
         if (r)
@@ -3143,6 +3542,14 @@ int kvm_init_arch(struct kvm_arch_ops *ops, struct module *module)
         if (r)
                 goto out_free_3;
 
+        /* A kmem cache lets us meet the alignment requirements of fx_save. */
+        kvm_vcpu_cache = kmem_cache_create("kvm_vcpu", vcpu_size,
+                                           __alignof__(struct kvm_vcpu), 0, 0);
+        if (!kvm_vcpu_cache) {
+                r = -ENOMEM;
+                goto out_free_4;
+        }
+
         kvm_chardev_ops.owner = module;
 
         r = misc_register(&kvm_dev);
@@ -3151,9 +3558,14 @@ int kvm_init_arch(struct kvm_arch_ops *ops, struct module *module)
                 goto out_free;
         }
 
+        kvm_preempt_ops.sched_in = kvm_sched_in;
+        kvm_preempt_ops.sched_out = kvm_sched_out;
+
         return r;
 
 out_free:
+        kmem_cache_destroy(kvm_vcpu_cache);
+out_free_4:
         sysdev_unregister(&kvm_sysdev);
 out_free_3:
         sysdev_class_unregister(&kvm_sysdev_class);
@@ -3162,22 +3574,24 @@ out_free_2:
         unregister_cpu_notifier(&kvm_cpu_notifier);
 out_free_1:
         on_each_cpu(hardware_disable, NULL, 0, 1);
-        kvm_arch_ops->hardware_unsetup();
+out_free_0:
+        kvm_x86_ops->hardware_unsetup();
 out:
-        kvm_arch_ops = NULL;
+        kvm_x86_ops = NULL;
         return r;
 }
 
-void kvm_exit_arch(void)
+void kvm_exit_x86(void)
 {
         misc_deregister(&kvm_dev);
+        kmem_cache_destroy(kvm_vcpu_cache);
         sysdev_unregister(&kvm_sysdev);
         sysdev_class_unregister(&kvm_sysdev_class);
         unregister_reboot_notifier(&kvm_reboot_notifier);
         unregister_cpu_notifier(&kvm_cpu_notifier);
         on_each_cpu(hardware_disable, NULL, 0, 1);
-        kvm_arch_ops->hardware_unsetup();
-        kvm_arch_ops = NULL;
+        kvm_x86_ops->hardware_unsetup();
+        kvm_x86_ops = NULL;
 }
 
 static __init int kvm_init(void)
@@ -3220,5 +3634,5 @@ static __exit void kvm_exit(void)
 module_init(kvm_init)
 module_exit(kvm_exit)
 
-EXPORT_SYMBOL_GPL(kvm_init_arch);
-EXPORT_SYMBOL_GPL(kvm_exit_arch);
+EXPORT_SYMBOL_GPL(kvm_init_x86);
+EXPORT_SYMBOL_GPL(kvm_exit_x86);
diff --git a/drivers/kvm/kvm_svm.h b/drivers/kvm/kvm_svm.h
index a869983d68..a0e415daef 100644
--- a/drivers/kvm/kvm_svm.h
+++ b/drivers/kvm/kvm_svm.h
@@ -20,7 +20,10 @@ static const u32 host_save_user_msrs[] = {
 #define NR_HOST_SAVE_USER_MSRS ARRAY_SIZE(host_save_user_msrs)
 #define NUM_DB_REGS 4
 
+struct kvm_vcpu;
+
 struct vcpu_svm {
+        struct kvm_vcpu vcpu;
         struct vmcb *vmcb;
         unsigned long vmcb_pa;
         struct svm_cpu_data *svm_data;
diff --git a/drivers/kvm/lapic.c b/drivers/kvm/lapic.c
new file mode 100644
index 0000000000..a190587cf6
--- /dev/null
+++ b/drivers/kvm/lapic.c
@@ -0,0 +1,1064 @@
+
+/*
+ * Local APIC virtualization
+ *
+ * Copyright (C) 2006 Qumranet, Inc.
+ * Copyright (C) 2007 Novell
+ * Copyright (C) 2007 Intel
+ *
+ * Authors:
+ *   Dor Laor <dor.laor@qumranet.com>
+ *   Gregory Haskins <ghaskins@novell.com>
+ *   Yaozu (Eddie) Dong <eddie.dong@intel.com>
+ *
+ * Based on Xen 3.1 code, Copyright (c) 2004, Intel Corporation.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2.  See
+ * the COPYING file in the top-level directory.
+ */
+
+#include "kvm.h"
+#include <linux/kvm.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/smp.h>
+#include <linux/hrtimer.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <asm/processor.h>
+#include <asm/msr.h>
+#include <asm/page.h>
+#include <asm/current.h>
+#include <asm/apicdef.h>
+#include <asm/atomic.h>
+#include <asm/div64.h>
+#include "irq.h"
+
+#define PRId64 "d"
+#define PRIx64 "llx"
+#define PRIu64 "u"
+#define PRIo64 "o"
+
+#define APIC_BUS_CYCLE_NS 1
+
+/* #define apic_debug(fmt,arg...) printk(KERN_WARNING fmt,##arg) */
+#define apic_debug(fmt, arg...)
+
+#define APIC_LVT_NUM                    6
+/* 14 is the version for Xeon and Pentium 8.4.8*/
+#define APIC_VERSION                    (0x14UL | ((APIC_LVT_NUM - 1) << 16))
+#define LAPIC_MMIO_LENGTH               (1 << 12)
+/* followed define is not in apicdef.h */
+#define APIC_SHORT_MASK                 0xc0000
+#define APIC_DEST_NOSHORT               0x0
+#define APIC_DEST_MASK                  0x800
+#define MAX_APIC_VECTOR                 256
+
+#define VEC_POS(v) ((v) & (32 - 1))
+#define REG_POS(v) (((v) >> 5) << 4)
+static inline u32 apic_get_reg(struct kvm_lapic *apic, int reg_off)
+{
+        return *((u32 *) (apic->regs + reg_off));
+}
+
+static inline void apic_set_reg(struct kvm_lapic *apic, int reg_off, u32 val)
+{
+        *((u32 *) (apic->regs + reg_off)) = val;
+}
+
+static inline int apic_test_and_set_vector(int vec, void *bitmap)
+{
+        return test_and_set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
+static inline int apic_test_and_clear_vector(int vec, void *bitmap)
+{
+        return test_and_clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
+static inline void apic_set_vector(int vec, void *bitmap)
+{
+        set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
+static inline void apic_clear_vector(int vec, void *bitmap)
+{
+        clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
+static inline int apic_hw_enabled(struct kvm_lapic *apic)
+{
+        return (apic)->vcpu->apic_base & MSR_IA32_APICBASE_ENABLE;
+}
+
+static inline int  apic_sw_enabled(struct kvm_lapic *apic)
+{
+        return apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_APIC_ENABLED;
+}
+
+static inline int apic_enabled(struct kvm_lapic *apic)
+{
+        return apic_sw_enabled(apic) && apic_hw_enabled(apic);
+}
+
+#define LVT_MASK        \
+        (APIC_LVT_MASKED | APIC_SEND_PENDING | APIC_VECTOR_MASK)
+
+#define LINT_MASK       \
+        (LVT_MASK | APIC_MODE_MASK | APIC_INPUT_POLARITY | \
+         APIC_LVT_REMOTE_IRR | APIC_LVT_LEVEL_TRIGGER)
+
+static inline int kvm_apic_id(struct kvm_lapic *apic)
+{
+        return (apic_get_reg(apic, APIC_ID) >> 24) & 0xff;
+}
+
+static inline int apic_lvt_enabled(struct kvm_lapic *apic, int lvt_type)
+{
+        return !(apic_get_reg(apic, lvt_type) & APIC_LVT_MASKED);
+}
+
+static inline int apic_lvt_vector(struct kvm_lapic *apic, int lvt_type)
+{
+        return apic_get_reg(apic, lvt_type) & APIC_VECTOR_MASK;
+}
+
+static inline int apic_lvtt_period(struct kvm_lapic *apic)
+{
+        return apic_get_reg(apic, APIC_LVTT) & APIC_LVT_TIMER_PERIODIC;
+}
+
+static unsigned int apic_lvt_mask[APIC_LVT_NUM] = {
+        LVT_MASK | APIC_LVT_TIMER_PERIODIC,     /* LVTT */
+        LVT_MASK | APIC_MODE_MASK,      /* LVTTHMR */
+        LVT_MASK | APIC_MODE_MASK,      /* LVTPC */
+        LINT_MASK, LINT_MASK,   /* LVT0-1 */
+        LVT_MASK                /* LVTERR */
+};
+
+static int find_highest_vector(void *bitmap)
+{
+        u32 *word = bitmap;
+        int word_offset = MAX_APIC_VECTOR >> 5;
+
+        while ((word_offset != 0) && (word[(--word_offset) << 2] == 0))
+                continue;
+
+        if (likely(!word_offset && !word[0]))
+                return -1;
+        else
+                return fls(word[word_offset << 2]) - 1 + (word_offset << 5);
+}
+
+static inline int apic_test_and_set_irr(int vec, struct kvm_lapic *apic)
+{
+        return apic_test_and_set_vector(vec, apic->regs + APIC_IRR);
+}
+
+static inline void apic_clear_irr(int vec, struct kvm_lapic *apic)
+{
+        apic_clear_vector(vec, apic->regs + APIC_IRR);
+}
+
+static inline int apic_find_highest_irr(struct kvm_lapic *apic)
+{
+        int result;
+
+        result = find_highest_vector(apic->regs + APIC_IRR);
+        ASSERT(result == -1 || result >= 16);
+
+        return result;
+}
+
+int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)vcpu->apic;
+        int highest_irr;
+
+        if (!apic)
+                return 0;
+        highest_irr = apic_find_highest_irr(apic);
+
+        return highest_irr;
+}
+EXPORT_SYMBOL_GPL(kvm_lapic_find_highest_irr);
+
+int kvm_apic_set_irq(struct kvm_lapic *apic, u8 vec, u8 trig)
+{
+        if (!apic_test_and_set_irr(vec, apic)) {
+                /* a new pending irq is set in IRR */
+                if (trig)
+                        apic_set_vector(vec, apic->regs + APIC_TMR);
+                else
+                        apic_clear_vector(vec, apic->regs + APIC_TMR);
+                kvm_vcpu_kick(apic->vcpu);
+                return 1;
+        }
+        return 0;
+}
+
+static inline int apic_find_highest_isr(struct kvm_lapic *apic)
+{
+        int result;
+
+        result = find_highest_vector(apic->regs + APIC_ISR);
+        ASSERT(result == -1 || result >= 16);
+
+        return result;
+}
+
+static void apic_update_ppr(struct kvm_lapic *apic)
+{
+        u32 tpr, isrv, ppr;
+        int isr;
+
+        tpr = apic_get_reg(apic, APIC_TASKPRI);
+        isr = apic_find_highest_isr(apic);
+        isrv = (isr != -1) ? isr : 0;
+
+        if ((tpr & 0xf0) >= (isrv & 0xf0))
+                ppr = tpr & 0xff;
+        else
+                ppr = isrv & 0xf0;
+
+        apic_debug("vlapic %p, ppr 0x%x, isr 0x%x, isrv 0x%x",
+                   apic, ppr, isr, isrv);
+
+        apic_set_reg(apic, APIC_PROCPRI, ppr);
+}
+
+static void apic_set_tpr(struct kvm_lapic *apic, u32 tpr)
+{
+        apic_set_reg(apic, APIC_TASKPRI, tpr);
+        apic_update_ppr(apic);
+}
+
+int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest)
+{
+        return kvm_apic_id(apic) == dest;
+}
+
+int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
+{
+        int result = 0;
+        u8 logical_id;
+
+        logical_id = GET_APIC_LOGICAL_ID(apic_get_reg(apic, APIC_LDR));
+
+        switch (apic_get_reg(apic, APIC_DFR)) {
+        case APIC_DFR_FLAT:
+                if (logical_id & mda)
+                        result = 1;
+                break;
+        case APIC_DFR_CLUSTER:
+                if (((logical_id >> 4) == (mda >> 0x4))
+                    && (logical_id & mda & 0xf))
+                        result = 1;
+                break;
+        default:
+                printk(KERN_WARNING "Bad DFR vcpu %d: %08x\n",
+                       apic->vcpu->vcpu_id, apic_get_reg(apic, APIC_DFR));
+                break;
+        }
+
+        return result;
+}
+
+static int apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
+                           int short_hand, int dest, int dest_mode)
+{
+        int result = 0;
+        struct kvm_lapic *target = vcpu->apic;
+
+        apic_debug("target %p, source %p, dest 0x%x, "
+                   "dest_mode 0x%x, short_hand 0x%x",
+                   target, source, dest, dest_mode, short_hand);
+
+        ASSERT(!target);
+        switch (short_hand) {
+        case APIC_DEST_NOSHORT:
+                if (dest_mode == 0) {
+                        /* Physical mode. */
+                        if ((dest == 0xFF) || (dest == kvm_apic_id(target)))
+                                result = 1;
+                } else
+                        /* Logical mode. */
+                        result = kvm_apic_match_logical_addr(target, dest);
+                break;
+        case APIC_DEST_SELF:
+                if (target == source)
+                        result = 1;
+                break;
+        case APIC_DEST_ALLINC:
+                result = 1;
+                break;
+        case APIC_DEST_ALLBUT:
+                if (target != source)
+                        result = 1;
+                break;
+        default:
+                printk(KERN_WARNING "Bad dest shorthand value %x\n",
+                       short_hand);
+                break;
+        }
+
+        return result;
+}
+
+/*
+ * Add a pending IRQ into lapic.
+ * Return 1 if successfully added and 0 if discarded.
+ */
+static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
+                             int vector, int level, int trig_mode)
+{
+        int orig_irr, result = 0;
+        struct kvm_vcpu *vcpu = apic->vcpu;
+
+        switch (delivery_mode) {
+        case APIC_DM_FIXED:
+        case APIC_DM_LOWEST:
+                /* FIXME add logic for vcpu on reset */
+                if (unlikely(!apic_enabled(apic)))
+                        break;
+
+                orig_irr = apic_test_and_set_irr(vector, apic);
+                if (orig_irr && trig_mode) {
+                        apic_debug("level trig mode repeatedly for vector %d",
+                                   vector);
+                        break;
+                }
+
+                if (trig_mode) {
+                        apic_debug("level trig mode for vector %d", vector);
+                        apic_set_vector(vector, apic->regs + APIC_TMR);
+                } else
+                        apic_clear_vector(vector, apic->regs + APIC_TMR);
+
+                if (vcpu->mp_state == VCPU_MP_STATE_RUNNABLE)
+                        kvm_vcpu_kick(vcpu);
+                else if (vcpu->mp_state == VCPU_MP_STATE_HALTED) {
+                        vcpu->mp_state = VCPU_MP_STATE_RUNNABLE;
+                        if (waitqueue_active(&vcpu->wq))
+                                wake_up_interruptible(&vcpu->wq);
+                }
+
+                result = (orig_irr == 0);
+                break;
+
+        case APIC_DM_REMRD:
+                printk(KERN_DEBUG "Ignoring delivery mode 3\n");
+                break;
+
+        case APIC_DM_SMI:
+                printk(KERN_DEBUG "Ignoring guest SMI\n");
+                break;
+        case APIC_DM_NMI:
+                printk(KERN_DEBUG "Ignoring guest NMI\n");
+                break;
+
+        case APIC_DM_INIT:
+                if (level) {
+                        if (vcpu->mp_state == VCPU_MP_STATE_RUNNABLE)
+                                printk(KERN_DEBUG
+                                       "INIT on a runnable vcpu %d\n",
+                                       vcpu->vcpu_id);
+                        vcpu->mp_state = VCPU_MP_STATE_INIT_RECEIVED;
+                        kvm_vcpu_kick(vcpu);
+                } else {
+                        printk(KERN_DEBUG
+                               "Ignoring de-assert INIT to vcpu %d\n",
+                               vcpu->vcpu_id);
+                }
+
+                break;
+
+        case APIC_DM_STARTUP:
+                printk(KERN_DEBUG "SIPI to vcpu %d vector 0x%02x\n",
+                       vcpu->vcpu_id, vector);
+                if (vcpu->mp_state == VCPU_MP_STATE_INIT_RECEIVED) {
+                        vcpu->sipi_vector = vector;
+                        vcpu->mp_state = VCPU_MP_STATE_SIPI_RECEIVED;
+                        if (waitqueue_active(&vcpu->wq))
+                                wake_up_interruptible(&vcpu->wq);
+                }
+                break;
+
+        default:
+                printk(KERN_ERR "TODO: unsupported delivery mode %x\n",
+                       delivery_mode);
+                break;
+        }
+        return result;
+}
+
+struct kvm_lapic *kvm_apic_round_robin(struct kvm *kvm, u8 vector,
+                                       unsigned long bitmap)
+{
+        int vcpu_id;
+        int last;
+        int next;
+        struct kvm_lapic *apic;
+
+        last = kvm->round_robin_prev_vcpu;
+        next = last;
+
+        do {
+                if (++next == KVM_MAX_VCPUS)
+                        next = 0;
+                if (kvm->vcpus[next] == NULL || !test_bit(next, &bitmap))
+                        continue;
+                apic = kvm->vcpus[next]->apic;
+                if (apic && apic_enabled(apic))
+                        break;
+                apic = NULL;
+        } while (next != last);
+        kvm->round_robin_prev_vcpu = next;
+
+        if (!apic) {
+                vcpu_id = ffs(bitmap) - 1;
+                if (vcpu_id < 0) {
+                        vcpu_id = 0;
+                        printk(KERN_DEBUG "vcpu not ready for apic_round_robin\n");
+                }
+                apic = kvm->vcpus[vcpu_id]->apic;
+        }
+
+        return apic;
+}
+
+static void apic_set_eoi(struct kvm_lapic *apic)
+{
+        int vector = apic_find_highest_isr(apic);
+
+        /*
+         * Not every write EOI will has corresponding ISR,
+         * one example is when Kernel check timer on setup_IO_APIC
+         */
+        if (vector == -1)
+                return;
+
+        apic_clear_vector(vector, apic->regs + APIC_ISR);
+        apic_update_ppr(apic);
+
+        if (apic_test_and_clear_vector(vector, apic->regs + APIC_TMR))
+                kvm_ioapic_update_eoi(apic->vcpu->kvm, vector);
+}
+
+static void apic_send_ipi(struct kvm_lapic *apic)
+{
+        u32 icr_low = apic_get_reg(apic, APIC_ICR);
+        u32 icr_high = apic_get_reg(apic, APIC_ICR2);
+
+        unsigned int dest = GET_APIC_DEST_FIELD(icr_high);
+        unsigned int short_hand = icr_low & APIC_SHORT_MASK;
+        unsigned int trig_mode = icr_low & APIC_INT_LEVELTRIG;
+        unsigned int level = icr_low & APIC_INT_ASSERT;
+        unsigned int dest_mode = icr_low & APIC_DEST_MASK;
+        unsigned int delivery_mode = icr_low & APIC_MODE_MASK;
+        unsigned int vector = icr_low & APIC_VECTOR_MASK;
+
+        struct kvm_lapic *target;
+        struct kvm_vcpu *vcpu;
+        unsigned long lpr_map = 0;
+        int i;
+
+        apic_debug("icr_high 0x%x, icr_low 0x%x, "
+                   "short_hand 0x%x, dest 0x%x, trig_mode 0x%x, level 0x%x, "
+                   "dest_mode 0x%x, delivery_mode 0x%x, vector 0x%x\n",
+                   icr_high, icr_low, short_hand, dest,
+                   trig_mode, level, dest_mode, delivery_mode, vector);
+
+        for (i = 0; i < KVM_MAX_VCPUS; i++) {
+                vcpu = apic->vcpu->kvm->vcpus[i];
+                if (!vcpu)
+                        continue;
+
+                if (vcpu->apic &&
+                    apic_match_dest(vcpu, apic, short_hand, dest, dest_mode)) {
+                        if (delivery_mode == APIC_DM_LOWEST)
+                                set_bit(vcpu->vcpu_id, &lpr_map);
+                        else
+                                __apic_accept_irq(vcpu->apic, delivery_mode,
+                                                  vector, level, trig_mode);
+                }
+        }
+
+        if (delivery_mode == APIC_DM_LOWEST) {
+                target = kvm_apic_round_robin(vcpu->kvm, vector, lpr_map);
+                if (target != NULL)
+                        __apic_accept_irq(target, delivery_mode,
+                                          vector, level, trig_mode);
+        }
+}
+
+static u32 apic_get_tmcct(struct kvm_lapic *apic)
+{
+        u32 counter_passed;
+        ktime_t passed, now = apic->timer.dev.base->get_time();
+        u32 tmcct = apic_get_reg(apic, APIC_TMICT);
+
+        ASSERT(apic != NULL);
+
+        if (unlikely(ktime_to_ns(now) <=
+                ktime_to_ns(apic->timer.last_update))) {
+                /* Wrap around */
+                passed = ktime_add(( {
+                                    (ktime_t) {
+                                    .tv64 = KTIME_MAX -
+                                    (apic->timer.last_update).tv64}; }
+                                   ), now);
+                apic_debug("time elapsed\n");
+        } else
+                passed = ktime_sub(now, apic->timer.last_update);
+
+        counter_passed = div64_64(ktime_to_ns(passed),
+                                  (APIC_BUS_CYCLE_NS * apic->timer.divide_count));
+        tmcct -= counter_passed;
+
+        if (tmcct <= 0) {
+                if (unlikely(!apic_lvtt_period(apic)))
+                        tmcct = 0;
+                else
+                        do {
+                                tmcct += apic_get_reg(apic, APIC_TMICT);
+                        } while (tmcct <= 0);
+        }
+
+        return tmcct;
+}
+
+static u32 __apic_read(struct kvm_lapic *apic, unsigned int offset)
+{
+        u32 val = 0;
+
+        if (offset >= LAPIC_MMIO_LENGTH)
+                return 0;
+
+        switch (offset) {
+        case APIC_ARBPRI:
+                printk(KERN_WARNING "Access APIC ARBPRI register "
+                       "which is for P6\n");
+                break;
+
+        case APIC_TMCCT:        /* Timer CCR */
+                val = apic_get_tmcct(apic);
+                break;
+
+        default:
+                apic_update_ppr(apic);
+                val = apic_get_reg(apic, offset);
+                break;
+        }
+
+        return val;
+}
+
+static void apic_mmio_read(struct kvm_io_device *this,
+                           gpa_t address, int len, void *data)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)this->private;
+        unsigned int offset = address - apic->base_address;
+        unsigned char alignment = offset & 0xf;
+        u32 result;
+
+        if ((alignment + len) > 4) {
+                printk(KERN_ERR "KVM_APIC_READ: alignment error %lx %d",
+                       (unsigned long)address, len);
+                return;
+        }
+        result = __apic_read(apic, offset & ~0xf);
+
+        switch (len) {
+        case 1:
+        case 2:
+        case 4:
+                memcpy(data, (char *)&result + alignment, len);
+                break;
+        default:
+                printk(KERN_ERR "Local APIC read with len = %x, "
+                       "should be 1,2, or 4 instead\n", len);
+                break;
+        }
+}
+
+static void update_divide_count(struct kvm_lapic *apic)
+{
+        u32 tmp1, tmp2, tdcr;
+
+        tdcr = apic_get_reg(apic, APIC_TDCR);
+        tmp1 = tdcr & 0xf;
+        tmp2 = ((tmp1 & 0x3) | ((tmp1 & 0x8) >> 1)) + 1;
+        apic->timer.divide_count = 0x1 << (tmp2 & 0x7);
+
+        apic_debug("timer divide count is 0x%x\n",
+                                   apic->timer.divide_count);
+}
+
+static void start_apic_timer(struct kvm_lapic *apic)
+{
+        ktime_t now = apic->timer.dev.base->get_time();
+
+        apic->timer.last_update = now;
+
+        apic->timer.period = apic_get_reg(apic, APIC_TMICT) *
+                    APIC_BUS_CYCLE_NS * apic->timer.divide_count;
+        atomic_set(&apic->timer.pending, 0);
+        hrtimer_start(&apic->timer.dev,
+                      ktime_add_ns(now, apic->timer.period),
+                      HRTIMER_MODE_ABS);
+
+        apic_debug("%s: bus cycle is %" PRId64 "ns, now 0x%016"
+                           PRIx64 ", "
+                           "timer initial count 0x%x, period %lldns, "
+                           "expire @ 0x%016" PRIx64 ".\n", __FUNCTION__,
+                           APIC_BUS_CYCLE_NS, ktime_to_ns(now),
+                           apic_get_reg(apic, APIC_TMICT),
+                           apic->timer.period,
+                           ktime_to_ns(ktime_add_ns(now,
+                                        apic->timer.period)));
+}
+
+static void apic_mmio_write(struct kvm_io_device *this,
+                            gpa_t address, int len, const void *data)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)this->private;
+        unsigned int offset = address - apic->base_address;
+        unsigned char alignment = offset & 0xf;
+        u32 val;
+
+        /*
+         * APIC register must be aligned on 128-bits boundary.
+         * 32/64/128 bits registers must be accessed thru 32 bits.
+         * Refer SDM 8.4.1
+         */
+        if (len != 4 || alignment) {
+                if (printk_ratelimit())
+                        printk(KERN_ERR "apic write: bad size=%d %lx\n",
+                               len, (long)address);
+                return;
+        }
+
+        val = *(u32 *) data;
+
+        /* too common printing */
+        if (offset != APIC_EOI)
+                apic_debug("%s: offset 0x%x with length 0x%x, and value is "
+                           "0x%x\n", __FUNCTION__, offset, len, val);
+
+        offset &= 0xff0;
+
+        switch (offset) {
+        case APIC_ID:           /* Local APIC ID */
+                apic_set_reg(apic, APIC_ID, val);
+                break;
+
+        case APIC_TASKPRI:
+                apic_set_tpr(apic, val & 0xff);
+                break;
+
+        case APIC_EOI:
+                apic_set_eoi(apic);
+                break;
+
+        case APIC_LDR:
+                apic_set_reg(apic, APIC_LDR, val & APIC_LDR_MASK);
+                break;
+
+        case APIC_DFR:
+                apic_set_reg(apic, APIC_DFR, val | 0x0FFFFFFF);
+                break;
+
+        case APIC_SPIV:
+                apic_set_reg(apic, APIC_SPIV, val & 0x3ff);
+                if (!(val & APIC_SPIV_APIC_ENABLED)) {
+                        int i;
+                        u32 lvt_val;
+
+                        for (i = 0; i < APIC_LVT_NUM; i++) {
+                                lvt_val = apic_get_reg(apic,
+                                                       APIC_LVTT + 0x10 * i);
+                                apic_set_reg(apic, APIC_LVTT + 0x10 * i,
+                                             lvt_val | APIC_LVT_MASKED);
+                        }
+                        atomic_set(&apic->timer.pending, 0);
+
+                }
+                break;
+
+        case APIC_ICR:
+                /* No delay here, so we always clear the pending bit */
+                apic_set_reg(apic, APIC_ICR, val & ~(1 << 12));
+                apic_send_ipi(apic);
+                break;
+
+        case APIC_ICR2:
+                apic_set_reg(apic, APIC_ICR2, val & 0xff000000);
+                break;
+
+        case APIC_LVTT:
+        case APIC_LVTTHMR:
+        case APIC_LVTPC:
+        case APIC_LVT0:
+        case APIC_LVT1:
+        case APIC_LVTERR:
+                /* TODO: Check vector */
+                if (!apic_sw_enabled(apic))
+                        val |= APIC_LVT_MASKED;
+
+                val &= apic_lvt_mask[(offset - APIC_LVTT) >> 4];
+                apic_set_reg(apic, offset, val);
+
+                break;
+
+        case APIC_TMICT:
+                hrtimer_cancel(&apic->timer.dev);
+                apic_set_reg(apic, APIC_TMICT, val);
+                start_apic_timer(apic);
+                return;
+
+        case APIC_TDCR:
+                if (val & 4)
+                        printk(KERN_ERR "KVM_WRITE:TDCR %x\n", val);
+                apic_set_reg(apic, APIC_TDCR, val);
+                update_divide_count(apic);
+                break;
+
+        default:
+                apic_debug("Local APIC Write to read-only register %x\n",
+                           offset);
+                break;
+        }
+
+}
+
+static int apic_mmio_range(struct kvm_io_device *this, gpa_t addr)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)this->private;
+        int ret = 0;
+
+
+        if (apic_hw_enabled(apic) &&
+            (addr >= apic->base_address) &&
+            (addr < (apic->base_address + LAPIC_MMIO_LENGTH)))
+                ret = 1;
+
+        return ret;
+}
+
+void kvm_free_apic(struct kvm_lapic *apic)
+{
+        if (!apic)
+                return;
+
+        hrtimer_cancel(&apic->timer.dev);
+
+        if (apic->regs_page) {
+                __free_page(apic->regs_page);
+                apic->regs_page = 0;
+        }
+
+        kfree(apic);
+}
+
+/*
+ *----------------------------------------------------------------------
+ * LAPIC interface
+ *----------------------------------------------------------------------
+ */
+
+void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)vcpu->apic;
+
+        if (!apic)
+                return;
+        apic_set_tpr(apic, ((cr8 & 0x0f) << 4));
+}
+
+u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)vcpu->apic;
+        u64 tpr;
+
+        if (!apic)
+                return 0;
+        tpr = (u64) apic_get_reg(apic, APIC_TASKPRI);
+
+        return (tpr & 0xf0) >> 4;
+}
+EXPORT_SYMBOL_GPL(kvm_lapic_get_cr8);
+
+void kvm_lapic_set_base(struct kvm_vcpu *vcpu, u64 value)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)vcpu->apic;
+
+        if (!apic) {
+                value |= MSR_IA32_APICBASE_BSP;
+                vcpu->apic_base = value;
+                return;
+        }
+        if (apic->vcpu->vcpu_id)
+                value &= ~MSR_IA32_APICBASE_BSP;
+
+        vcpu->apic_base = value;
+        apic->base_address = apic->vcpu->apic_base &
+                             MSR_IA32_APICBASE_BASE;
+
+        /* with FSB delivery interrupt, we can restart APIC functionality */
+        apic_debug("apic base msr is 0x%016" PRIx64 ", and base address is "
+                   "0x%lx.\n", apic->apic_base, apic->base_address);
+
+}
+
+u64 kvm_lapic_get_base(struct kvm_vcpu *vcpu)
+{
+        return vcpu->apic_base;
+}
+EXPORT_SYMBOL_GPL(kvm_lapic_get_base);
+
+void kvm_lapic_reset(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic;
+        int i;
+
+        apic_debug("%s\n", __FUNCTION__);
+
+        ASSERT(vcpu);
+        apic = vcpu->apic;
+        ASSERT(apic != NULL);
+
+        /* Stop the timer in case it's a reset to an active apic */
+        hrtimer_cancel(&apic->timer.dev);
+
+        apic_set_reg(apic, APIC_ID, vcpu->vcpu_id << 24);
+        apic_set_reg(apic, APIC_LVR, APIC_VERSION);
+
+        for (i = 0; i < APIC_LVT_NUM; i++)
+                apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);
+        apic_set_reg(apic, APIC_LVT0,
+                     SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));
+
+        apic_set_reg(apic, APIC_DFR, 0xffffffffU);
+        apic_set_reg(apic, APIC_SPIV, 0xff);
+        apic_set_reg(apic, APIC_TASKPRI, 0);
+        apic_set_reg(apic, APIC_LDR, 0);
+        apic_set_reg(apic, APIC_ESR, 0);
+        apic_set_reg(apic, APIC_ICR, 0);
+        apic_set_reg(apic, APIC_ICR2, 0);
+        apic_set_reg(apic, APIC_TDCR, 0);
+        apic_set_reg(apic, APIC_TMICT, 0);
+        for (i = 0; i < 8; i++) {
+                apic_set_reg(apic, APIC_IRR + 0x10 * i, 0);
+                apic_set_reg(apic, APIC_ISR + 0x10 * i, 0);
+                apic_set_reg(apic, APIC_TMR + 0x10 * i, 0);
+        }
+        apic->timer.divide_count = 0;
+        atomic_set(&apic->timer.pending, 0);
+        if (vcpu->vcpu_id == 0)
+                vcpu->apic_base |= MSR_IA32_APICBASE_BSP;
+        apic_update_ppr(apic);
+
+        apic_debug(KERN_INFO "%s: vcpu=%p, id=%d, base_msr="
+                   "0x%016" PRIx64 ", base_address=0x%0lx.\n", __FUNCTION__,
+                   vcpu, kvm_apic_id(apic),
+                   vcpu->apic_base, apic->base_address);
+}
+EXPORT_SYMBOL_GPL(kvm_lapic_reset);
+
+int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = (struct kvm_lapic *)vcpu->apic;
+        int ret = 0;
+
+        if (!apic)
+                return 0;
+        ret = apic_enabled(apic);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(kvm_lapic_enabled);
+
+/*
+ *----------------------------------------------------------------------
+ * timer interface
+ *----------------------------------------------------------------------
+ */
+
+/* TODO: make sure __apic_timer_fn runs in current pCPU */
+static int __apic_timer_fn(struct kvm_lapic *apic)
+{
+        int result = 0;
+        wait_queue_head_t *q = &apic->vcpu->wq;
+
+        atomic_inc(&apic->timer.pending);
+        if (waitqueue_active(q))
+        {
+                apic->vcpu->mp_state = VCPU_MP_STATE_RUNNABLE;
+                wake_up_interruptible(q);
+        }
+        if (apic_lvtt_period(apic)) {
+                result = 1;
+                apic->timer.dev.expires = ktime_add_ns(
+                                        apic->timer.dev.expires,
+                                        apic->timer.period);
+        }
+        return result;
+}
+
+static int __inject_apic_timer_irq(struct kvm_lapic *apic)
+{
+        int vector;
+
+        vector = apic_lvt_vector(apic, APIC_LVTT);
+        return __apic_accept_irq(apic, APIC_DM_FIXED, vector, 1, 0);
+}
+
+static enum hrtimer_restart apic_timer_fn(struct hrtimer *data)
+{
+        struct kvm_lapic *apic;
+        int restart_timer = 0;
+
+        apic = container_of(data, struct kvm_lapic, timer.dev);
+
+        restart_timer = __apic_timer_fn(apic);
+
+        if (restart_timer)
+                return HRTIMER_RESTART;
+        else
+                return HRTIMER_NORESTART;
+}
+
+int kvm_create_lapic(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic;
+
+        ASSERT(vcpu != NULL);
+        apic_debug("apic_init %d\n", vcpu->vcpu_id);
+
+        apic = kzalloc(sizeof(*apic), GFP_KERNEL);
+        if (!apic)
+                goto nomem;
+
+        vcpu->apic = apic;
+
+        apic->regs_page = alloc_page(GFP_KERNEL);
+        if (apic->regs_page == NULL) {
+                printk(KERN_ERR "malloc apic regs error for vcpu %x\n",
+                       vcpu->vcpu_id);
+                goto nomem;
+        }
+        apic->regs = page_address(apic->regs_page);
+        memset(apic->regs, 0, PAGE_SIZE);
+        apic->vcpu = vcpu;
+
+        hrtimer_init(&apic->timer.dev, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+        apic->timer.dev.function = apic_timer_fn;
+        apic->base_address = APIC_DEFAULT_PHYS_BASE;
+        vcpu->apic_base = APIC_DEFAULT_PHYS_BASE;
+
+        kvm_lapic_reset(vcpu);
+        apic->dev.read = apic_mmio_read;
+        apic->dev.write = apic_mmio_write;
+        apic->dev.in_range = apic_mmio_range;
+        apic->dev.private = apic;
+
+        return 0;
+nomem:
+        kvm_free_apic(apic);
+        return -ENOMEM;
+}
+EXPORT_SYMBOL_GPL(kvm_create_lapic);
+
+int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = vcpu->apic;
+        int highest_irr;
+
+        if (!apic || !apic_enabled(apic))
+                return -1;
+
+        apic_update_ppr(apic);
+        highest_irr = apic_find_highest_irr(apic);
+        if ((highest_irr == -1) ||
+            ((highest_irr & 0xF0) <= apic_get_reg(apic, APIC_PROCPRI)))
+                return -1;
+        return highest_irr;
+}
+
+int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu)
+{
+        u32 lvt0 = apic_get_reg(vcpu->apic, APIC_LVT0);
+        int r = 0;
+
+        if (vcpu->vcpu_id == 0) {
+                if (!apic_hw_enabled(vcpu->apic))
+                        r = 1;
+                if ((lvt0 & APIC_LVT_MASKED) == 0 &&
+                    GET_APIC_DELIVERY_MODE(lvt0) == APIC_MODE_EXTINT)
+                        r = 1;
+        }
+        return r;
+}
+
+void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = vcpu->apic;
+
+        if (apic && apic_lvt_enabled(apic, APIC_LVTT) &&
+                atomic_read(&apic->timer.pending) > 0) {
+                if (__inject_apic_timer_irq(apic))
+                        atomic_dec(&apic->timer.pending);
+        }
+}
+
+void kvm_apic_timer_intr_post(struct kvm_vcpu *vcpu, int vec)
+{
+        struct kvm_lapic *apic = vcpu->apic;
+
+        if (apic && apic_lvt_vector(apic, APIC_LVTT) == vec)
+                apic->timer.last_update = ktime_add_ns(
+                                apic->timer.last_update,
+                                apic->timer.period);
+}
+
+int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu)
+{
+        int vector = kvm_apic_has_interrupt(vcpu);
+        struct kvm_lapic *apic = vcpu->apic;
+
+        if (vector == -1)
+                return -1;
+
+        apic_set_vector(vector, apic->regs + APIC_ISR);
+        apic_update_ppr(apic);
+        apic_clear_irr(vector, apic);
+        return vector;
+}
+
+void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = vcpu->apic;
+
+        apic->base_address = vcpu->apic_base &
+                             MSR_IA32_APICBASE_BASE;
+        apic_set_reg(apic, APIC_LVR, APIC_VERSION);
+        apic_update_ppr(apic);
+        hrtimer_cancel(&apic->timer.dev);
+        update_divide_count(apic);
+        start_apic_timer(apic);
+}
+
+void kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
+{
+        struct kvm_lapic *apic = vcpu->apic;
+        struct hrtimer *timer;
+
+        if (!apic)
+                return;
+
+        timer = &apic->timer.dev;
+        if (hrtimer_cancel(timer))
+                hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
+}
+EXPORT_SYMBOL_GPL(kvm_migrate_apic_timer);
diff --git a/drivers/kvm/mmu.c b/drivers/kvm/mmu.c
index 23965aa5ee..6d84d30f5e 100644
--- a/drivers/kvm/mmu.c
+++ b/drivers/kvm/mmu.c
@@ -158,7 +158,7 @@ static struct kmem_cache *mmu_page_header_cache;
 
 static int is_write_protection(struct kvm_vcpu *vcpu)
 {
-        return vcpu->cr0 & CR0_WP_MASK;
+        return vcpu->cr0 & X86_CR0_WP;
 }
 
 static int is_cpuid_PSE36(void)
@@ -202,15 +202,14 @@ static void set_shadow_pte(u64 *sptep, u64 spte)
 }
 
 static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache,
-                                  struct kmem_cache *base_cache, int min,
-                                  gfp_t gfp_flags)
+                                  struct kmem_cache *base_cache, int min)
 {
         void *obj;
 
         if (cache->nobjs >= min)
                 return 0;
         while (cache->nobjs < ARRAY_SIZE(cache->objects)) {
-                obj = kmem_cache_zalloc(base_cache, gfp_flags);
+                obj = kmem_cache_zalloc(base_cache, GFP_KERNEL);
                 if (!obj)
                         return -ENOMEM;
                 cache->objects[cache->nobjs++] = obj;
@@ -225,14 +224,14 @@ static void mmu_free_memory_cache(struct kvm_mmu_memory_cache *mc)
 }
 
 static int mmu_topup_memory_cache_page(struct kvm_mmu_memory_cache *cache,
-                                       int min, gfp_t gfp_flags)
+                                       int min)
 {
         struct page *page;
 
         if (cache->nobjs >= min)
                 return 0;
         while (cache->nobjs < ARRAY_SIZE(cache->objects)) {
-                page = alloc_page(gfp_flags);
+                page = alloc_page(GFP_KERNEL);
                 if (!page)
                         return -ENOMEM;
                 set_page_private(page, 0);
@@ -247,44 +246,28 @@ static void mmu_free_memory_cache_page(struct kvm_mmu_memory_cache *mc)
                 free_page((unsigned long)mc->objects[--mc->nobjs]);
 }
 
-static int __mmu_topup_memory_caches(struct kvm_vcpu *vcpu, gfp_t gfp_flags)
+static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu)
 {
         int r;
 
+        kvm_mmu_free_some_pages(vcpu);
         r = mmu_topup_memory_cache(&vcpu->mmu_pte_chain_cache,
-                                   pte_chain_cache, 4, gfp_flags);
+                                   pte_chain_cache, 4);
         if (r)
                 goto out;
         r = mmu_topup_memory_cache(&vcpu->mmu_rmap_desc_cache,
-                                   rmap_desc_cache, 1, gfp_flags);
+                                   rmap_desc_cache, 1);
         if (r)
                 goto out;
-        r = mmu_topup_memory_cache_page(&vcpu->mmu_page_cache, 4, gfp_flags);
+        r = mmu_topup_memory_cache_page(&vcpu->mmu_page_cache, 4);
         if (r)
                 goto out;
         r = mmu_topup_memory_cache(&vcpu->mmu_page_header_cache,
-                                   mmu_page_header_cache, 4, gfp_flags);
+                                   mmu_page_header_cache, 4);
 out:
         return r;
 }
 
-static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu)
-{
-        int r;
-
-        r = __mmu_topup_memory_caches(vcpu, GFP_NOWAIT);
-        kvm_mmu_free_some_pages(vcpu);
-        if (r < 0) {
-                spin_unlock(&vcpu->kvm->lock);
-                kvm_arch_ops->vcpu_put(vcpu);
-                r = __mmu_topup_memory_caches(vcpu, GFP_KERNEL);
-                kvm_arch_ops->vcpu_load(vcpu);
-                spin_lock(&vcpu->kvm->lock);
-                kvm_mmu_free_some_pages(vcpu);
-        }
-        return r;
-}
-
 static void mmu_free_memory_caches(struct kvm_vcpu *vcpu)
 {
         mmu_free_memory_cache(&vcpu->mmu_pte_chain_cache);
@@ -969,7 +952,7 @@ static int nonpaging_init_context(struct kvm_vcpu *vcpu)
 static void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu)
 {
         ++vcpu->stat.tlb_flush;
-        kvm_arch_ops->tlb_flush(vcpu);
+        kvm_x86_ops->tlb_flush(vcpu);
 }
 
 static void paging_new_cr3(struct kvm_vcpu *vcpu)
@@ -982,7 +965,7 @@ static void inject_page_fault(struct kvm_vcpu *vcpu,
                               u64 addr,
                               u32 err_code)
 {
-        kvm_arch_ops->inject_page_fault(vcpu, addr, err_code);
+        kvm_x86_ops->inject_page_fault(vcpu, addr, err_code);
 }
 
 static void paging_free(struct kvm_vcpu *vcpu)
@@ -1071,15 +1054,15 @@ int kvm_mmu_load(struct kvm_vcpu *vcpu)
 {
         int r;
 
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&vcpu->kvm->lock);
         r = mmu_topup_memory_caches(vcpu);
         if (r)
                 goto out;
         mmu_alloc_roots(vcpu);
-        kvm_arch_ops->set_cr3(vcpu, vcpu->mmu.root_hpa);
+        kvm_x86_ops->set_cr3(vcpu, vcpu->mmu.root_hpa);
         kvm_mmu_flush_tlb(vcpu);
 out:
-        spin_unlock(&vcpu->kvm->lock);
+        mutex_unlock(&vcpu->kvm->lock);
         return r;
 }
 EXPORT_SYMBOL_GPL(kvm_mmu_load);
@@ -1124,7 +1107,7 @@ static void mmu_pte_write_new_pte(struct kvm_vcpu *vcpu,
 }
 
 void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
-                       const u8 *old, const u8 *new, int bytes)
+                       const u8 *new, int bytes)
 {
         gfn_t gfn = gpa >> PAGE_SHIFT;
         struct kvm_mmu_page *page;
diff --git a/drivers/kvm/paging_tmpl.h b/drivers/kvm/paging_tmpl.h
index 4b5391c717..6b094b44f8 100644
--- a/drivers/kvm/paging_tmpl.h
+++ b/drivers/kvm/paging_tmpl.h
@@ -58,7 +58,10 @@ struct guest_walker {
         int level;
         gfn_t table_gfn[PT_MAX_FULL_LEVELS];
         pt_element_t *table;
+        pt_element_t pte;
         pt_element_t *ptep;
+        struct page *page;
+        int index;
         pt_element_t inherited_ar;
         gfn_t gfn;
         u32 error_code;
@@ -80,11 +83,14 @@ static int FNAME(walk_addr)(struct guest_walker *walker,
         pgprintk("%s: addr %lx\n", __FUNCTION__, addr);
         walker->level = vcpu->mmu.root_level;
         walker->table = NULL;
+        walker->page = NULL;
+        walker->ptep = NULL;
         root = vcpu->cr3;
 #if PTTYPE == 64
         if (!is_long_mode(vcpu)) {
                 walker->ptep = &vcpu->pdptrs[(addr >> 30) & 3];
                 root = *walker->ptep;
+                walker->pte = root;
                 if (!(root & PT_PRESENT_MASK))
                         goto not_present;
                 --walker->level;
@@ -96,10 +102,11 @@ static int FNAME(walk_addr)(struct guest_walker *walker,
                  walker->level - 1, table_gfn);
         slot = gfn_to_memslot(vcpu->kvm, table_gfn);
         hpa = safe_gpa_to_hpa(vcpu, root & PT64_BASE_ADDR_MASK);
-        walker->table = kmap_atomic(pfn_to_page(hpa >> PAGE_SHIFT), KM_USER0);
+        walker->page = pfn_to_page(hpa >> PAGE_SHIFT);
+        walker->table = kmap_atomic(walker->page, KM_USER0);
 
         ASSERT((!is_long_mode(vcpu) && is_pae(vcpu)) ||
-               (vcpu->cr3 & ~(PAGE_MASK | CR3_FLAGS_MASK)) == 0);
+               (vcpu->cr3 & CR3_NONPAE_RESERVED_BITS) == 0);
 
         walker->inherited_ar = PT_USER_MASK | PT_WRITABLE_MASK;
 
@@ -108,6 +115,7 @@ static int FNAME(walk_addr)(struct guest_walker *walker,
                 hpa_t paddr;
 
                 ptep = &walker->table[index];
+                walker->index = index;
                 ASSERT(((unsigned long)walker->table & PAGE_MASK) ==
                        ((unsigned long)ptep & PAGE_MASK));
 
@@ -148,16 +156,20 @@ static int FNAME(walk_addr)(struct guest_walker *walker,
 
                 walker->inherited_ar &= walker->table[index];
                 table_gfn = (*ptep & PT_BASE_ADDR_MASK) >> PAGE_SHIFT;
-                paddr = safe_gpa_to_hpa(vcpu, *ptep & PT_BASE_ADDR_MASK);
                 kunmap_atomic(walker->table, KM_USER0);
-                walker->table = kmap_atomic(pfn_to_page(paddr >> PAGE_SHIFT),
-                                            KM_USER0);
+                paddr = safe_gpa_to_hpa(vcpu, table_gfn << PAGE_SHIFT);
+                walker->page = pfn_to_page(paddr >> PAGE_SHIFT);
+                walker->table = kmap_atomic(walker->page, KM_USER0);
                 --walker->level;
                 walker->table_gfn[walker->level - 1 ] = table_gfn;
                 pgprintk("%s: table_gfn[%d] %lx\n", __FUNCTION__,
                          walker->level - 1, table_gfn);
         }
-        walker->ptep = ptep;
+        walker->pte = *ptep;
+        if (walker->page)
+                walker->ptep = NULL;
+        if (walker->table)
+                kunmap_atomic(walker->table, KM_USER0);
         pgprintk("%s: pte %llx\n", __FUNCTION__, (u64)*ptep);
         return 1;
 
@@ -175,13 +187,9 @@ err:
                 walker->error_code |= PFERR_USER_MASK;
         if (fetch_fault)
                 walker->error_code |= PFERR_FETCH_MASK;
-        return 0;
-}
-
-static void FNAME(release_walker)(struct guest_walker *walker)
-{
         if (walker->table)
                 kunmap_atomic(walker->table, KM_USER0);
+        return 0;
 }
 
 static void FNAME(mark_pagetable_dirty)(struct kvm *kvm,
@@ -193,7 +201,7 @@ static void FNAME(mark_pagetable_dirty)(struct kvm *kvm,
 static void FNAME(set_pte_common)(struct kvm_vcpu *vcpu,
                                   u64 *shadow_pte,
                                   gpa_t gaddr,
-                                  pt_element_t *gpte,
+                                  pt_element_t gpte,
                                   u64 access_bits,
                                   int user_fault,
                                   int write_fault,
@@ -202,23 +210,34 @@ static void FNAME(set_pte_common)(struct kvm_vcpu *vcpu,
                                   gfn_t gfn)
 {
         hpa_t paddr;
-        int dirty = *gpte & PT_DIRTY_MASK;
+        int dirty = gpte & PT_DIRTY_MASK;
         u64 spte = *shadow_pte;
         int was_rmapped = is_rmap_pte(spte);
 
         pgprintk("%s: spte %llx gpte %llx access %llx write_fault %d"
                  " user_fault %d gfn %lx\n",
-                 __FUNCTION__, spte, (u64)*gpte, access_bits,
+                 __FUNCTION__, spte, (u64)gpte, access_bits,
                  write_fault, user_fault, gfn);
 
         if (write_fault && !dirty) {
-                *gpte |= PT_DIRTY_MASK;
+                pt_element_t *guest_ent, *tmp = NULL;
+
+                if (walker->ptep)
+                        guest_ent = walker->ptep;
+                else {
+                        tmp = kmap_atomic(walker->page, KM_USER0);
+                        guest_ent = &tmp[walker->index];
+                }
+
+                *guest_ent |= PT_DIRTY_MASK;
+                if (!walker->ptep)
+                        kunmap_atomic(tmp, KM_USER0);
                 dirty = 1;
                 FNAME(mark_pagetable_dirty)(vcpu->kvm, walker);
         }
 
         spte |= PT_PRESENT_MASK | PT_ACCESSED_MASK | PT_DIRTY_MASK;
-        spte |= *gpte & PT64_NX_MASK;
+        spte |= gpte & PT64_NX_MASK;
         if (!dirty)
                 access_bits &= ~PT_WRITABLE_MASK;
 
@@ -255,7 +274,7 @@ static void FNAME(set_pte_common)(struct kvm_vcpu *vcpu,
                         access_bits &= ~PT_WRITABLE_MASK;
                         if (is_writeble_pte(spte)) {
                                 spte &= ~PT_WRITABLE_MASK;
-                                kvm_arch_ops->tlb_flush(vcpu);
+                                kvm_x86_ops->tlb_flush(vcpu);
                         }
                         if (write_fault)
                                 *ptwrite = 1;
@@ -273,13 +292,13 @@ unshadowed:
                 rmap_add(vcpu, shadow_pte);
 }
 
-static void FNAME(set_pte)(struct kvm_vcpu *vcpu, pt_element_t *gpte,
+static void FNAME(set_pte)(struct kvm_vcpu *vcpu, pt_element_t gpte,
                            u64 *shadow_pte, u64 access_bits,
                            int user_fault, int write_fault, int *ptwrite,
                            struct guest_walker *walker, gfn_t gfn)
 {
-        access_bits &= *gpte;
-        FNAME(set_pte_common)(vcpu, shadow_pte, *gpte & PT_BASE_ADDR_MASK,
+        access_bits &= gpte;
+        FNAME(set_pte_common)(vcpu, shadow_pte, gpte & PT_BASE_ADDR_MASK,
                               gpte, access_bits, user_fault, write_fault,
                               ptwrite, walker, gfn);
 }
@@ -295,22 +314,22 @@ static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *page,
         if (~gpte & (PT_PRESENT_MASK | PT_ACCESSED_MASK))
                 return;
         pgprintk("%s: gpte %llx spte %p\n", __FUNCTION__, (u64)gpte, spte);
-        FNAME(set_pte)(vcpu, &gpte, spte, PT_USER_MASK | PT_WRITABLE_MASK, 0,
+        FNAME(set_pte)(vcpu, gpte, spte, PT_USER_MASK | PT_WRITABLE_MASK, 0,
                        0, NULL, NULL,
                        (gpte & PT_BASE_ADDR_MASK) >> PAGE_SHIFT);
 }
 
-static void FNAME(set_pde)(struct kvm_vcpu *vcpu, pt_element_t *gpde,
+static void FNAME(set_pde)(struct kvm_vcpu *vcpu, pt_element_t gpde,
                            u64 *shadow_pte, u64 access_bits,
                            int user_fault, int write_fault, int *ptwrite,
                            struct guest_walker *walker, gfn_t gfn)
 {
         gpa_t gaddr;
 
-        access_bits &= *gpde;
+        access_bits &= gpde;
         gaddr = (gpa_t)gfn << PAGE_SHIFT;
         if (PTTYPE == 32 && is_cpuid_PSE36())
-                gaddr |= (*gpde & PT32_DIR_PSE36_MASK) <<
+                gaddr |= (gpde & PT32_DIR_PSE36_MASK) <<
                         (32 - PT32_DIR_PSE36_SHIFT);
         FNAME(set_pte_common)(vcpu, shadow_pte, gaddr,
                               gpde, access_bits, user_fault, write_fault,
@@ -328,9 +347,8 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
         int level;
         u64 *shadow_ent;
         u64 *prev_shadow_ent = NULL;
-        pt_element_t *guest_ent = walker->ptep;
 
-        if (!is_present_pte(*guest_ent))
+        if (!is_present_pte(walker->pte))
                 return NULL;
 
         shadow_addr = vcpu->mmu.root_hpa;
@@ -364,12 +382,12 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
                 if (level - 1 == PT_PAGE_TABLE_LEVEL
                     && walker->level == PT_DIRECTORY_LEVEL) {
                         metaphysical = 1;
-                        hugepage_access = *guest_ent;
+                        hugepage_access = walker->pte;
                         hugepage_access &= PT_USER_MASK | PT_WRITABLE_MASK;
-                        if (*guest_ent & PT64_NX_MASK)
+                        if (walker->pte & PT64_NX_MASK)
                                 hugepage_access |= (1 << 2);
                         hugepage_access >>= PT_WRITABLE_SHIFT;
-                        table_gfn = (*guest_ent & PT_BASE_ADDR_MASK)
+                        table_gfn = (walker->pte & PT_BASE_ADDR_MASK)
                                 >> PAGE_SHIFT;
                 } else {
                         metaphysical = 0;
@@ -386,12 +404,12 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
         }
 
         if (walker->level == PT_DIRECTORY_LEVEL) {
-                FNAME(set_pde)(vcpu, guest_ent, shadow_ent,
+                FNAME(set_pde)(vcpu, walker->pte, shadow_ent,
                                walker->inherited_ar, user_fault, write_fault,
                                ptwrite, walker, walker->gfn);
         } else {
                 ASSERT(walker->level == PT_PAGE_TABLE_LEVEL);
-                FNAME(set_pte)(vcpu, guest_ent, shadow_ent,
+                FNAME(set_pte)(vcpu, walker->pte, shadow_ent,
                                walker->inherited_ar, user_fault, write_fault,
                                ptwrite, walker, walker->gfn);
         }
@@ -442,7 +460,6 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
         if (!r) {
                 pgprintk("%s: guest page fault\n", __FUNCTION__);
                 inject_page_fault(vcpu, addr, walker.error_code);
-                FNAME(release_walker)(&walker);
                 vcpu->last_pt_write_count = 0; /* reset fork detector */
                 return 0;
         }
@@ -452,8 +469,6 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
         pgprintk("%s: shadow pte %p %llx ptwrite %d\n", __FUNCTION__,
                  shadow_pte, *shadow_pte, write_pt);
 
-        FNAME(release_walker)(&walker);
-
         if (!write_pt)
                 vcpu->last_pt_write_count = 0; /* reset fork detector */
 
@@ -482,7 +497,6 @@ static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t vaddr)
                 gpa |= vaddr & ~PAGE_MASK;
         }
 
-        FNAME(release_walker)(&walker);
         return gpa;
 }
 
diff --git a/drivers/kvm/svm.c b/drivers/kvm/svm.c
index bc818cc126..729f1cd936 100644
--- a/drivers/kvm/svm.c
+++ b/drivers/kvm/svm.c
@@ -16,12 +16,12 @@
 
 #include "kvm_svm.h"
 #include "x86_emulate.h"
+#include "irq.h"
 
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/vmalloc.h>
 #include <linux/highmem.h>
-#include <linux/profile.h>
 #include <linux/sched.h>
 
 #include <asm/desc.h>
@@ -38,7 +38,6 @@ MODULE_LICENSE("GPL");
 
 #define DR7_GD_MASK (1 << 13)
 #define DR6_BD_MASK (1 << 13)
-#define CR4_DE_MASK (1UL << 3)
 
 #define SEG_TYPE_LDT 2
 #define SEG_TYPE_BUSY_TSS16 3
@@ -50,6 +49,13 @@ MODULE_LICENSE("GPL");
 #define SVM_FEATURE_LBRV (1 << 1)
 #define SVM_DEATURE_SVML (1 << 2)
 
+static void kvm_reput_irq(struct vcpu_svm *svm);
+
+static inline struct vcpu_svm *to_svm(struct kvm_vcpu *vcpu)
+{
+        return container_of(vcpu, struct vcpu_svm, vcpu);
+}
+
 unsigned long iopm_base;
 unsigned long msrpm_base;
 
@@ -94,20 +100,6 @@ static inline u32 svm_has(u32 feat)
         return svm_features & feat;
 }
 
-static unsigned get_addr_size(struct kvm_vcpu *vcpu)
-{
-        struct vmcb_save_area *sa = &vcpu->svm->vmcb->save;
-        u16 cs_attrib;
-
-        if (!(sa->cr0 & CR0_PE_MASK) || (sa->rflags & X86_EFLAGS_VM))
-                return 2;
-
-        cs_attrib = sa->cs.attrib;
-
-        return (cs_attrib & SVM_SELECTOR_L_MASK) ? 8 :
-                                (cs_attrib & SVM_SELECTOR_DB_MASK) ? 4 : 2;
-}
-
 static inline u8 pop_irq(struct kvm_vcpu *vcpu)
 {
         int word_index = __ffs(vcpu->irq_summary);
@@ -182,7 +174,7 @@ static inline void write_dr7(unsigned long val)
 
 static inline void force_new_asid(struct kvm_vcpu *vcpu)
 {
-        vcpu->svm->asid_generation--;
+        to_svm(vcpu)->asid_generation--;
 }
 
 static inline void flush_guest_tlb(struct kvm_vcpu *vcpu)
@@ -195,22 +187,24 @@ static void svm_set_efer(struct kvm_vcpu *vcpu, u64 efer)
         if (!(efer & KVM_EFER_LMA))
                 efer &= ~KVM_EFER_LME;
 
-        vcpu->svm->vmcb->save.efer = efer | MSR_EFER_SVME_MASK;
+        to_svm(vcpu)->vmcb->save.efer = efer | MSR_EFER_SVME_MASK;
         vcpu->shadow_efer = efer;
 }
 
 static void svm_inject_gp(struct kvm_vcpu *vcpu, unsigned error_code)
 {
-        vcpu->svm->vmcb->control.event_inj =    SVM_EVTINJ_VALID |
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm->vmcb->control.event_inj =          SVM_EVTINJ_VALID |
                                                 SVM_EVTINJ_VALID_ERR |
                                                 SVM_EVTINJ_TYPE_EXEPT |
                                                 GP_VECTOR;
-        vcpu->svm->vmcb->control.event_inj_err = error_code;
+        svm->vmcb->control.event_inj_err = error_code;
 }
 
 static void inject_ud(struct kvm_vcpu *vcpu)
 {
-        vcpu->svm->vmcb->control.event_inj =    SVM_EVTINJ_VALID |
+        to_svm(vcpu)->vmcb->control.event_inj = SVM_EVTINJ_VALID |
                                                 SVM_EVTINJ_TYPE_EXEPT |
                                                 UD_VECTOR;
 }
@@ -229,19 +223,21 @@ static int is_external_interrupt(u32 info)
 
 static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
 {
-        if (!vcpu->svm->next_rip) {
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        if (!svm->next_rip) {
                 printk(KERN_DEBUG "%s: NOP\n", __FUNCTION__);
                 return;
         }
-        if (vcpu->svm->next_rip - vcpu->svm->vmcb->save.rip > 15) {
+        if (svm->next_rip - svm->vmcb->save.rip > MAX_INST_SIZE) {
                 printk(KERN_ERR "%s: ip 0x%llx next 0x%llx\n",
                        __FUNCTION__,
-                       vcpu->svm->vmcb->save.rip,
-                       vcpu->svm->next_rip);
+                       svm->vmcb->save.rip,
+                       svm->next_rip);
         }
 
-        vcpu->rip = vcpu->svm->vmcb->save.rip = vcpu->svm->next_rip;
-        vcpu->svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK;
+        vcpu->rip = svm->vmcb->save.rip = svm->next_rip;
+        svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK;
 
         vcpu->interrupt_window_open = 1;
 }
@@ -351,8 +347,8 @@ err_1:
 
 }
 
-static int set_msr_interception(u32 *msrpm, unsigned msr,
-                                int read, int write)
+static void set_msr_interception(u32 *msrpm, unsigned msr,
+                                 int read, int write)
 {
         int i;
 
@@ -367,11 +363,10 @@ static int set_msr_interception(u32 *msrpm, unsigned msr,
                         u32 mask = ((write) ? 0 : 2) | ((read) ? 0 : 1);
                         *base = (*base & ~(0x3 << msr_shift)) |
                                 (mask << msr_shift);
-                        return 1;
+                        return;
                 }
         }
-        printk(KERN_DEBUG "%s: not found 0x%x\n", __FUNCTION__, msr);
-        return 0;
+        BUG();
 }
 
 static __init int svm_hardware_setup(void)
@@ -382,8 +377,6 @@ static __init int svm_hardware_setup(void)
         void *iopm_va, *msrpm_va;
         int r;
 
-        kvm_emulator_want_group7_invlpg();
-
         iopm_pages = alloc_pages(GFP_KERNEL, IOPM_ALLOC_ORDER);
 
         if (!iopm_pages)
@@ -458,11 +451,6 @@ static void init_sys_seg(struct vmcb_seg *seg, uint32_t type)
         seg->base = 0;
 }
 
-static int svm_vcpu_setup(struct kvm_vcpu *vcpu)
-{
-        return 0;
-}
-
 static void init_vmcb(struct vmcb *vmcb)
 {
         struct vmcb_control_area *control = &vmcb->control;
@@ -563,59 +551,83 @@ static void init_vmcb(struct vmcb *vmcb)
          * cr0 val on cpu init should be 0x60000010, we enable cpu
          * cache by default. the orderly way is to enable cache in bios.
          */
-        save->cr0 = 0x00000010 | CR0_PG_MASK | CR0_WP_MASK;
-        save->cr4 = CR4_PAE_MASK;
+        save->cr0 = 0x00000010 | X86_CR0_PG | X86_CR0_WP;
+        save->cr4 = X86_CR4_PAE;
         /* rdx = ?? */
 }
 
-static int svm_create_vcpu(struct kvm_vcpu *vcpu)
+static void svm_vcpu_reset(struct kvm_vcpu *vcpu)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        init_vmcb(svm->vmcb);
+}
+
+static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id)
 {
+        struct vcpu_svm *svm;
         struct page *page;
-        int r;
+        int err;
+
+        svm = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
+        if (!svm) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        err = kvm_vcpu_init(&svm->vcpu, kvm, id);
+        if (err)
+                goto free_svm;
+
+        if (irqchip_in_kernel(kvm)) {
+                err = kvm_create_lapic(&svm->vcpu);
+                if (err < 0)
+                        goto free_svm;
+        }
 
-        r = -ENOMEM;
-        vcpu->svm = kzalloc(sizeof *vcpu->svm, GFP_KERNEL);
-        if (!vcpu->svm)
-                goto out1;
         page = alloc_page(GFP_KERNEL);
-        if (!page)
-                goto out2;
-
-        vcpu->svm->vmcb = page_address(page);
-        clear_page(vcpu->svm->vmcb);
-        vcpu->svm->vmcb_pa = page_to_pfn(page) << PAGE_SHIFT;
-        vcpu->svm->asid_generation = 0;
-        memset(vcpu->svm->db_regs, 0, sizeof(vcpu->svm->db_regs));
-        init_vmcb(vcpu->svm->vmcb);
-
-        fx_init(vcpu);
-        vcpu->fpu_active = 1;
-        vcpu->apic_base = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
-        if (vcpu == &vcpu->kvm->vcpus[0])
-                vcpu->apic_base |= MSR_IA32_APICBASE_BSP;
+        if (!page) {
+                err = -ENOMEM;
+                goto uninit;
+        }
 
-        return 0;
+        svm->vmcb = page_address(page);
+        clear_page(svm->vmcb);
+        svm->vmcb_pa = page_to_pfn(page) << PAGE_SHIFT;
+        svm->asid_generation = 0;
+        memset(svm->db_regs, 0, sizeof(svm->db_regs));
+        init_vmcb(svm->vmcb);
 
-out2:
-        kfree(vcpu->svm);
-out1:
-        return r;
+        fx_init(&svm->vcpu);
+        svm->vcpu.fpu_active = 1;
+        svm->vcpu.apic_base = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
+        if (svm->vcpu.vcpu_id == 0)
+                svm->vcpu.apic_base |= MSR_IA32_APICBASE_BSP;
+
+        return &svm->vcpu;
+
+uninit:
+        kvm_vcpu_uninit(&svm->vcpu);
+free_svm:
+        kmem_cache_free(kvm_vcpu_cache, svm);
+out:
+        return ERR_PTR(err);
 }
 
 static void svm_free_vcpu(struct kvm_vcpu *vcpu)
 {
-        if (!vcpu->svm)
-                return;
-        if (vcpu->svm->vmcb)
-                __free_page(pfn_to_page(vcpu->svm->vmcb_pa >> PAGE_SHIFT));
-        kfree(vcpu->svm);
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        __free_page(pfn_to_page(svm->vmcb_pa >> PAGE_SHIFT));
+        kvm_vcpu_uninit(vcpu);
+        kmem_cache_free(kvm_vcpu_cache, svm);
 }
 
-static void svm_vcpu_load(struct kvm_vcpu *vcpu)
+static void svm_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 {
-        int cpu, i;
+        struct vcpu_svm *svm = to_svm(vcpu);
+        int i;
 
-        cpu = get_cpu();
         if (unlikely(cpu != vcpu->cpu)) {
                 u64 tsc_this, delta;
 
@@ -625,23 +637,24 @@ static void svm_vcpu_load(struct kvm_vcpu *vcpu)
                  */
                 rdtscll(tsc_this);
                 delta = vcpu->host_tsc - tsc_this;
-                vcpu->svm->vmcb->control.tsc_offset += delta;
+                svm->vmcb->control.tsc_offset += delta;
                 vcpu->cpu = cpu;
+                kvm_migrate_apic_timer(vcpu);
         }
 
         for (i = 0; i < NR_HOST_SAVE_USER_MSRS; i++)
-                rdmsrl(host_save_user_msrs[i], vcpu->svm->host_user_msrs[i]);
+                rdmsrl(host_save_user_msrs[i], svm->host_user_msrs[i]);
 }
 
 static void svm_vcpu_put(struct kvm_vcpu *vcpu)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
         int i;
 
         for (i = 0; i < NR_HOST_SAVE_USER_MSRS; i++)
-                wrmsrl(host_save_user_msrs[i], vcpu->svm->host_user_msrs[i]);
+                wrmsrl(host_save_user_msrs[i], svm->host_user_msrs[i]);
 
         rdtscll(vcpu->host_tsc);
-        put_cpu();
 }
 
 static void svm_vcpu_decache(struct kvm_vcpu *vcpu)
@@ -650,31 +663,34 @@ static void svm_vcpu_decache(struct kvm_vcpu *vcpu)
 
 static void svm_cache_regs(struct kvm_vcpu *vcpu)
 {
-        vcpu->regs[VCPU_REGS_RAX] = vcpu->svm->vmcb->save.rax;
-        vcpu->regs[VCPU_REGS_RSP] = vcpu->svm->vmcb->save.rsp;
-        vcpu->rip = vcpu->svm->vmcb->save.rip;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        vcpu->regs[VCPU_REGS_RAX] = svm->vmcb->save.rax;
+        vcpu->regs[VCPU_REGS_RSP] = svm->vmcb->save.rsp;
+        vcpu->rip = svm->vmcb->save.rip;
 }
 
 static void svm_decache_regs(struct kvm_vcpu *vcpu)
 {
-        vcpu->svm->vmcb->save.rax = vcpu->regs[VCPU_REGS_RAX];
-        vcpu->svm->vmcb->save.rsp = vcpu->regs[VCPU_REGS_RSP];
-        vcpu->svm->vmcb->save.rip = vcpu->rip;
+        struct vcpu_svm *svm = to_svm(vcpu);
+        svm->vmcb->save.rax = vcpu->regs[VCPU_REGS_RAX];
+        svm->vmcb->save.rsp = vcpu->regs[VCPU_REGS_RSP];
+        svm->vmcb->save.rip = vcpu->rip;
 }
 
 static unsigned long svm_get_rflags(struct kvm_vcpu *vcpu)
 {
-        return vcpu->svm->vmcb->save.rflags;
+        return to_svm(vcpu)->vmcb->save.rflags;
 }
 
 static void svm_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags)
 {
-        vcpu->svm->vmcb->save.rflags = rflags;
+        to_svm(vcpu)->vmcb->save.rflags = rflags;
 }
 
 static struct vmcb_seg *svm_seg(struct kvm_vcpu *vcpu, int seg)
 {
-        struct vmcb_save_area *save = &vcpu->svm->vmcb->save;
+        struct vmcb_save_area *save = &to_svm(vcpu)->vmcb->save;
 
         switch (seg) {
         case VCPU_SREG_CS: return &save->cs;
@@ -716,36 +732,36 @@ static void svm_get_segment(struct kvm_vcpu *vcpu,
         var->unusable = !var->present;
 }
 
-static void svm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l)
-{
-        struct vmcb_seg *s = svm_seg(vcpu, VCPU_SREG_CS);
-
-        *db = (s->attrib >> SVM_SELECTOR_DB_SHIFT) & 1;
-        *l = (s->attrib >> SVM_SELECTOR_L_SHIFT) & 1;
-}
-
 static void svm_get_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        dt->limit = vcpu->svm->vmcb->save.idtr.limit;
-        dt->base = vcpu->svm->vmcb->save.idtr.base;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        dt->limit = svm->vmcb->save.idtr.limit;
+        dt->base = svm->vmcb->save.idtr.base;
 }
 
 static void svm_set_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        vcpu->svm->vmcb->save.idtr.limit = dt->limit;
-        vcpu->svm->vmcb->save.idtr.base = dt->base ;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm->vmcb->save.idtr.limit = dt->limit;
+        svm->vmcb->save.idtr.base = dt->base ;
 }
 
 static void svm_get_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        dt->limit = vcpu->svm->vmcb->save.gdtr.limit;
-        dt->base = vcpu->svm->vmcb->save.gdtr.base;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        dt->limit = svm->vmcb->save.gdtr.limit;
+        dt->base = svm->vmcb->save.gdtr.base;
 }
 
 static void svm_set_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        vcpu->svm->vmcb->save.gdtr.limit = dt->limit;
-        vcpu->svm->vmcb->save.gdtr.base = dt->base ;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm->vmcb->save.gdtr.limit = dt->limit;
+        svm->vmcb->save.gdtr.base = dt->base ;
 }
 
 static void svm_decache_cr4_guest_bits(struct kvm_vcpu *vcpu)
@@ -754,39 +770,42 @@ static void svm_decache_cr4_guest_bits(struct kvm_vcpu *vcpu)
 
 static void svm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
+
 #ifdef CONFIG_X86_64
         if (vcpu->shadow_efer & KVM_EFER_LME) {
-                if (!is_paging(vcpu) && (cr0 & CR0_PG_MASK)) {
+                if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) {
                         vcpu->shadow_efer |= KVM_EFER_LMA;
-                        vcpu->svm->vmcb->save.efer |= KVM_EFER_LMA | KVM_EFER_LME;
+                        svm->vmcb->save.efer |= KVM_EFER_LMA | KVM_EFER_LME;
                 }
 
-                if (is_paging(vcpu) && !(cr0 & CR0_PG_MASK) ) {
+                if (is_paging(vcpu) && !(cr0 & X86_CR0_PG) ) {
                         vcpu->shadow_efer &= ~KVM_EFER_LMA;
-                        vcpu->svm->vmcb->save.efer &= ~(KVM_EFER_LMA | KVM_EFER_LME);
+                        svm->vmcb->save.efer &= ~(KVM_EFER_LMA | KVM_EFER_LME);
                 }
         }
 #endif
-        if ((vcpu->cr0 & CR0_TS_MASK) && !(cr0 & CR0_TS_MASK)) {
-                vcpu->svm->vmcb->control.intercept_exceptions &= ~(1 << NM_VECTOR);
+        if ((vcpu->cr0 & X86_CR0_TS) && !(cr0 & X86_CR0_TS)) {
+                svm->vmcb->control.intercept_exceptions &= ~(1 << NM_VECTOR);
                 vcpu->fpu_active = 1;
         }
 
         vcpu->cr0 = cr0;
-        cr0 |= CR0_PG_MASK | CR0_WP_MASK;
-        cr0 &= ~(CR0_CD_MASK | CR0_NW_MASK);
-        vcpu->svm->vmcb->save.cr0 = cr0;
+        cr0 |= X86_CR0_PG | X86_CR0_WP;
+        cr0 &= ~(X86_CR0_CD | X86_CR0_NW);
+        svm->vmcb->save.cr0 = cr0;
 }
 
 static void svm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
 {
        vcpu->cr4 = cr4;
-       vcpu->svm->vmcb->save.cr4 = cr4 | CR4_PAE_MASK;
+       to_svm(vcpu)->vmcb->save.cr4 = cr4 | X86_CR4_PAE;
 }
 
 static void svm_set_segment(struct kvm_vcpu *vcpu,
                             struct kvm_segment *var, int seg)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
         struct vmcb_seg *s = svm_seg(vcpu, seg);
 
         s->base = var->base;
@@ -805,16 +824,16 @@ static void svm_set_segment(struct kvm_vcpu *vcpu,
                 s->attrib |= (var->g & 1) << SVM_SELECTOR_G_SHIFT;
         }
         if (seg == VCPU_SREG_CS)
-                vcpu->svm->vmcb->save.cpl
-                        = (vcpu->svm->vmcb->save.cs.attrib
+                svm->vmcb->save.cpl
+                        = (svm->vmcb->save.cs.attrib
                            >> SVM_SELECTOR_DPL_SHIFT) & 3;
 
 }
 
 /* FIXME:
 
-        vcpu->svm->vmcb->control.int_ctl &= ~V_TPR_MASK;
-        vcpu->svm->vmcb->control.int_ctl |= (sregs->cr8 & V_TPR_MASK);
+        svm(vcpu)->vmcb->control.int_ctl &= ~V_TPR_MASK;
+        svm(vcpu)->vmcb->control.int_ctl |= (sregs->cr8 & V_TPR_MASK);
 
 */
 
@@ -823,61 +842,68 @@ static int svm_guest_debug(struct kvm_vcpu *vcpu, struct kvm_debug_guest *dbg)
         return -EOPNOTSUPP;
 }
 
+static int svm_get_irq(struct kvm_vcpu *vcpu)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
+        u32 exit_int_info = svm->vmcb->control.exit_int_info;
+
+        if (is_external_interrupt(exit_int_info))
+                return exit_int_info & SVM_EVTINJ_VEC_MASK;
+        return -1;
+}
+
 static void load_host_msrs(struct kvm_vcpu *vcpu)
 {
 #ifdef CONFIG_X86_64
-        wrmsrl(MSR_GS_BASE, vcpu->svm->host_gs_base);
+        wrmsrl(MSR_GS_BASE, to_svm(vcpu)->host_gs_base);
 #endif
 }
 
 static void save_host_msrs(struct kvm_vcpu *vcpu)
 {
 #ifdef CONFIG_X86_64
-        rdmsrl(MSR_GS_BASE, vcpu->svm->host_gs_base);
+        rdmsrl(MSR_GS_BASE, to_svm(vcpu)->host_gs_base);
 #endif
 }
 
-static void new_asid(struct kvm_vcpu *vcpu, struct svm_cpu_data *svm_data)
+static void new_asid(struct vcpu_svm *svm, struct svm_cpu_data *svm_data)
 {
         if (svm_data->next_asid > svm_data->max_asid) {
                 ++svm_data->asid_generation;
                 svm_data->next_asid = 1;
-                vcpu->svm->vmcb->control.tlb_ctl = TLB_CONTROL_FLUSH_ALL_ASID;
+                svm->vmcb->control.tlb_ctl = TLB_CONTROL_FLUSH_ALL_ASID;
         }
 
-        vcpu->cpu = svm_data->cpu;
-        vcpu->svm->asid_generation = svm_data->asid_generation;
-        vcpu->svm->vmcb->control.asid = svm_data->next_asid++;
-}
-
-static void svm_invlpg(struct kvm_vcpu *vcpu, gva_t address)
-{
-        invlpga(address, vcpu->svm->vmcb->control.asid); // is needed?
+        svm->vcpu.cpu = svm_data->cpu;
+        svm->asid_generation = svm_data->asid_generation;
+        svm->vmcb->control.asid = svm_data->next_asid++;
 }
 
 static unsigned long svm_get_dr(struct kvm_vcpu *vcpu, int dr)
 {
-        return vcpu->svm->db_regs[dr];
+        return to_svm(vcpu)->db_regs[dr];
 }
 
 static void svm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long value,
                        int *exception)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
+
         *exception = 0;
 
-        if (vcpu->svm->vmcb->save.dr7 & DR7_GD_MASK) {
-                vcpu->svm->vmcb->save.dr7 &= ~DR7_GD_MASK;
-                vcpu->svm->vmcb->save.dr6 |= DR6_BD_MASK;
+        if (svm->vmcb->save.dr7 & DR7_GD_MASK) {
+                svm->vmcb->save.dr7 &= ~DR7_GD_MASK;
+                svm->vmcb->save.dr6 |= DR6_BD_MASK;
                 *exception = DB_VECTOR;
                 return;
         }
 
         switch (dr) {
         case 0 ... 3:
-                vcpu->svm->db_regs[dr] = value;
+                svm->db_regs[dr] = value;
                 return;
         case 4 ... 5:
-                if (vcpu->cr4 & CR4_DE_MASK) {
+                if (vcpu->cr4 & X86_CR4_DE) {
                         *exception = UD_VECTOR;
                         return;
                 }
@@ -886,7 +912,7 @@ static void svm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long value,
                         *exception = GP_VECTOR;
                         return;
                 }
-                vcpu->svm->vmcb->save.dr7 = value;
+                svm->vmcb->save.dr7 = value;
                 return;
         }
         default:
@@ -897,42 +923,44 @@ static void svm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long value,
         }
 }
 
-static int pf_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int pf_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        u32 exit_int_info = vcpu->svm->vmcb->control.exit_int_info;
+        u32 exit_int_info = svm->vmcb->control.exit_int_info;
+        struct kvm *kvm = svm->vcpu.kvm;
         u64 fault_address;
         u32 error_code;
         enum emulation_result er;
         int r;
 
-        if (is_external_interrupt(exit_int_info))
-                push_irq(vcpu, exit_int_info & SVM_EVTINJ_VEC_MASK);
+        if (!irqchip_in_kernel(kvm) &&
+                is_external_interrupt(exit_int_info))
+                push_irq(&svm->vcpu, exit_int_info & SVM_EVTINJ_VEC_MASK);
 
-        spin_lock(&vcpu->kvm->lock);
+        mutex_lock(&kvm->lock);
 
-        fault_address  = vcpu->svm->vmcb->control.exit_info_2;
-        error_code = vcpu->svm->vmcb->control.exit_info_1;
-        r = kvm_mmu_page_fault(vcpu, fault_address, error_code);
+        fault_address  = svm->vmcb->control.exit_info_2;
+        error_code = svm->vmcb->control.exit_info_1;
+        r = kvm_mmu_page_fault(&svm->vcpu, fault_address, error_code);
         if (r < 0) {
-                spin_unlock(&vcpu->kvm->lock);
+                mutex_unlock(&kvm->lock);
                 return r;
         }
         if (!r) {
-                spin_unlock(&vcpu->kvm->lock);
+                mutex_unlock(&kvm->lock);
                 return 1;
         }
-        er = emulate_instruction(vcpu, kvm_run, fault_address, error_code);
-        spin_unlock(&vcpu->kvm->lock);
+        er = emulate_instruction(&svm->vcpu, kvm_run, fault_address,
+                                 error_code);
+        mutex_unlock(&kvm->lock);
 
         switch (er) {
         case EMULATE_DONE:
                 return 1;
         case EMULATE_DO_MMIO:
-                ++vcpu->stat.mmio_exits;
-                kvm_run->exit_reason = KVM_EXIT_MMIO;
+                ++svm->vcpu.stat.mmio_exits;
                 return 0;
         case EMULATE_FAIL:
-                vcpu_printf(vcpu, "%s: emulate fail\n", __FUNCTION__);
+                kvm_report_emulation_failure(&svm->vcpu, "pagetable");
                 break;
         default:
                 BUG();
@@ -942,252 +970,142 @@ static int pf_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         return 0;
 }
 
-static int nm_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int nm_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-       vcpu->svm->vmcb->control.intercept_exceptions &= ~(1 << NM_VECTOR);
-       if (!(vcpu->cr0 & CR0_TS_MASK))
-               vcpu->svm->vmcb->save.cr0 &= ~CR0_TS_MASK;
-       vcpu->fpu_active = 1;
+        svm->vmcb->control.intercept_exceptions &= ~(1 << NM_VECTOR);
+        if (!(svm->vcpu.cr0 & X86_CR0_TS))
+                svm->vmcb->save.cr0 &= ~X86_CR0_TS;
+        svm->vcpu.fpu_active = 1;
 
-       return 1;
+        return 1;
 }
 
-static int shutdown_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int shutdown_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
         /*
          * VMCB is undefined after a SHUTDOWN intercept
          * so reinitialize it.
          */
-        clear_page(vcpu->svm->vmcb);
-        init_vmcb(vcpu->svm->vmcb);
+        clear_page(svm->vmcb);
+        init_vmcb(svm->vmcb);
 
         kvm_run->exit_reason = KVM_EXIT_SHUTDOWN;
         return 0;
 }
 
-static int io_get_override(struct kvm_vcpu *vcpu,
-                          struct vmcb_seg **seg,
-                          int *addr_override)
-{
-        u8 inst[MAX_INST_SIZE];
-        unsigned ins_length;
-        gva_t rip;
-        int i;
-
-        rip =  vcpu->svm->vmcb->save.rip;
-        ins_length = vcpu->svm->next_rip - rip;
-        rip += vcpu->svm->vmcb->save.cs.base;
-
-        if (ins_length > MAX_INST_SIZE)
-                printk(KERN_DEBUG
-                       "%s: inst length err, cs base 0x%llx rip 0x%llx "
-                       "next rip 0x%llx ins_length %u\n",
-                       __FUNCTION__,
-                       vcpu->svm->vmcb->save.cs.base,
-                       vcpu->svm->vmcb->save.rip,
-                       vcpu->svm->vmcb->control.exit_info_2,
-                       ins_length);
-
-        if (kvm_read_guest(vcpu, rip, ins_length, inst) != ins_length)
-                /* #PF */
-                return 0;
-
-        *addr_override = 0;
-        *seg = NULL;
-        for (i = 0; i < ins_length; i++)
-                switch (inst[i]) {
-                case 0xf0:
-                case 0xf2:
-                case 0xf3:
-                case 0x66:
-                        continue;
-                case 0x67:
-                        *addr_override = 1;
-                        continue;
-                case 0x2e:
-                        *seg = &vcpu->svm->vmcb->save.cs;
-                        continue;
-                case 0x36:
-                        *seg = &vcpu->svm->vmcb->save.ss;
-                        continue;
-                case 0x3e:
-                        *seg = &vcpu->svm->vmcb->save.ds;
-                        continue;
-                case 0x26:
-                        *seg = &vcpu->svm->vmcb->save.es;
-                        continue;
-                case 0x64:
-                        *seg = &vcpu->svm->vmcb->save.fs;
-                        continue;
-                case 0x65:
-                        *seg = &vcpu->svm->vmcb->save.gs;
-                        continue;
-                default:
-                        return 1;
-                }
-        printk(KERN_DEBUG "%s: unexpected\n", __FUNCTION__);
-        return 0;
-}
-
-static unsigned long io_adress(struct kvm_vcpu *vcpu, int ins, gva_t *address)
+static int io_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        unsigned long addr_mask;
-        unsigned long *reg;
-        struct vmcb_seg *seg;
-        int addr_override;
-        struct vmcb_save_area *save_area = &vcpu->svm->vmcb->save;
-        u16 cs_attrib = save_area->cs.attrib;
-        unsigned addr_size = get_addr_size(vcpu);
-
-        if (!io_get_override(vcpu, &seg, &addr_override))
-                return 0;
-
-        if (addr_override)
-                addr_size = (addr_size == 2) ? 4: (addr_size >> 1);
+        u32 io_info = svm->vmcb->control.exit_info_1; //address size bug?
+        int size, down, in, string, rep;
+        unsigned port;
 
-        if (ins) {
-                reg = &vcpu->regs[VCPU_REGS_RDI];
-                seg = &vcpu->svm->vmcb->save.es;
-        } else {
-                reg = &vcpu->regs[VCPU_REGS_RSI];
-                seg = (seg) ? seg : &vcpu->svm->vmcb->save.ds;
-        }
+        ++svm->vcpu.stat.io_exits;
 
-        addr_mask = ~0ULL >> (64 - (addr_size * 8));
+        svm->next_rip = svm->vmcb->control.exit_info_2;
 
-        if ((cs_attrib & SVM_SELECTOR_L_MASK) &&
-            !(vcpu->svm->vmcb->save.rflags & X86_EFLAGS_VM)) {
-                *address = (*reg & addr_mask);
-                return addr_mask;
-        }
+        string = (io_info & SVM_IOIO_STR_MASK) != 0;
 
-        if (!(seg->attrib & SVM_SELECTOR_P_SHIFT)) {
-                svm_inject_gp(vcpu, 0);
-                return 0;
+        if (string) {
+                if (emulate_instruction(&svm->vcpu, kvm_run, 0, 0) == EMULATE_DO_MMIO)
+                        return 0;
+                return 1;
         }
 
-        *address = (*reg & addr_mask) + seg->base;
-        return addr_mask;
-}
-
-static int io_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
-{
-        u32 io_info = vcpu->svm->vmcb->control.exit_info_1; //address size bug?
-        int size, down, in, string, rep;
-        unsigned port;
-        unsigned long count;
-        gva_t address = 0;
-
-        ++vcpu->stat.io_exits;
-
-        vcpu->svm->next_rip = vcpu->svm->vmcb->control.exit_info_2;
-
         in = (io_info & SVM_IOIO_TYPE_MASK) != 0;
         port = io_info >> 16;
         size = (io_info & SVM_IOIO_SIZE_MASK) >> SVM_IOIO_SIZE_SHIFT;
-        string = (io_info & SVM_IOIO_STR_MASK) != 0;
         rep = (io_info & SVM_IOIO_REP_MASK) != 0;
-        count = 1;
-        down = (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_DF) != 0;
+        down = (svm->vmcb->save.rflags & X86_EFLAGS_DF) != 0;
 
-        if (string) {
-                unsigned addr_mask;
-
-                addr_mask = io_adress(vcpu, in, &address);
-                if (!addr_mask) {
-                        printk(KERN_DEBUG "%s: get io address failed\n",
-                               __FUNCTION__);
-                        return 1;
-                }
-
-                if (rep)
-                        count = vcpu->regs[VCPU_REGS_RCX] & addr_mask;
-        }
-        return kvm_setup_pio(vcpu, kvm_run, in, size, count, string, down,
-                             address, rep, port);
+        return kvm_emulate_pio(&svm->vcpu, kvm_run, in, size, port);
 }
 
-static int nop_on_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int nop_on_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
         return 1;
 }
 
-static int halt_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int halt_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 1;
-        skip_emulated_instruction(vcpu);
-        return kvm_emulate_halt(vcpu);
+        svm->next_rip = svm->vmcb->save.rip + 1;
+        skip_emulated_instruction(&svm->vcpu);
+        return kvm_emulate_halt(&svm->vcpu);
 }
 
-static int vmmcall_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int vmmcall_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 3;
-        skip_emulated_instruction(vcpu);
-        return kvm_hypercall(vcpu, kvm_run);
+        svm->next_rip = svm->vmcb->save.rip + 3;
+        skip_emulated_instruction(&svm->vcpu);
+        return kvm_hypercall(&svm->vcpu, kvm_run);
 }
 
-static int invalid_op_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int invalid_op_interception(struct vcpu_svm *svm,
+                                   struct kvm_run *kvm_run)
 {
-        inject_ud(vcpu);
+        inject_ud(&svm->vcpu);
         return 1;
 }
 
-static int task_switch_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int task_switch_interception(struct vcpu_svm *svm,
+                                    struct kvm_run *kvm_run)
 {
-        printk(KERN_DEBUG "%s: task swiche is unsupported\n", __FUNCTION__);
+        pr_unimpl(&svm->vcpu, "%s: task switch is unsupported\n", __FUNCTION__);
         kvm_run->exit_reason = KVM_EXIT_UNKNOWN;
         return 0;
 }
 
-static int cpuid_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int cpuid_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 2;
-        kvm_emulate_cpuid(vcpu);
+        svm->next_rip = svm->vmcb->save.rip + 2;
+        kvm_emulate_cpuid(&svm->vcpu);
         return 1;
 }
 
-static int emulate_on_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int emulate_on_interception(struct vcpu_svm *svm,
+                                   struct kvm_run *kvm_run)
 {
-        if (emulate_instruction(vcpu, NULL, 0, 0) != EMULATE_DONE)
-                printk(KERN_ERR "%s: failed\n", __FUNCTION__);
+        if (emulate_instruction(&svm->vcpu, NULL, 0, 0) != EMULATE_DONE)
+                pr_unimpl(&svm->vcpu, "%s: failed\n", __FUNCTION__);
         return 1;
 }
 
 static int svm_get_msr(struct kvm_vcpu *vcpu, unsigned ecx, u64 *data)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
+
         switch (ecx) {
         case MSR_IA32_TIME_STAMP_COUNTER: {
                 u64 tsc;
 
                 rdtscll(tsc);
-                *data = vcpu->svm->vmcb->control.tsc_offset + tsc;
+                *data = svm->vmcb->control.tsc_offset + tsc;
                 break;
         }
         case MSR_K6_STAR:
-                *data = vcpu->svm->vmcb->save.star;
+                *data = svm->vmcb->save.star;
                 break;
 #ifdef CONFIG_X86_64
         case MSR_LSTAR:
-                *data = vcpu->svm->vmcb->save.lstar;
+                *data = svm->vmcb->save.lstar;
                 break;
         case MSR_CSTAR:
-                *data = vcpu->svm->vmcb->save.cstar;
+                *data = svm->vmcb->save.cstar;
                 break;
         case MSR_KERNEL_GS_BASE:
-                *data = vcpu->svm->vmcb->save.kernel_gs_base;
+                *data = svm->vmcb->save.kernel_gs_base;
                 break;
         case MSR_SYSCALL_MASK:
-                *data = vcpu->svm->vmcb->save.sfmask;
+                *data = svm->vmcb->save.sfmask;
                 break;
 #endif
         case MSR_IA32_SYSENTER_CS:
-                *data = vcpu->svm->vmcb->save.sysenter_cs;
+                *data = svm->vmcb->save.sysenter_cs;
                 break;
         case MSR_IA32_SYSENTER_EIP:
-                *data = vcpu->svm->vmcb->save.sysenter_eip;
+                *data = svm->vmcb->save.sysenter_eip;
                 break;
         case MSR_IA32_SYSENTER_ESP:
-                *data = vcpu->svm->vmcb->save.sysenter_esp;
+                *data = svm->vmcb->save.sysenter_esp;
                 break;
         default:
                 return kvm_get_msr_common(vcpu, ecx, data);
@@ -1195,57 +1113,59 @@ static int svm_get_msr(struct kvm_vcpu *vcpu, unsigned ecx, u64 *data)
         return 0;
 }
 
-static int rdmsr_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int rdmsr_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        u32 ecx = vcpu->regs[VCPU_REGS_RCX];
+        u32 ecx = svm->vcpu.regs[VCPU_REGS_RCX];
         u64 data;
 
-        if (svm_get_msr(vcpu, ecx, &data))
-                svm_inject_gp(vcpu, 0);
+        if (svm_get_msr(&svm->vcpu, ecx, &data))
+                svm_inject_gp(&svm->vcpu, 0);
         else {
-                vcpu->svm->vmcb->save.rax = data & 0xffffffff;
-                vcpu->regs[VCPU_REGS_RDX] = data >> 32;
-                vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 2;
-                skip_emulated_instruction(vcpu);
+                svm->vmcb->save.rax = data & 0xffffffff;
+                svm->vcpu.regs[VCPU_REGS_RDX] = data >> 32;
+                svm->next_rip = svm->vmcb->save.rip + 2;
+                skip_emulated_instruction(&svm->vcpu);
         }
         return 1;
 }
 
 static int svm_set_msr(struct kvm_vcpu *vcpu, unsigned ecx, u64 data)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
+
         switch (ecx) {
         case MSR_IA32_TIME_STAMP_COUNTER: {
                 u64 tsc;
 
                 rdtscll(tsc);
-                vcpu->svm->vmcb->control.tsc_offset = data - tsc;
+                svm->vmcb->control.tsc_offset = data - tsc;
                 break;
         }
         case MSR_K6_STAR:
-                vcpu->svm->vmcb->save.star = data;
+                svm->vmcb->save.star = data;
                 break;
 #ifdef CONFIG_X86_64
         case MSR_LSTAR:
-                vcpu->svm->vmcb->save.lstar = data;
+                svm->vmcb->save.lstar = data;
                 break;
         case MSR_CSTAR:
-                vcpu->svm->vmcb->save.cstar = data;
+                svm->vmcb->save.cstar = data;
                 break;
         case MSR_KERNEL_GS_BASE:
-                vcpu->svm->vmcb->save.kernel_gs_base = data;
+                svm->vmcb->save.kernel_gs_base = data;
                 break;
         case MSR_SYSCALL_MASK:
-                vcpu->svm->vmcb->save.sfmask = data;
+                svm->vmcb->save.sfmask = data;
                 break;
 #endif
         case MSR_IA32_SYSENTER_CS:
-                vcpu->svm->vmcb->save.sysenter_cs = data;
+                svm->vmcb->save.sysenter_cs = data;
                 break;
         case MSR_IA32_SYSENTER_EIP:
-                vcpu->svm->vmcb->save.sysenter_eip = data;
+                svm->vmcb->save.sysenter_eip = data;
                 break;
         case MSR_IA32_SYSENTER_ESP:
-                vcpu->svm->vmcb->save.sysenter_esp = data;
+                svm->vmcb->save.sysenter_esp = data;
                 break;
         default:
                 return kvm_set_msr_common(vcpu, ecx, data);
@@ -1253,37 +1173,39 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, unsigned ecx, u64 data)
         return 0;
 }
 
-static int wrmsr_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int wrmsr_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        u32 ecx = vcpu->regs[VCPU_REGS_RCX];
-        u64 data = (vcpu->svm->vmcb->save.rax & -1u)
-                | ((u64)(vcpu->regs[VCPU_REGS_RDX] & -1u) << 32);
-        vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 2;
-        if (svm_set_msr(vcpu, ecx, data))
-                svm_inject_gp(vcpu, 0);
+        u32 ecx = svm->vcpu.regs[VCPU_REGS_RCX];
+        u64 data = (svm->vmcb->save.rax & -1u)
+                | ((u64)(svm->vcpu.regs[VCPU_REGS_RDX] & -1u) << 32);
+        svm->next_rip = svm->vmcb->save.rip + 2;
+        if (svm_set_msr(&svm->vcpu, ecx, data))
+                svm_inject_gp(&svm->vcpu, 0);
         else
-                skip_emulated_instruction(vcpu);
+                skip_emulated_instruction(&svm->vcpu);
         return 1;
 }
 
-static int msr_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int msr_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        if (vcpu->svm->vmcb->control.exit_info_1)
-                return wrmsr_interception(vcpu, kvm_run);
+        if (svm->vmcb->control.exit_info_1)
+                return wrmsr_interception(svm, kvm_run);
         else
-                return rdmsr_interception(vcpu, kvm_run);
+                return rdmsr_interception(svm, kvm_run);
 }
 
-static int interrupt_window_interception(struct kvm_vcpu *vcpu,
+static int interrupt_window_interception(struct vcpu_svm *svm,
                                    struct kvm_run *kvm_run)
 {
+        svm->vmcb->control.intercept &= ~(1ULL << INTERCEPT_VINTR);
+        svm->vmcb->control.int_ctl &= ~V_IRQ_MASK;
         /*
          * If the user space waits to inject interrupts, exit as soon as
          * possible
          */
         if (kvm_run->request_interrupt_window &&
-            !vcpu->irq_summary) {
-                ++vcpu->stat.irq_window_exits;
+            !svm->vcpu.irq_summary) {
+                ++svm->vcpu.stat.irq_window_exits;
                 kvm_run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
                 return 0;
         }
@@ -1291,7 +1213,7 @@ static int interrupt_window_interception(struct kvm_vcpu *vcpu,
         return 1;
 }
 
-static int (*svm_exit_handlers[])(struct kvm_vcpu *vcpu,
+static int (*svm_exit_handlers[])(struct vcpu_svm *svm,
                                       struct kvm_run *kvm_run) = {
         [SVM_EXIT_READ_CR0]                     = emulate_on_interception,
         [SVM_EXIT_READ_CR3]                     = emulate_on_interception,
@@ -1338,15 +1260,25 @@ static int (*svm_exit_handlers[])(struct kvm_vcpu *vcpu,
 };
 
 
-static int handle_exit(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 {
-        u32 exit_code = vcpu->svm->vmcb->control.exit_code;
+        struct vcpu_svm *svm = to_svm(vcpu);
+        u32 exit_code = svm->vmcb->control.exit_code;
+
+        kvm_reput_irq(svm);
 
-        if (is_external_interrupt(vcpu->svm->vmcb->control.exit_int_info) &&
+        if (svm->vmcb->control.exit_code == SVM_EXIT_ERR) {
+                kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
+                kvm_run->fail_entry.hardware_entry_failure_reason
+                        = svm->vmcb->control.exit_code;
+                return 0;
+        }
+
+        if (is_external_interrupt(svm->vmcb->control.exit_int_info) &&
             exit_code != SVM_EXIT_EXCP_BASE + PF_VECTOR)
                 printk(KERN_ERR "%s: unexpected exit_ini_info 0x%x "
                        "exit_code 0x%x\n",
-                       __FUNCTION__, vcpu->svm->vmcb->control.exit_int_info,
+                       __FUNCTION__, svm->vmcb->control.exit_int_info,
                        exit_code);
 
         if (exit_code >= ARRAY_SIZE(svm_exit_handlers)
@@ -1356,7 +1288,7 @@ static int handle_exit(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 return 0;
         }
 
-        return svm_exit_handlers[exit_code](vcpu, kvm_run);
+        return svm_exit_handlers[exit_code](svm, kvm_run);
 }
 
 static void reload_tss(struct kvm_vcpu *vcpu)
@@ -1368,93 +1300,126 @@ static void reload_tss(struct kvm_vcpu *vcpu)
         load_TR_desc();
 }
 
-static void pre_svm_run(struct kvm_vcpu *vcpu)
+static void pre_svm_run(struct vcpu_svm *svm)
 {
         int cpu = raw_smp_processor_id();
 
         struct svm_cpu_data *svm_data = per_cpu(svm_data, cpu);
 
-        vcpu->svm->vmcb->control.tlb_ctl = TLB_CONTROL_DO_NOTHING;
-        if (vcpu->cpu != cpu ||
-            vcpu->svm->asid_generation != svm_data->asid_generation)
-                new_asid(vcpu, svm_data);
+        svm->vmcb->control.tlb_ctl = TLB_CONTROL_DO_NOTHING;
+        if (svm->vcpu.cpu != cpu ||
+            svm->asid_generation != svm_data->asid_generation)
+                new_asid(svm, svm_data);
 }
 
 
-static inline void kvm_do_inject_irq(struct kvm_vcpu *vcpu)
+static inline void svm_inject_irq(struct vcpu_svm *svm, int irq)
 {
         struct vmcb_control_area *control;
 
-        control = &vcpu->svm->vmcb->control;
-        control->int_vector = pop_irq(vcpu);
+        control = &svm->vmcb->control;
+        control->int_vector = irq;
         control->int_ctl &= ~V_INTR_PRIO_MASK;
         control->int_ctl |= V_IRQ_MASK |
                 ((/*control->int_vector >> 4*/ 0xf) << V_INTR_PRIO_SHIFT);
 }
 
-static void kvm_reput_irq(struct kvm_vcpu *vcpu)
+static void svm_set_irq(struct kvm_vcpu *vcpu, int irq)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm_inject_irq(svm, irq);
+}
+
+static void svm_intr_assist(struct kvm_vcpu *vcpu)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
+        struct vmcb *vmcb = svm->vmcb;
+        int intr_vector = -1;
+
+        kvm_inject_pending_timer_irqs(vcpu);
+        if ((vmcb->control.exit_int_info & SVM_EVTINJ_VALID) &&
+            ((vmcb->control.exit_int_info & SVM_EVTINJ_TYPE_MASK) == 0)) {
+                intr_vector = vmcb->control.exit_int_info &
+                              SVM_EVTINJ_VEC_MASK;
+                vmcb->control.exit_int_info = 0;
+                svm_inject_irq(svm, intr_vector);
+                return;
+        }
+
+        if (vmcb->control.int_ctl & V_IRQ_MASK)
+                return;
+
+        if (!kvm_cpu_has_interrupt(vcpu))
+                return;
+
+        if (!(vmcb->save.rflags & X86_EFLAGS_IF) ||
+            (vmcb->control.int_state & SVM_INTERRUPT_SHADOW_MASK) ||
+            (vmcb->control.event_inj & SVM_EVTINJ_VALID)) {
+                /* unable to deliver irq, set pending irq */
+                vmcb->control.intercept |= (1ULL << INTERCEPT_VINTR);
+                svm_inject_irq(svm, 0x0);
+                return;
+        }
+        /* Okay, we can deliver the interrupt: grab it and update PIC state. */
+        intr_vector = kvm_cpu_get_interrupt(vcpu);
+        svm_inject_irq(svm, intr_vector);
+        kvm_timer_intr_post(vcpu, intr_vector);
+}
+
+static void kvm_reput_irq(struct vcpu_svm *svm)
 {
-        struct vmcb_control_area *control = &vcpu->svm->vmcb->control;
+        struct vmcb_control_area *control = &svm->vmcb->control;
 
-        if (control->int_ctl & V_IRQ_MASK) {
+        if ((control->int_ctl & V_IRQ_MASK)
+            && !irqchip_in_kernel(svm->vcpu.kvm)) {
                 control->int_ctl &= ~V_IRQ_MASK;
-                push_irq(vcpu, control->int_vector);
+                push_irq(&svm->vcpu, control->int_vector);
         }
 
-        vcpu->interrupt_window_open =
+        svm->vcpu.interrupt_window_open =
                 !(control->int_state & SVM_INTERRUPT_SHADOW_MASK);
 }
 
+static void svm_do_inject_vector(struct vcpu_svm *svm)
+{
+        struct kvm_vcpu *vcpu = &svm->vcpu;
+        int word_index = __ffs(vcpu->irq_summary);
+        int bit_index = __ffs(vcpu->irq_pending[word_index]);
+        int irq = word_index * BITS_PER_LONG + bit_index;
+
+        clear_bit(bit_index, &vcpu->irq_pending[word_index]);
+        if (!vcpu->irq_pending[word_index])
+                clear_bit(word_index, &vcpu->irq_summary);
+        svm_inject_irq(svm, irq);
+}
+
 static void do_interrupt_requests(struct kvm_vcpu *vcpu,
                                        struct kvm_run *kvm_run)
 {
-        struct vmcb_control_area *control = &vcpu->svm->vmcb->control;
+        struct vcpu_svm *svm = to_svm(vcpu);
+        struct vmcb_control_area *control = &svm->vmcb->control;
 
-        vcpu->interrupt_window_open =
+        svm->vcpu.interrupt_window_open =
                 (!(control->int_state & SVM_INTERRUPT_SHADOW_MASK) &&
-                 (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF));
+                 (svm->vmcb->save.rflags & X86_EFLAGS_IF));
 
-        if (vcpu->interrupt_window_open && vcpu->irq_summary)
+        if (svm->vcpu.interrupt_window_open && svm->vcpu.irq_summary)
                 /*
                  * If interrupts enabled, and not blocked by sti or mov ss. Good.
                  */
-                kvm_do_inject_irq(vcpu);
+                svm_do_inject_vector(svm);
 
         /*
          * Interrupts blocked.  Wait for unblock.
          */
-        if (!vcpu->interrupt_window_open &&
-            (vcpu->irq_summary || kvm_run->request_interrupt_window)) {
+        if (!svm->vcpu.interrupt_window_open &&
+            (svm->vcpu.irq_summary || kvm_run->request_interrupt_window)) {
                 control->intercept |= 1ULL << INTERCEPT_VINTR;
         } else
                 control->intercept &= ~(1ULL << INTERCEPT_VINTR);
 }
 
-static void post_kvm_run_save(struct kvm_vcpu *vcpu,
-                              struct kvm_run *kvm_run)
-{
-        kvm_run->ready_for_interrupt_injection = (vcpu->interrupt_window_open &&
-                                                  vcpu->irq_summary == 0);
-        kvm_run->if_flag = (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF) != 0;
-        kvm_run->cr8 = vcpu->cr8;
-        kvm_run->apic_base = vcpu->apic_base;
-}
-
-/*
- * Check if userspace requested an interrupt window, and that the
- * interrupt window is open.
- *
- * No need to exit to userspace if we already have an interrupt queued.
- */
-static int dm_request_for_irq_injection(struct kvm_vcpu *vcpu,
-                                          struct kvm_run *kvm_run)
-{
-        return (!vcpu->irq_summary &&
-                kvm_run->request_interrupt_window &&
-                vcpu->interrupt_window_open &&
-                (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF));
-}
-
 static void save_db_regs(unsigned long *db_regs)
 {
         asm volatile ("mov %%dr0, %0" : "=r"(db_regs[0]));
@@ -1476,49 +1441,37 @@ static void svm_flush_tlb(struct kvm_vcpu *vcpu)
         force_new_asid(vcpu);
 }
 
-static int svm_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static void svm_prepare_guest_switch(struct kvm_vcpu *vcpu)
+{
+}
+
+static void svm_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
+        struct vcpu_svm *svm = to_svm(vcpu);
         u16 fs_selector;
         u16 gs_selector;
         u16 ldt_selector;
-        int r;
-
-again:
-        r = kvm_mmu_reload(vcpu);
-        if (unlikely(r))
-                return r;
-
-        if (!vcpu->mmio_read_completed)
-                do_interrupt_requests(vcpu, kvm_run);
 
-        clgi();
-
-        vcpu->guest_mode = 1;
-        if (vcpu->requests)
-                if (test_and_clear_bit(KVM_TLB_FLUSH, &vcpu->requests))
-                    svm_flush_tlb(vcpu);
-
-        pre_svm_run(vcpu);
+        pre_svm_run(svm);
 
         save_host_msrs(vcpu);
         fs_selector = read_fs();
         gs_selector = read_gs();
         ldt_selector = read_ldt();
-        vcpu->svm->host_cr2 = kvm_read_cr2();
-        vcpu->svm->host_dr6 = read_dr6();
-        vcpu->svm->host_dr7 = read_dr7();
-        vcpu->svm->vmcb->save.cr2 = vcpu->cr2;
+        svm->host_cr2 = kvm_read_cr2();
+        svm->host_dr6 = read_dr6();
+        svm->host_dr7 = read_dr7();
+        svm->vmcb->save.cr2 = vcpu->cr2;
 
-        if (vcpu->svm->vmcb->save.dr7 & 0xff) {
+        if (svm->vmcb->save.dr7 & 0xff) {
                 write_dr7(0);
-                save_db_regs(vcpu->svm->host_db_regs);
-                load_db_regs(vcpu->svm->db_regs);
+                save_db_regs(svm->host_db_regs);
+                load_db_regs(svm->db_regs);
         }
 
-        if (vcpu->fpu_active) {
-                fx_save(vcpu->host_fx_image);
-                fx_restore(vcpu->guest_fx_image);
-        }
+        clgi();
+
+        local_irq_enable();
 
         asm volatile (
 #ifdef CONFIG_X86_64
@@ -1532,34 +1485,33 @@ again:
 #endif
 
 #ifdef CONFIG_X86_64
-                "mov %c[rbx](%[vcpu]), %%rbx \n\t"
-                "mov %c[rcx](%[vcpu]), %%rcx \n\t"
-                "mov %c[rdx](%[vcpu]), %%rdx \n\t"
-                "mov %c[rsi](%[vcpu]), %%rsi \n\t"
-                "mov %c[rdi](%[vcpu]), %%rdi \n\t"
-                "mov %c[rbp](%[vcpu]), %%rbp \n\t"
-                "mov %c[r8](%[vcpu]),  %%r8  \n\t"
-                "mov %c[r9](%[vcpu]),  %%r9  \n\t"
-                "mov %c[r10](%[vcpu]), %%r10 \n\t"
-                "mov %c[r11](%[vcpu]), %%r11 \n\t"
-                "mov %c[r12](%[vcpu]), %%r12 \n\t"
-                "mov %c[r13](%[vcpu]), %%r13 \n\t"
-                "mov %c[r14](%[vcpu]), %%r14 \n\t"
-                "mov %c[r15](%[vcpu]), %%r15 \n\t"
+                "mov %c[rbx](%[svm]), %%rbx \n\t"
+                "mov %c[rcx](%[svm]), %%rcx \n\t"
+                "mov %c[rdx](%[svm]), %%rdx \n\t"
+                "mov %c[rsi](%[svm]), %%rsi \n\t"
+                "mov %c[rdi](%[svm]), %%rdi \n\t"
+                "mov %c[rbp](%[svm]), %%rbp \n\t"
+                "mov %c[r8](%[svm]),  %%r8  \n\t"
+                "mov %c[r9](%[svm]),  %%r9  \n\t"
+                "mov %c[r10](%[svm]), %%r10 \n\t"
+                "mov %c[r11](%[svm]), %%r11 \n\t"
+                "mov %c[r12](%[svm]), %%r12 \n\t"
+                "mov %c[r13](%[svm]), %%r13 \n\t"
+                "mov %c[r14](%[svm]), %%r14 \n\t"
+                "mov %c[r15](%[svm]), %%r15 \n\t"
 #else
-                "mov %c[rbx](%[vcpu]), %%ebx \n\t"
-                "mov %c[rcx](%[vcpu]), %%ecx \n\t"
-                "mov %c[rdx](%[vcpu]), %%edx \n\t"
-                "mov %c[rsi](%[vcpu]), %%esi \n\t"
-                "mov %c[rdi](%[vcpu]), %%edi \n\t"
-                "mov %c[rbp](%[vcpu]), %%ebp \n\t"
+                "mov %c[rbx](%[svm]), %%ebx \n\t"
+                "mov %c[rcx](%[svm]), %%ecx \n\t"
+                "mov %c[rdx](%[svm]), %%edx \n\t"
+                "mov %c[rsi](%[svm]), %%esi \n\t"
+                "mov %c[rdi](%[svm]), %%edi \n\t"
+                "mov %c[rbp](%[svm]), %%ebp \n\t"
 #endif
 
 #ifdef CONFIG_X86_64
                 /* Enter guest mode */
                 "push %%rax \n\t"
-                "mov %c[svm](%[vcpu]), %%rax \n\t"
-                "mov %c[vmcb](%%rax), %%rax \n\t"
+                "mov %c[vmcb](%[svm]), %%rax \n\t"
                 SVM_VMLOAD "\n\t"
                 SVM_VMRUN "\n\t"
                 SVM_VMSAVE "\n\t"
@@ -1567,8 +1519,7 @@ again:
 #else
                 /* Enter guest mode */
                 "push %%eax \n\t"
-                "mov %c[svm](%[vcpu]), %%eax \n\t"
-                "mov %c[vmcb](%%eax), %%eax \n\t"
+                "mov %c[vmcb](%[svm]), %%eax \n\t"
                 SVM_VMLOAD "\n\t"
                 SVM_VMRUN "\n\t"
                 SVM_VMSAVE "\n\t"
@@ -1577,73 +1528,69 @@ again:
 
                 /* Save guest registers, load host registers */
 #ifdef CONFIG_X86_64
-                "mov %%rbx, %c[rbx](%[vcpu]) \n\t"
-                "mov %%rcx, %c[rcx](%[vcpu]) \n\t"
-                "mov %%rdx, %c[rdx](%[vcpu]) \n\t"
-                "mov %%rsi, %c[rsi](%[vcpu]) \n\t"
-                "mov %%rdi, %c[rdi](%[vcpu]) \n\t"
-                "mov %%rbp, %c[rbp](%[vcpu]) \n\t"
-                "mov %%r8,  %c[r8](%[vcpu]) \n\t"
-                "mov %%r9,  %c[r9](%[vcpu]) \n\t"
-                "mov %%r10, %c[r10](%[vcpu]) \n\t"
-                "mov %%r11, %c[r11](%[vcpu]) \n\t"
-                "mov %%r12, %c[r12](%[vcpu]) \n\t"
-                "mov %%r13, %c[r13](%[vcpu]) \n\t"
-                "mov %%r14, %c[r14](%[vcpu]) \n\t"
-                "mov %%r15, %c[r15](%[vcpu]) \n\t"
+                "mov %%rbx, %c[rbx](%[svm]) \n\t"
+                "mov %%rcx, %c[rcx](%[svm]) \n\t"
+                "mov %%rdx, %c[rdx](%[svm]) \n\t"
+                "mov %%rsi, %c[rsi](%[svm]) \n\t"
+                "mov %%rdi, %c[rdi](%[svm]) \n\t"
+                "mov %%rbp, %c[rbp](%[svm]) \n\t"
+                "mov %%r8,  %c[r8](%[svm]) \n\t"
+                "mov %%r9,  %c[r9](%[svm]) \n\t"
+                "mov %%r10, %c[r10](%[svm]) \n\t"
+                "mov %%r11, %c[r11](%[svm]) \n\t"
+                "mov %%r12, %c[r12](%[svm]) \n\t"
+                "mov %%r13, %c[r13](%[svm]) \n\t"
+                "mov %%r14, %c[r14](%[svm]) \n\t"
+                "mov %%r15, %c[r15](%[svm]) \n\t"
 
                 "pop  %%r15; pop  %%r14; pop  %%r13; pop  %%r12;"
                 "pop  %%r11; pop  %%r10; pop  %%r9;  pop  %%r8;"
                 "pop  %%rbp; pop  %%rdi; pop  %%rsi;"
                 "pop  %%rdx; pop  %%rcx; pop  %%rbx; \n\t"
 #else
-                "mov %%ebx, %c[rbx](%[vcpu]) \n\t"
-                "mov %%ecx, %c[rcx](%[vcpu]) \n\t"
-                "mov %%edx, %c[rdx](%[vcpu]) \n\t"
-                "mov %%esi, %c[rsi](%[vcpu]) \n\t"
-                "mov %%edi, %c[rdi](%[vcpu]) \n\t"
-                "mov %%ebp, %c[rbp](%[vcpu]) \n\t"
+                "mov %%ebx, %c[rbx](%[svm]) \n\t"
+                "mov %%ecx, %c[rcx](%[svm]) \n\t"
+                "mov %%edx, %c[rdx](%[svm]) \n\t"
+                "mov %%esi, %c[rsi](%[svm]) \n\t"
+                "mov %%edi, %c[rdi](%[svm]) \n\t"
+                "mov %%ebp, %c[rbp](%[svm]) \n\t"
 
                 "pop  %%ebp; pop  %%edi; pop  %%esi;"
                 "pop  %%edx; pop  %%ecx; pop  %%ebx; \n\t"
 #endif
                 :
-                : [vcpu]"a"(vcpu),
-                  [svm]"i"(offsetof(struct kvm_vcpu, svm)),
+                : [svm]"a"(svm),
                   [vmcb]"i"(offsetof(struct vcpu_svm, vmcb_pa)),
-                  [rbx]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RBX])),
-                  [rcx]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RCX])),
-                  [rdx]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RDX])),
-                  [rsi]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RSI])),
-                  [rdi]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RDI])),
-                  [rbp]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RBP]))
+                  [rbx]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RBX])),
+                  [rcx]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RCX])),
+                  [rdx]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RDX])),
+                  [rsi]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RSI])),
+                  [rdi]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RDI])),
+                  [rbp]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_RBP]))
 #ifdef CONFIG_X86_64
-                  ,[r8 ]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R8 ])),
-                  [r9 ]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R9 ])),
-                  [r10]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R10])),
-                  [r11]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R11])),
-                  [r12]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R12])),
-                  [r13]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R13])),
-                  [r14]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R14])),
-                  [r15]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_R15]))
+                  ,[r8 ]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R8])),
+                  [r9 ]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R9 ])),
+                  [r10]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R10])),
+                  [r11]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R11])),
+                  [r12]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R12])),
+                  [r13]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R13])),
+                  [r14]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R14])),
+                  [r15]"i"(offsetof(struct vcpu_svm,vcpu.regs[VCPU_REGS_R15]))
 #endif
                 : "cc", "memory" );
 
-        vcpu->guest_mode = 0;
+        local_irq_disable();
 
-        if (vcpu->fpu_active) {
-                fx_save(vcpu->guest_fx_image);
-                fx_restore(vcpu->host_fx_image);
-        }
+        stgi();
 
-        if ((vcpu->svm->vmcb->save.dr7 & 0xff))
-                load_db_regs(vcpu->svm->host_db_regs);
+        if ((svm->vmcb->save.dr7 & 0xff))
+                load_db_regs(svm->host_db_regs);
 
-        vcpu->cr2 = vcpu->svm->vmcb->save.cr2;
+        vcpu->cr2 = svm->vmcb->save.cr2;
 
-        write_dr6(vcpu->svm->host_dr6);
-        write_dr7(vcpu->svm->host_dr7);
-        kvm_write_cr2(vcpu->svm->host_cr2);
+        write_dr6(svm->host_dr6);
+        write_dr7(svm->host_dr7);
+        kvm_write_cr2(svm->host_cr2);
 
         load_fs(fs_selector);
         load_gs(gs_selector);
@@ -1652,57 +1599,19 @@ again:
 
         reload_tss(vcpu);
 
-        /*
-         * Profile KVM exit RIPs:
-         */
-        if (unlikely(prof_on == KVM_PROFILING))
-                profile_hit(KVM_PROFILING,
-                        (void *)(unsigned long)vcpu->svm->vmcb->save.rip);
-
-        stgi();
-
-        kvm_reput_irq(vcpu);
-
-        vcpu->svm->next_rip = 0;
-
-        if (vcpu->svm->vmcb->control.exit_code == SVM_EXIT_ERR) {
-                kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
-                kvm_run->fail_entry.hardware_entry_failure_reason
-                        = vcpu->svm->vmcb->control.exit_code;
-                post_kvm_run_save(vcpu, kvm_run);
-                return 0;
-        }
-
-        r = handle_exit(vcpu, kvm_run);
-        if (r > 0) {
-                if (signal_pending(current)) {
-                        ++vcpu->stat.signal_exits;
-                        post_kvm_run_save(vcpu, kvm_run);
-                        kvm_run->exit_reason = KVM_EXIT_INTR;
-                        return -EINTR;
-                }
-
-                if (dm_request_for_irq_injection(vcpu, kvm_run)) {
-                        ++vcpu->stat.request_irq_exits;
-                        post_kvm_run_save(vcpu, kvm_run);
-                        kvm_run->exit_reason = KVM_EXIT_INTR;
-                        return -EINTR;
-                }
-                kvm_resched(vcpu);
-                goto again;
-        }
-        post_kvm_run_save(vcpu, kvm_run);
-        return r;
+        svm->next_rip = 0;
 }
 
 static void svm_set_cr3(struct kvm_vcpu *vcpu, unsigned long root)
 {
-        vcpu->svm->vmcb->save.cr3 = root;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm->vmcb->save.cr3 = root;
         force_new_asid(vcpu);
 
         if (vcpu->fpu_active) {
-                vcpu->svm->vmcb->control.intercept_exceptions |= (1 << NM_VECTOR);
-                vcpu->svm->vmcb->save.cr0 |= CR0_TS_MASK;
+                svm->vmcb->control.intercept_exceptions |= (1 << NM_VECTOR);
+                svm->vmcb->save.cr0 |= X86_CR0_TS;
                 vcpu->fpu_active = 0;
         }
 }
@@ -1711,26 +1620,27 @@ static void svm_inject_page_fault(struct kvm_vcpu *vcpu,
                                   unsigned long  addr,
                                   uint32_t err_code)
 {
-        uint32_t exit_int_info = vcpu->svm->vmcb->control.exit_int_info;
+        struct vcpu_svm *svm = to_svm(vcpu);
+        uint32_t exit_int_info = svm->vmcb->control.exit_int_info;
 
         ++vcpu->stat.pf_guest;
 
         if (is_page_fault(exit_int_info)) {
 
-                vcpu->svm->vmcb->control.event_inj_err = 0;
-                vcpu->svm->vmcb->control.event_inj =    SVM_EVTINJ_VALID |
-                                                        SVM_EVTINJ_VALID_ERR |
-                                                        SVM_EVTINJ_TYPE_EXEPT |
-                                                        DF_VECTOR;
+                svm->vmcb->control.event_inj_err = 0;
+                svm->vmcb->control.event_inj =  SVM_EVTINJ_VALID |
+                                                SVM_EVTINJ_VALID_ERR |
+                                                SVM_EVTINJ_TYPE_EXEPT |
+                                                DF_VECTOR;
                 return;
         }
         vcpu->cr2 = addr;
-        vcpu->svm->vmcb->save.cr2 = addr;
-        vcpu->svm->vmcb->control.event_inj =    SVM_EVTINJ_VALID |
-                                                SVM_EVTINJ_VALID_ERR |
-                                                SVM_EVTINJ_TYPE_EXEPT |
-                                                PF_VECTOR;
-        vcpu->svm->vmcb->control.event_inj_err = err_code;
+        svm->vmcb->save.cr2 = addr;
+        svm->vmcb->control.event_inj =  SVM_EVTINJ_VALID |
+                                        SVM_EVTINJ_VALID_ERR |
+                                        SVM_EVTINJ_TYPE_EXEPT |
+                                        PF_VECTOR;
+        svm->vmcb->control.event_inj_err = err_code;
 }
 
 
@@ -1757,17 +1667,25 @@ svm_patch_hypercall(struct kvm_vcpu *vcpu, unsigned char *hypercall)
         hypercall[3] = 0xc3;
 }
 
-static struct kvm_arch_ops svm_arch_ops = {
+static void svm_check_processor_compat(void *rtn)
+{
+        *(int *)rtn = 0;
+}
+
+static struct kvm_x86_ops svm_x86_ops = {
         .cpu_has_kvm_support = has_svm,
         .disabled_by_bios = is_disabled,
         .hardware_setup = svm_hardware_setup,
         .hardware_unsetup = svm_hardware_unsetup,
+        .check_processor_compatibility = svm_check_processor_compat,
         .hardware_enable = svm_hardware_enable,
         .hardware_disable = svm_hardware_disable,
 
         .vcpu_create = svm_create_vcpu,
         .vcpu_free = svm_free_vcpu,
+        .vcpu_reset = svm_vcpu_reset,
 
+        .prepare_guest_switch = svm_prepare_guest_switch,
         .vcpu_load = svm_vcpu_load,
         .vcpu_put = svm_vcpu_put,
         .vcpu_decache = svm_vcpu_decache,
@@ -1778,7 +1696,7 @@ static struct kvm_arch_ops svm_arch_ops = {
         .get_segment_base = svm_get_segment_base,
         .get_segment = svm_get_segment,
         .set_segment = svm_set_segment,
-        .get_cs_db_l_bits = svm_get_cs_db_l_bits,
+        .get_cs_db_l_bits = kvm_get_cs_db_l_bits,
         .decache_cr4_guest_bits = svm_decache_cr4_guest_bits,
         .set_cr0 = svm_set_cr0,
         .set_cr3 = svm_set_cr3,
@@ -1795,26 +1713,30 @@ static struct kvm_arch_ops svm_arch_ops = {
         .get_rflags = svm_get_rflags,
         .set_rflags = svm_set_rflags,
 
-        .invlpg = svm_invlpg,
         .tlb_flush = svm_flush_tlb,
         .inject_page_fault = svm_inject_page_fault,
 
         .inject_gp = svm_inject_gp,
 
         .run = svm_vcpu_run,
+        .handle_exit = handle_exit,
         .skip_emulated_instruction = skip_emulated_instruction,
-        .vcpu_setup = svm_vcpu_setup,
         .patch_hypercall = svm_patch_hypercall,
+        .get_irq = svm_get_irq,
+        .set_irq = svm_set_irq,
+        .inject_pending_irq = svm_intr_assist,
+        .inject_pending_vectors = do_interrupt_requests,
 };
 
 static int __init svm_init(void)
 {
-        return kvm_init_arch(&svm_arch_ops, THIS_MODULE);
+        return kvm_init_x86(&svm_x86_ops, sizeof(struct vcpu_svm),
+                              THIS_MODULE);
 }
 
 static void __exit svm_exit(void)
 {
-        kvm_exit_arch();
+        kvm_exit_x86();
 }
 
 module_init(svm_init)
diff --git a/drivers/kvm/vmx.c b/drivers/kvm/vmx.c
index 80628f6991..4f115a8e45 100644
--- a/drivers/kvm/vmx.c
+++ b/drivers/kvm/vmx.c
@@ -16,6 +16,8 @@
  */
 
 #include "kvm.h"
+#include "x86_emulate.h"
+#include "irq.h"
 #include "vmx.h"
 #include "segment_descriptor.h"
 
@@ -23,7 +25,6 @@
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
-#include <linux/profile.h>
 #include <linux/sched.h>
 
 #include <asm/io.h>
@@ -32,6 +33,39 @@
 MODULE_AUTHOR("Qumranet");
 MODULE_LICENSE("GPL");
 
+struct vmcs {
+        u32 revision_id;
+        u32 abort;
+        char data[0];
+};
+
+struct vcpu_vmx {
+        struct kvm_vcpu       vcpu;
+        int                   launched;
+        u8                    fail;
+        struct kvm_msr_entry *guest_msrs;
+        struct kvm_msr_entry *host_msrs;
+        int                   nmsrs;
+        int                   save_nmsrs;
+        int                   msr_offset_efer;
+#ifdef CONFIG_X86_64
+        int                   msr_offset_kernel_gs_base;
+#endif
+        struct vmcs          *vmcs;
+        struct {
+                int           loaded;
+                u16           fs_sel, gs_sel, ldt_sel;
+                int           gs_ldt_reload_needed;
+                int           fs_reload_needed;
+        }host_state;
+
+};
+
+static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
+{
+        return container_of(vcpu, struct vcpu_vmx, vcpu);
+}
+
 static int init_rmode_tss(struct kvm *kvm);
 
 static DEFINE_PER_CPU(struct vmcs *, vmxarea);
@@ -40,18 +74,17 @@ static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
 static struct page *vmx_io_bitmap_a;
 static struct page *vmx_io_bitmap_b;
 
-#ifdef CONFIG_X86_64
-#define HOST_IS_64 1
-#else
-#define HOST_IS_64 0
-#endif
 #define EFER_SAVE_RESTORE_BITS ((u64)EFER_SCE)
 
-static struct vmcs_descriptor {
+static struct vmcs_config {
         int size;
         int order;
         u32 revision_id;
-} vmcs_descriptor;
+        u32 pin_based_exec_ctrl;
+        u32 cpu_based_exec_ctrl;
+        u32 vmexit_ctrl;
+        u32 vmentry_ctrl;
+} vmcs_config;
 
 #define VMX_SEGMENT_FIELD(seg)                                  \
         [VCPU_SREG_##seg] = {                                   \
@@ -89,16 +122,32 @@ static const u32 vmx_msr_index[] = {
 };
 #define NR_VMX_MSR ARRAY_SIZE(vmx_msr_index)
 
-static inline u64 msr_efer_save_restore_bits(struct vmx_msr_entry msr)
+static void load_msrs(struct kvm_msr_entry *e, int n)
+{
+        int i;
+
+        for (i = 0; i < n; ++i)
+                wrmsrl(e[i].index, e[i].data);
+}
+
+static void save_msrs(struct kvm_msr_entry *e, int n)
+{
+        int i;
+
+        for (i = 0; i < n; ++i)
+                rdmsrl(e[i].index, e[i].data);
+}
+
+static inline u64 msr_efer_save_restore_bits(struct kvm_msr_entry msr)
 {
         return (u64)msr.data & EFER_SAVE_RESTORE_BITS;
 }
 
-static inline int msr_efer_need_save_restore(struct kvm_vcpu *vcpu)
+static inline int msr_efer_need_save_restore(struct vcpu_vmx *vmx)
 {
-        int efer_offset = vcpu->msr_offset_efer;
-        return msr_efer_save_restore_bits(vcpu->host_msrs[efer_offset]) !=
-                msr_efer_save_restore_bits(vcpu->guest_msrs[efer_offset]);
+        int efer_offset = vmx->msr_offset_efer;
+        return msr_efer_save_restore_bits(vmx->host_msrs[efer_offset]) !=
+                msr_efer_save_restore_bits(vmx->guest_msrs[efer_offset]);
 }
 
 static inline int is_page_fault(u32 intr_info)
@@ -121,23 +170,33 @@ static inline int is_external_interrupt(u32 intr_info)
                 == (INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
 }
 
-static int __find_msr_index(struct kvm_vcpu *vcpu, u32 msr)
+static inline int cpu_has_vmx_tpr_shadow(void)
+{
+        return (vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW);
+}
+
+static inline int vm_need_tpr_shadow(struct kvm *kvm)
+{
+        return ((cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm)));
+}
+
+static int __find_msr_index(struct vcpu_vmx *vmx, u32 msr)
 {
         int i;
 
-        for (i = 0; i < vcpu->nmsrs; ++i)
-                if (vcpu->guest_msrs[i].index == msr)
+        for (i = 0; i < vmx->nmsrs; ++i)
+                if (vmx->guest_msrs[i].index == msr)
                         return i;
         return -1;
 }
 
-static struct vmx_msr_entry *find_msr_entry(struct kvm_vcpu *vcpu, u32 msr)
+static struct kvm_msr_entry *find_msr_entry(struct vcpu_vmx *vmx, u32 msr)
 {
         int i;
 
-        i = __find_msr_index(vcpu, msr);
+        i = __find_msr_index(vmx, msr);
         if (i >= 0)
-                return &vcpu->guest_msrs[i];
+                return &vmx->guest_msrs[i];
         return NULL;
 }
 
@@ -156,23 +215,24 @@ static void vmcs_clear(struct vmcs *vmcs)
 
 static void __vcpu_clear(void *arg)
 {
-        struct kvm_vcpu *vcpu = arg;
+        struct vcpu_vmx *vmx = arg;
         int cpu = raw_smp_processor_id();
 
-        if (vcpu->cpu == cpu)
-                vmcs_clear(vcpu->vmcs);
-        if (per_cpu(current_vmcs, cpu) == vcpu->vmcs)
+        if (vmx->vcpu.cpu == cpu)
+                vmcs_clear(vmx->vmcs);
+        if (per_cpu(current_vmcs, cpu) == vmx->vmcs)
                 per_cpu(current_vmcs, cpu) = NULL;
-        rdtscll(vcpu->host_tsc);
+        rdtscll(vmx->vcpu.host_tsc);
 }
 
-static void vcpu_clear(struct kvm_vcpu *vcpu)
+static void vcpu_clear(struct vcpu_vmx *vmx)
 {
-        if (vcpu->cpu != raw_smp_processor_id() && vcpu->cpu != -1)
-                smp_call_function_single(vcpu->cpu, __vcpu_clear, vcpu, 0, 1);
+        if (vmx->vcpu.cpu != raw_smp_processor_id() && vmx->vcpu.cpu != -1)
+                smp_call_function_single(vmx->vcpu.cpu, __vcpu_clear,
+                                         vmx, 0, 1);
         else
-                __vcpu_clear(vcpu);
-        vcpu->launched = 0;
+                __vcpu_clear(vmx);
+        vmx->launched = 0;
 }
 
 static unsigned long vmcs_readl(unsigned long field)
@@ -282,121 +342,122 @@ static void reload_tss(void)
 #endif
 }
 
-static void load_transition_efer(struct kvm_vcpu *vcpu)
+static void load_transition_efer(struct vcpu_vmx *vmx)
 {
         u64 trans_efer;
-        int efer_offset = vcpu->msr_offset_efer;
+        int efer_offset = vmx->msr_offset_efer;
 
-        trans_efer = vcpu->host_msrs[efer_offset].data;
+        trans_efer = vmx->host_msrs[efer_offset].data;
         trans_efer &= ~EFER_SAVE_RESTORE_BITS;
-        trans_efer |= msr_efer_save_restore_bits(
-                                vcpu->guest_msrs[efer_offset]);
+        trans_efer |= msr_efer_save_restore_bits(vmx->guest_msrs[efer_offset]);
         wrmsrl(MSR_EFER, trans_efer);
-        vcpu->stat.efer_reload++;
+        vmx->vcpu.stat.efer_reload++;
 }
 
 static void vmx_save_host_state(struct kvm_vcpu *vcpu)
 {
-        struct vmx_host_state *hs = &vcpu->vmx_host_state;
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
 
-        if (hs->loaded)
+        if (vmx->host_state.loaded)
                 return;
 
-        hs->loaded = 1;
+        vmx->host_state.loaded = 1;
         /*
          * Set host fs and gs selectors.  Unfortunately, 22.2.3 does not
          * allow segment selectors with cpl > 0 or ti == 1.
          */
-        hs->ldt_sel = read_ldt();
-        hs->fs_gs_ldt_reload_needed = hs->ldt_sel;
-        hs->fs_sel = read_fs();
-        if (!(hs->fs_sel & 7))
-                vmcs_write16(HOST_FS_SELECTOR, hs->fs_sel);
-        else {
+        vmx->host_state.ldt_sel = read_ldt();
+        vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel;
+        vmx->host_state.fs_sel = read_fs();
+        if (!(vmx->host_state.fs_sel & 7)) {
+                vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel);
+                vmx->host_state.fs_reload_needed = 0;
+        } else {
                 vmcs_write16(HOST_FS_SELECTOR, 0);
-                hs->fs_gs_ldt_reload_needed = 1;
+                vmx->host_state.fs_reload_needed = 1;
         }
-        hs->gs_sel = read_gs();
-        if (!(hs->gs_sel & 7))
-                vmcs_write16(HOST_GS_SELECTOR, hs->gs_sel);
+        vmx->host_state.gs_sel = read_gs();
+        if (!(vmx->host_state.gs_sel & 7))
+                vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel);
         else {
                 vmcs_write16(HOST_GS_SELECTOR, 0);
-                hs->fs_gs_ldt_reload_needed = 1;
+                vmx->host_state.gs_ldt_reload_needed = 1;
         }
 
 #ifdef CONFIG_X86_64
         vmcs_writel(HOST_FS_BASE, read_msr(MSR_FS_BASE));
         vmcs_writel(HOST_GS_BASE, read_msr(MSR_GS_BASE));
 #else
-        vmcs_writel(HOST_FS_BASE, segment_base(hs->fs_sel));
-        vmcs_writel(HOST_GS_BASE, segment_base(hs->gs_sel));
+        vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel));
+        vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel));
 #endif
 
 #ifdef CONFIG_X86_64
-        if (is_long_mode(vcpu)) {
-                save_msrs(vcpu->host_msrs + vcpu->msr_offset_kernel_gs_base, 1);
+        if (is_long_mode(&vmx->vcpu)) {
+                save_msrs(vmx->host_msrs +
+                          vmx->msr_offset_kernel_gs_base, 1);
         }
 #endif
-        load_msrs(vcpu->guest_msrs, vcpu->save_nmsrs);
-        if (msr_efer_need_save_restore(vcpu))
-                load_transition_efer(vcpu);
+        load_msrs(vmx->guest_msrs, vmx->save_nmsrs);
+        if (msr_efer_need_save_restore(vmx))
+                load_transition_efer(vmx);
 }
 
-static void vmx_load_host_state(struct kvm_vcpu *vcpu)
+static void vmx_load_host_state(struct vcpu_vmx *vmx)
 {
-        struct vmx_host_state *hs = &vcpu->vmx_host_state;
+        unsigned long flags;
 
-        if (!hs->loaded)
+        if (!vmx->host_state.loaded)
                 return;
 
-        hs->loaded = 0;
-        if (hs->fs_gs_ldt_reload_needed) {
-                load_ldt(hs->ldt_sel);
-                load_fs(hs->fs_sel);
+        vmx->host_state.loaded = 0;
+        if (vmx->host_state.fs_reload_needed)
+                load_fs(vmx->host_state.fs_sel);
+        if (vmx->host_state.gs_ldt_reload_needed) {
+                load_ldt(vmx->host_state.ldt_sel);
                 /*
                  * If we have to reload gs, we must take care to
                  * preserve our gs base.
                  */
-                local_irq_disable();
-                load_gs(hs->gs_sel);
+                local_irq_save(flags);
+                load_gs(vmx->host_state.gs_sel);
 #ifdef CONFIG_X86_64
                 wrmsrl(MSR_GS_BASE, vmcs_readl(HOST_GS_BASE));
 #endif
-                local_irq_enable();
-
-                reload_tss();
+                local_irq_restore(flags);
         }
-        save_msrs(vcpu->guest_msrs, vcpu->save_nmsrs);
-        load_msrs(vcpu->host_msrs, vcpu->save_nmsrs);
-        if (msr_efer_need_save_restore(vcpu))
-                load_msrs(vcpu->host_msrs + vcpu->msr_offset_efer, 1);
+        reload_tss();
+        save_msrs(vmx->guest_msrs, vmx->save_nmsrs);
+        load_msrs(vmx->host_msrs, vmx->save_nmsrs);
+        if (msr_efer_need_save_restore(vmx))
+                load_msrs(vmx->host_msrs + vmx->msr_offset_efer, 1);
 }
 
 /*
  * Switches to specified vcpu, until a matching vcpu_put(), but assumes
  * vcpu mutex is already taken.
  */
-static void vmx_vcpu_load(struct kvm_vcpu *vcpu)
+static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 {
-        u64 phys_addr = __pa(vcpu->vmcs);
-        int cpu;
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+        u64 phys_addr = __pa(vmx->vmcs);
         u64 tsc_this, delta;
 
-        cpu = get_cpu();
-
-        if (vcpu->cpu != cpu)
-                vcpu_clear(vcpu);
+        if (vcpu->cpu != cpu) {
+                vcpu_clear(vmx);
+                kvm_migrate_apic_timer(vcpu);
+        }
 
-        if (per_cpu(current_vmcs, cpu) != vcpu->vmcs) {
+        if (per_cpu(current_vmcs, cpu) != vmx->vmcs) {
                 u8 error;
 
-                per_cpu(current_vmcs, cpu) = vcpu->vmcs;
+                per_cpu(current_vmcs, cpu) = vmx->vmcs;
                 asm volatile (ASM_VMX_VMPTRLD_RAX "; setna %0"
                               : "=g"(error) : "a"(&phys_addr), "m"(phys_addr)
                               : "cc");
                 if (error)
                         printk(KERN_ERR "kvm: vmptrld %p/%llx fail\n",
-                               vcpu->vmcs, phys_addr);
+                               vmx->vmcs, phys_addr);
         }
 
         if (vcpu->cpu != cpu) {
@@ -426,9 +487,8 @@ static void vmx_vcpu_load(struct kvm_vcpu *vcpu)
 
 static void vmx_vcpu_put(struct kvm_vcpu *vcpu)
 {
-        vmx_load_host_state(vcpu);
+        vmx_load_host_state(to_vmx(vcpu));
         kvm_put_guest_fpu(vcpu);
-        put_cpu();
 }
 
 static void vmx_fpu_activate(struct kvm_vcpu *vcpu)
@@ -436,9 +496,9 @@ static void vmx_fpu_activate(struct kvm_vcpu *vcpu)
         if (vcpu->fpu_active)
                 return;
         vcpu->fpu_active = 1;
-        vmcs_clear_bits(GUEST_CR0, CR0_TS_MASK);
-        if (vcpu->cr0 & CR0_TS_MASK)
-                vmcs_set_bits(GUEST_CR0, CR0_TS_MASK);
+        vmcs_clear_bits(GUEST_CR0, X86_CR0_TS);
+        if (vcpu->cr0 & X86_CR0_TS)
+                vmcs_set_bits(GUEST_CR0, X86_CR0_TS);
         update_exception_bitmap(vcpu);
 }
 
@@ -447,13 +507,13 @@ static void vmx_fpu_deactivate(struct kvm_vcpu *vcpu)
         if (!vcpu->fpu_active)
                 return;
         vcpu->fpu_active = 0;
-        vmcs_set_bits(GUEST_CR0, CR0_TS_MASK);
+        vmcs_set_bits(GUEST_CR0, X86_CR0_TS);
         update_exception_bitmap(vcpu);
 }
 
 static void vmx_vcpu_decache(struct kvm_vcpu *vcpu)
 {
-        vcpu_clear(vcpu);
+        vcpu_clear(to_vmx(vcpu));
 }
 
 static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu)
@@ -501,59 +561,62 @@ static void vmx_inject_gp(struct kvm_vcpu *vcpu, unsigned error_code)
 /*
  * Swap MSR entry in host/guest MSR entry array.
  */
-void move_msr_up(struct kvm_vcpu *vcpu, int from, int to)
+#ifdef CONFIG_X86_64
+static void move_msr_up(struct vcpu_vmx *vmx, int from, int to)
 {
-        struct vmx_msr_entry tmp;
-        tmp = vcpu->guest_msrs[to];
-        vcpu->guest_msrs[to] = vcpu->guest_msrs[from];
-        vcpu->guest_msrs[from] = tmp;
-        tmp = vcpu->host_msrs[to];
-        vcpu->host_msrs[to] = vcpu->host_msrs[from];
-        vcpu->host_msrs[from] = tmp;
+        struct kvm_msr_entry tmp;
+
+        tmp = vmx->guest_msrs[to];
+        vmx->guest_msrs[to] = vmx->guest_msrs[from];
+        vmx->guest_msrs[from] = tmp;
+        tmp = vmx->host_msrs[to];
+        vmx->host_msrs[to] = vmx->host_msrs[from];
+        vmx->host_msrs[from] = tmp;
 }
+#endif
 
 /*
  * Set up the vmcs to automatically save and restore system
  * msrs.  Don't touch the 64-bit msrs if the guest is in legacy
  * mode, as fiddling with msrs is very expensive.
  */
-static void setup_msrs(struct kvm_vcpu *vcpu)
+static void setup_msrs(struct vcpu_vmx *vmx)
 {
         int save_nmsrs;
 
         save_nmsrs = 0;
 #ifdef CONFIG_X86_64
-        if (is_long_mode(vcpu)) {
+        if (is_long_mode(&vmx->vcpu)) {
                 int index;
 
-                index = __find_msr_index(vcpu, MSR_SYSCALL_MASK);
+                index = __find_msr_index(vmx, MSR_SYSCALL_MASK);
                 if (index >= 0)
-                        move_msr_up(vcpu, index, save_nmsrs++);
-                index = __find_msr_index(vcpu, MSR_LSTAR);
+                        move_msr_up(vmx, index, save_nmsrs++);
+                index = __find_msr_index(vmx, MSR_LSTAR);
                 if (index >= 0)
-                        move_msr_up(vcpu, index, save_nmsrs++);
-                index = __find_msr_index(vcpu, MSR_CSTAR);
+                        move_msr_up(vmx, index, save_nmsrs++);
+                index = __find_msr_index(vmx, MSR_CSTAR);
                 if (index >= 0)
-                        move_msr_up(vcpu, index, save_nmsrs++);
-                index = __find_msr_index(vcpu, MSR_KERNEL_GS_BASE);
+                        move_msr_up(vmx, index, save_nmsrs++);
+                index = __find_msr_index(vmx, MSR_KERNEL_GS_BASE);
                 if (index >= 0)
-                        move_msr_up(vcpu, index, save_nmsrs++);
+                        move_msr_up(vmx, index, save_nmsrs++);
                 /*
                  * MSR_K6_STAR is only needed on long mode guests, and only
                  * if efer.sce is enabled.
                  */
-                index = __find_msr_index(vcpu, MSR_K6_STAR);
-                if ((index >= 0) && (vcpu->shadow_efer & EFER_SCE))
-                        move_msr_up(vcpu, index, save_nmsrs++);
+                index = __find_msr_index(vmx, MSR_K6_STAR);
+                if ((index >= 0) && (vmx->vcpu.shadow_efer & EFER_SCE))
+                        move_msr_up(vmx, index, save_nmsrs++);
         }
 #endif
-        vcpu->save_nmsrs = save_nmsrs;
+        vmx->save_nmsrs = save_nmsrs;
 
 #ifdef CONFIG_X86_64
-        vcpu->msr_offset_kernel_gs_base =
-                __find_msr_index(vcpu, MSR_KERNEL_GS_BASE);
+        vmx->msr_offset_kernel_gs_base =
+                __find_msr_index(vmx, MSR_KERNEL_GS_BASE);
 #endif
-        vcpu->msr_offset_efer = __find_msr_index(vcpu, MSR_EFER);
+        vmx->msr_offset_efer = __find_msr_index(vmx, MSR_EFER);
 }
 
 /*
@@ -589,7 +652,7 @@ static void guest_write_tsc(u64 guest_tsc)
 static int vmx_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
 {
         u64 data;
-        struct vmx_msr_entry *msr;
+        struct kvm_msr_entry *msr;
 
         if (!pdata) {
                 printk(KERN_ERR "BUG: get_msr called with NULL pdata\n");
@@ -620,7 +683,7 @@ static int vmx_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
                 data = vmcs_readl(GUEST_SYSENTER_ESP);
                 break;
         default:
-                msr = find_msr_entry(vcpu, msr_index);
+                msr = find_msr_entry(to_vmx(vcpu), msr_index);
                 if (msr) {
                         data = msr->data;
                         break;
@@ -639,15 +702,16 @@ static int vmx_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
  */
 static int vmx_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
 {
-        struct vmx_msr_entry *msr;
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+        struct kvm_msr_entry *msr;
         int ret = 0;
 
         switch (msr_index) {
 #ifdef CONFIG_X86_64
         case MSR_EFER:
                 ret = kvm_set_msr_common(vcpu, msr_index, data);
-                if (vcpu->vmx_host_state.loaded)
-                        load_transition_efer(vcpu);
+                if (vmx->host_state.loaded)
+                        load_transition_efer(vmx);
                 break;
         case MSR_FS_BASE:
                 vmcs_writel(GUEST_FS_BASE, data);
@@ -669,11 +733,11 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
                 guest_write_tsc(data);
                 break;
         default:
-                msr = find_msr_entry(vcpu, msr_index);
+                msr = find_msr_entry(vmx, msr_index);
                 if (msr) {
                         msr->data = data;
-                        if (vcpu->vmx_host_state.loaded)
-                                load_msrs(vcpu->guest_msrs, vcpu->save_nmsrs);
+                        if (vmx->host_state.loaded)
+                                load_msrs(vmx->guest_msrs, vmx->save_nmsrs);
                         break;
                 }
                 ret = kvm_set_msr_common(vcpu, msr_index, data);
@@ -740,6 +804,20 @@ static int set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_debug_guest *dbg)
         return 0;
 }
 
+static int vmx_get_irq(struct kvm_vcpu *vcpu)
+{
+        u32 idtv_info_field;
+
+        idtv_info_field = vmcs_read32(IDT_VECTORING_INFO_FIELD);
+        if (idtv_info_field & INTR_INFO_VALID_MASK) {
+                if (is_external_interrupt(idtv_info_field))
+                        return idtv_info_field & VECTORING_INFO_VECTOR_MASK;
+                else
+                        printk("pending exception: not handled yet\n");
+        }
+        return -1;
+}
+
 static __init int cpu_has_kvm_support(void)
 {
         unsigned long ecx = cpuid_ecx(1);
@@ -751,7 +829,10 @@ static __init int vmx_disabled_by_bios(void)
         u64 msr;
 
         rdmsrl(MSR_IA32_FEATURE_CONTROL, msr);
-        return (msr & 5) == 1; /* locked but not enabled */
+        return (msr & (MSR_IA32_FEATURE_CONTROL_LOCKED |
+                       MSR_IA32_FEATURE_CONTROL_VMXON_ENABLED))
+            == MSR_IA32_FEATURE_CONTROL_LOCKED;
+        /* locked but not enabled */
 }
 
 static void hardware_enable(void *garbage)
@@ -761,10 +842,15 @@ static void hardware_enable(void *garbage)
         u64 old;
 
         rdmsrl(MSR_IA32_FEATURE_CONTROL, old);
-        if ((old & 5) != 5)
+        if ((old & (MSR_IA32_FEATURE_CONTROL_LOCKED |
+                    MSR_IA32_FEATURE_CONTROL_VMXON_ENABLED))
+            != (MSR_IA32_FEATURE_CONTROL_LOCKED |
+                MSR_IA32_FEATURE_CONTROL_VMXON_ENABLED))
                 /* enable and lock */
-                wrmsrl(MSR_IA32_FEATURE_CONTROL, old | 5);
-        write_cr4(read_cr4() | CR4_VMXE); /* FIXME: not cpu hotplug safe */
+                wrmsrl(MSR_IA32_FEATURE_CONTROL, old |
+                       MSR_IA32_FEATURE_CONTROL_LOCKED |
+                       MSR_IA32_FEATURE_CONTROL_VMXON_ENABLED);
+        write_cr4(read_cr4() | X86_CR4_VMXE); /* FIXME: not cpu hotplug safe */
         asm volatile (ASM_VMX_VMXON_RAX : : "a"(&phys_addr), "m"(phys_addr)
                       : "memory", "cc");
 }
@@ -774,14 +860,102 @@ static void hardware_disable(void *garbage)
         asm volatile (ASM_VMX_VMXOFF : : : "cc");
 }
 
-static __init void setup_vmcs_descriptor(void)
+static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
+                                      u32 msr, u32* result)
+{
+        u32 vmx_msr_low, vmx_msr_high;
+        u32 ctl = ctl_min | ctl_opt;
+
+        rdmsr(msr, vmx_msr_low, vmx_msr_high);
+
+        ctl &= vmx_msr_high; /* bit == 0 in high word ==> must be zero */
+        ctl |= vmx_msr_low;  /* bit == 1 in low word  ==> must be one  */
+
+        /* Ensure minimum (required) set of control bits are supported. */
+        if (ctl_min & ~ctl)
+                return -EIO;
+
+        *result = ctl;
+        return 0;
+}
+
+static __init int setup_vmcs_config(struct vmcs_config *vmcs_conf)
 {
         u32 vmx_msr_low, vmx_msr_high;
+        u32 min, opt;
+        u32 _pin_based_exec_control = 0;
+        u32 _cpu_based_exec_control = 0;
+        u32 _vmexit_control = 0;
+        u32 _vmentry_control = 0;
+
+        min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING;
+        opt = 0;
+        if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS,
+                                &_pin_based_exec_control) < 0)
+                return -EIO;
+
+        min = CPU_BASED_HLT_EXITING |
+#ifdef CONFIG_X86_64
+              CPU_BASED_CR8_LOAD_EXITING |
+              CPU_BASED_CR8_STORE_EXITING |
+#endif
+              CPU_BASED_USE_IO_BITMAPS |
+              CPU_BASED_MOV_DR_EXITING |
+              CPU_BASED_USE_TSC_OFFSETING;
+#ifdef CONFIG_X86_64
+        opt = CPU_BASED_TPR_SHADOW;
+#else
+        opt = 0;
+#endif
+        if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS,
+                                &_cpu_based_exec_control) < 0)
+                return -EIO;
+#ifdef CONFIG_X86_64
+        if ((_cpu_based_exec_control & CPU_BASED_TPR_SHADOW))
+                _cpu_based_exec_control &= ~CPU_BASED_CR8_LOAD_EXITING &
+                                           ~CPU_BASED_CR8_STORE_EXITING;
+#endif
+
+        min = 0;
+#ifdef CONFIG_X86_64
+        min |= VM_EXIT_HOST_ADDR_SPACE_SIZE;
+#endif
+        opt = 0;
+        if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS,
+                                &_vmexit_control) < 0)
+                return -EIO;
+
+        min = opt = 0;
+        if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS,
+                                &_vmentry_control) < 0)
+                return -EIO;
 
         rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high);
-        vmcs_descriptor.size = vmx_msr_high & 0x1fff;
-        vmcs_descriptor.order = get_order(vmcs_descriptor.size);
-        vmcs_descriptor.revision_id = vmx_msr_low;
+
+        /* IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. */
+        if ((vmx_msr_high & 0x1fff) > PAGE_SIZE)
+                return -EIO;
+
+#ifdef CONFIG_X86_64
+        /* IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. */
+        if (vmx_msr_high & (1u<<16))
+                return -EIO;
+#endif
+
+        /* Require Write-Back (WB) memory type for VMCS accesses. */
+        if (((vmx_msr_high >> 18) & 15) != 6)
+                return -EIO;
+
+        vmcs_conf->size = vmx_msr_high & 0x1fff;
+        vmcs_conf->order = get_order(vmcs_config.size);
+        vmcs_conf->revision_id = vmx_msr_low;
+
+        vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control;
+        vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control;
+        vmcs_conf->vmexit_ctrl         = _vmexit_control;
+        vmcs_conf->vmentry_ctrl        = _vmentry_control;
+
+        return 0;
 }
 
 static struct vmcs *alloc_vmcs_cpu(int cpu)
@@ -790,12 +964,12 @@ static struct vmcs *alloc_vmcs_cpu(int cpu)
         struct page *pages;
         struct vmcs *vmcs;
 
-        pages = alloc_pages_node(node, GFP_KERNEL, vmcs_descriptor.order);
+        pages = alloc_pages_node(node, GFP_KERNEL, vmcs_config.order);
         if (!pages)
                 return NULL;
         vmcs = page_address(pages);
-        memset(vmcs, 0, vmcs_descriptor.size);
-        vmcs->revision_id = vmcs_descriptor.revision_id; /* vmcs revision id */
+        memset(vmcs, 0, vmcs_config.size);
+        vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id */
         return vmcs;
 }
 
@@ -806,7 +980,7 @@ static struct vmcs *alloc_vmcs(void)
 
 static void free_vmcs(struct vmcs *vmcs)
 {
-        free_pages((unsigned long)vmcs, vmcs_descriptor.order);
+        free_pages((unsigned long)vmcs, vmcs_config.order);
 }
 
 static void free_kvm_area(void)
@@ -817,8 +991,6 @@ static void free_kvm_area(void)
                 free_vmcs(per_cpu(vmxarea, cpu));
 }
 
-extern struct vmcs *alloc_vmcs_cpu(int cpu);
-
 static __init int alloc_kvm_area(void)
 {
         int cpu;
@@ -839,7 +1011,8 @@ static __init int alloc_kvm_area(void)
 
 static __init int hardware_setup(void)
 {
-        setup_vmcs_descriptor();
+        if (setup_vmcs_config(&vmcs_config) < 0)
+                return -EIO;
         return alloc_kvm_area();
 }
 
@@ -879,8 +1052,8 @@ static void enter_pmode(struct kvm_vcpu *vcpu)
         flags |= (vcpu->rmode.save_iopl << IOPL_SHIFT);
         vmcs_writel(GUEST_RFLAGS, flags);
 
-        vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~CR4_VME_MASK) |
-                        (vmcs_readl(CR4_READ_SHADOW) & CR4_VME_MASK));
+        vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) |
+                        (vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME));
 
         update_exception_bitmap(vcpu);
 
@@ -897,7 +1070,7 @@ static void enter_pmode(struct kvm_vcpu *vcpu)
         vmcs_write32(GUEST_CS_AR_BYTES, 0x9b);
 }
 
-static int rmode_tss_base(struct kvm* kvm)
+static gva_t rmode_tss_base(struct kvm* kvm)
 {
         gfn_t base_gfn = kvm->memslots[0].base_gfn + kvm->memslots[0].npages - 3;
         return base_gfn << PAGE_SHIFT;
@@ -937,7 +1110,7 @@ static void enter_rmode(struct kvm_vcpu *vcpu)
         flags |= IOPL_MASK | X86_EFLAGS_VM;
 
         vmcs_writel(GUEST_RFLAGS, flags);
-        vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) | CR4_VME_MASK);
+        vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) | X86_CR4_VME);
         update_exception_bitmap(vcpu);
 
         vmcs_write16(GUEST_SS_SELECTOR, vmcs_readl(GUEST_SS_BASE) >> 4);
@@ -975,10 +1148,10 @@ static void enter_lmode(struct kvm_vcpu *vcpu)
 
         vcpu->shadow_efer |= EFER_LMA;
 
-        find_msr_entry(vcpu, MSR_EFER)->data |= EFER_LMA | EFER_LME;
+        find_msr_entry(to_vmx(vcpu), MSR_EFER)->data |= EFER_LMA | EFER_LME;
         vmcs_write32(VM_ENTRY_CONTROLS,
                      vmcs_read32(VM_ENTRY_CONTROLS)
-                     | VM_ENTRY_CONTROLS_IA32E_MASK);
+                     | VM_ENTRY_IA32E_MODE);
 }
 
 static void exit_lmode(struct kvm_vcpu *vcpu)
@@ -987,7 +1160,7 @@ static void exit_lmode(struct kvm_vcpu *vcpu)
 
         vmcs_write32(VM_ENTRY_CONTROLS,
                      vmcs_read32(VM_ENTRY_CONTROLS)
-                     & ~VM_ENTRY_CONTROLS_IA32E_MASK);
+                     & ~VM_ENTRY_IA32E_MODE);
 }
 
 #endif
@@ -1002,17 +1175,17 @@ static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 {
         vmx_fpu_deactivate(vcpu);
 
-        if (vcpu->rmode.active && (cr0 & CR0_PE_MASK))
+        if (vcpu->rmode.active && (cr0 & X86_CR0_PE))
                 enter_pmode(vcpu);
 
-        if (!vcpu->rmode.active && !(cr0 & CR0_PE_MASK))
+        if (!vcpu->rmode.active && !(cr0 & X86_CR0_PE))
                 enter_rmode(vcpu);
 
 #ifdef CONFIG_X86_64
         if (vcpu->shadow_efer & EFER_LME) {
-                if (!is_paging(vcpu) && (cr0 & CR0_PG_MASK))
+                if (!is_paging(vcpu) && (cr0 & X86_CR0_PG))
                         enter_lmode(vcpu);
-                if (is_paging(vcpu) && !(cr0 & CR0_PG_MASK))
+                if (is_paging(vcpu) && !(cr0 & X86_CR0_PG))
                         exit_lmode(vcpu);
         }
 #endif
@@ -1022,14 +1195,14 @@ static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
                     (cr0 & ~KVM_GUEST_CR0_MASK) | KVM_VM_CR0_ALWAYS_ON);
         vcpu->cr0 = cr0;
 
-        if (!(cr0 & CR0_TS_MASK) || !(cr0 & CR0_PE_MASK))
+        if (!(cr0 & X86_CR0_TS) || !(cr0 & X86_CR0_PE))
                 vmx_fpu_activate(vcpu);
 }
 
 static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
 {
         vmcs_writel(GUEST_CR3, cr3);
-        if (vcpu->cr0 & CR0_PE_MASK)
+        if (vcpu->cr0 & X86_CR0_PE)
                 vmx_fpu_deactivate(vcpu);
 }
 
@@ -1045,23 +1218,24 @@ static void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
 
 static void vmx_set_efer(struct kvm_vcpu *vcpu, u64 efer)
 {
-        struct vmx_msr_entry *msr = find_msr_entry(vcpu, MSR_EFER);
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+        struct kvm_msr_entry *msr = find_msr_entry(vmx, MSR_EFER);
 
         vcpu->shadow_efer = efer;
         if (efer & EFER_LMA) {
                 vmcs_write32(VM_ENTRY_CONTROLS,
                                      vmcs_read32(VM_ENTRY_CONTROLS) |
-                                     VM_ENTRY_CONTROLS_IA32E_MASK);
+                                     VM_ENTRY_IA32E_MODE);
                 msr->data = efer;
 
         } else {
                 vmcs_write32(VM_ENTRY_CONTROLS,
                                      vmcs_read32(VM_ENTRY_CONTROLS) &
-                                     ~VM_ENTRY_CONTROLS_IA32E_MASK);
+                                     ~VM_ENTRY_IA32E_MODE);
 
                 msr->data = efer & ~EFER_LME;
         }
-        setup_msrs(vcpu);
+        setup_msrs(vmx);
 }
 
 #endif
@@ -1210,17 +1384,6 @@ static int init_rmode_tss(struct kvm* kvm)
         return 1;
 }
 
-static void vmcs_write32_fixedbits(u32 msr, u32 vmcs_field, u32 val)
-{
-        u32 msr_high, msr_low;
-
-        rdmsr(msr, msr_low, msr_high);
-
-        val &= msr_high;
-        val |= msr_low;
-        vmcs_write32(vmcs_field, val);
-}
-
 static void seg_setup(int seg)
 {
         struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
@@ -1234,7 +1397,7 @@ static void seg_setup(int seg)
 /*
  * Sets up the vmcs for emulated real mode.
  */
-static int vmx_vcpu_setup(struct kvm_vcpu *vcpu)
+static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
 {
         u32 host_sysenter_cs;
         u32 junk;
@@ -1243,27 +1406,36 @@ static int vmx_vcpu_setup(struct kvm_vcpu *vcpu)
         int i;
         int ret = 0;
         unsigned long kvm_vmx_return;
+        u64 msr;
+        u32 exec_control;
 
-        if (!init_rmode_tss(vcpu->kvm)) {
+        if (!init_rmode_tss(vmx->vcpu.kvm)) {
                 ret = -ENOMEM;
                 goto out;
         }
 
-        memset(vcpu->regs, 0, sizeof(vcpu->regs));
-        vcpu->regs[VCPU_REGS_RDX] = get_rdx_init_val();
-        vcpu->cr8 = 0;
-        vcpu->apic_base = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
-        if (vcpu == &vcpu->kvm->vcpus[0])
-                vcpu->apic_base |= MSR_IA32_APICBASE_BSP;
+        vmx->vcpu.rmode.active = 0;
 
-        fx_init(vcpu);
+        vmx->vcpu.regs[VCPU_REGS_RDX] = get_rdx_init_val();
+        set_cr8(&vmx->vcpu, 0);
+        msr = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
+        if (vmx->vcpu.vcpu_id == 0)
+                msr |= MSR_IA32_APICBASE_BSP;
+        kvm_set_apic_base(&vmx->vcpu, msr);
+
+        fx_init(&vmx->vcpu);
 
         /*
          * GUEST_CS_BASE should really be 0xffff0000, but VT vm86 mode
          * insists on having GUEST_CS_BASE == GUEST_CS_SELECTOR << 4.  Sigh.
          */
-        vmcs_write16(GUEST_CS_SELECTOR, 0xf000);
-        vmcs_writel(GUEST_CS_BASE, 0x000f0000);
+        if (vmx->vcpu.vcpu_id == 0) {
+                vmcs_write16(GUEST_CS_SELECTOR, 0xf000);
+                vmcs_writel(GUEST_CS_BASE, 0x000f0000);
+        } else {
+                vmcs_write16(GUEST_CS_SELECTOR, vmx->vcpu.sipi_vector << 8);
+                vmcs_writel(GUEST_CS_BASE, vmx->vcpu.sipi_vector << 12);
+        }
         vmcs_write32(GUEST_CS_LIMIT, 0xffff);
         vmcs_write32(GUEST_CS_AR_BYTES, 0x9b);
 
@@ -1288,7 +1460,10 @@ static int vmx_vcpu_setup(struct kvm_vcpu *vcpu)
         vmcs_writel(GUEST_SYSENTER_EIP, 0);
 
         vmcs_writel(GUEST_RFLAGS, 0x02);
-        vmcs_writel(GUEST_RIP, 0xfff0);
+        if (vmx->vcpu.vcpu_id == 0)
+                vmcs_writel(GUEST_RIP, 0xfff0);
+        else
+                vmcs_writel(GUEST_RIP, 0);
         vmcs_writel(GUEST_RSP, 0);
 
         //todo: dr0 = dr1 = dr2 = dr3 = 0; dr6 = 0xffff0ff0
@@ -1316,20 +1491,18 @@ static int vmx_vcpu_setup(struct kvm_vcpu *vcpu)
         vmcs_write64(GUEST_IA32_DEBUGCTL, 0);
 
         /* Control */
-        vmcs_write32_fixedbits(MSR_IA32_VMX_PINBASED_CTLS,
-                               PIN_BASED_VM_EXEC_CONTROL,
-                               PIN_BASED_EXT_INTR_MASK   /* 20.6.1 */
-                               | PIN_BASED_NMI_EXITING   /* 20.6.1 */
-                        );
-        vmcs_write32_fixedbits(MSR_IA32_VMX_PROCBASED_CTLS,
-                               CPU_BASED_VM_EXEC_CONTROL,
-                               CPU_BASED_HLT_EXITING         /* 20.6.2 */
-                               | CPU_BASED_CR8_LOAD_EXITING    /* 20.6.2 */
-                               | CPU_BASED_CR8_STORE_EXITING   /* 20.6.2 */
-                               | CPU_BASED_ACTIVATE_IO_BITMAP  /* 20.6.2 */
-                               | CPU_BASED_MOV_DR_EXITING
-                               | CPU_BASED_USE_TSC_OFFSETING   /* 21.3 */
-                        );
+        vmcs_write32(PIN_BASED_VM_EXEC_CONTROL,
+                vmcs_config.pin_based_exec_ctrl);
+
+        exec_control = vmcs_config.cpu_based_exec_ctrl;
+        if (!vm_need_tpr_shadow(vmx->vcpu.kvm)) {
+                exec_control &= ~CPU_BASED_TPR_SHADOW;
+#ifdef CONFIG_X86_64
+                exec_control |= CPU_BASED_CR8_STORE_EXITING |
+                                CPU_BASED_CR8_LOAD_EXITING;
+#endif
+        }
+        vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control);
 
         vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, 0);
         vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, 0);
@@ -1377,46 +1550,48 @@ static int vmx_vcpu_setup(struct kvm_vcpu *vcpu)
                 u32 index = vmx_msr_index[i];
                 u32 data_low, data_high;
                 u64 data;
-                int j = vcpu->nmsrs;
+                int j = vmx->nmsrs;
 
                 if (rdmsr_safe(index, &data_low, &data_high) < 0)
                         continue;
                 if (wrmsr_safe(index, data_low, data_high) < 0)
                         continue;
                 data = data_low | ((u64)data_high << 32);
-                vcpu->host_msrs[j].index = index;
-                vcpu->host_msrs[j].reserved = 0;
-                vcpu->host_msrs[j].data = data;
-                vcpu->guest_msrs[j] = vcpu->host_msrs[j];
-                ++vcpu->nmsrs;
+                vmx->host_msrs[j].index = index;
+                vmx->host_msrs[j].reserved = 0;
+                vmx->host_msrs[j].data = data;
+                vmx->guest_msrs[j] = vmx->host_msrs[j];
+                ++vmx->nmsrs;
         }
 
-        setup_msrs(vcpu);
+        setup_msrs(vmx);
 
-        vmcs_write32_fixedbits(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_CONTROLS,
-                               (HOST_IS_64 << 9));  /* 22.2,1, 20.7.1 */
+        vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl);
 
         /* 22.2.1, 20.8.1 */
-        vmcs_write32_fixedbits(MSR_IA32_VMX_ENTRY_CTLS,
-                               VM_ENTRY_CONTROLS, 0);
+        vmcs_write32(VM_ENTRY_CONTROLS, vmcs_config.vmentry_ctrl);
+
         vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0);  /* 22.2.1 */
 
 #ifdef CONFIG_X86_64
-        vmcs_writel(VIRTUAL_APIC_PAGE_ADDR, 0);
-        vmcs_writel(TPR_THRESHOLD, 0);
+        vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, 0);
+        if (vm_need_tpr_shadow(vmx->vcpu.kvm))
+                vmcs_write64(VIRTUAL_APIC_PAGE_ADDR,
+                             page_to_phys(vmx->vcpu.apic->regs_page));
+        vmcs_write32(TPR_THRESHOLD, 0);
 #endif
 
         vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL);
         vmcs_writel(CR4_GUEST_HOST_MASK, KVM_GUEST_CR4_MASK);
 
-        vcpu->cr0 = 0x60000010;
-        vmx_set_cr0(vcpu, vcpu->cr0); // enter rmode
-        vmx_set_cr4(vcpu, 0);
+        vmx->vcpu.cr0 = 0x60000010;
+        vmx_set_cr0(&vmx->vcpu, vmx->vcpu.cr0); // enter rmode
+        vmx_set_cr4(&vmx->vcpu, 0);
 #ifdef CONFIG_X86_64
-        vmx_set_efer(vcpu, 0);
+        vmx_set_efer(&vmx->vcpu, 0);
 #endif
-        vmx_fpu_activate(vcpu);
-        update_exception_bitmap(vcpu);
+        vmx_fpu_activate(&vmx->vcpu);
+        update_exception_bitmap(&vmx->vcpu);
 
         return 0;
 
@@ -1424,6 +1599,13 @@ out:
         return ret;
 }
 
+static void vmx_vcpu_reset(struct kvm_vcpu *vcpu)
+{
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+
+        vmx_vcpu_setup(vmx);
+}
+
 static void inject_rmode_irq(struct kvm_vcpu *vcpu, int irq)
 {
         u16 ent[2];
@@ -1443,8 +1625,8 @@ static void inject_rmode_irq(struct kvm_vcpu *vcpu, int irq)
                 return;
         }
 
-        if (kvm_read_guest(vcpu, irq * sizeof(ent), sizeof(ent), &ent) !=
-                                                                sizeof(ent)) {
+        if (emulator_read_std(irq * sizeof(ent), &ent, sizeof(ent), vcpu) !=
+                                                        X86EMUL_CONTINUE) {
                 vcpu_printf(vcpu, "%s: read guest err\n", __FUNCTION__);
                 return;
         }
@@ -1454,9 +1636,9 @@ static void inject_rmode_irq(struct kvm_vcpu *vcpu, int irq)
         ip =  vmcs_readl(GUEST_RIP);
 
 
-        if (kvm_write_guest(vcpu, ss_base + sp - 2, 2, &flags) != 2 ||
-            kvm_write_guest(vcpu, ss_base + sp - 4, 2, &cs) != 2 ||
-            kvm_write_guest(vcpu, ss_base + sp - 6, 2, &ip) != 2) {
+        if (emulator_write_emulated(ss_base + sp - 2, &flags, 2, vcpu) != X86EMUL_CONTINUE ||
+            emulator_write_emulated(ss_base + sp - 4, &cs, 2, vcpu) != X86EMUL_CONTINUE ||
+            emulator_write_emulated(ss_base + sp - 6, &ip, 2, vcpu) != X86EMUL_CONTINUE) {
                 vcpu_printf(vcpu, "%s: write guest err\n", __FUNCTION__);
                 return;
         }
@@ -1469,6 +1651,16 @@ static void inject_rmode_irq(struct kvm_vcpu *vcpu, int irq)
         vmcs_writel(GUEST_RSP, (vmcs_readl(GUEST_RSP) & ~0xffff) | (sp - 6));
 }
 
+static void vmx_inject_irq(struct kvm_vcpu *vcpu, int irq)
+{
+        if (vcpu->rmode.active) {
+                inject_rmode_irq(vcpu, irq);
+                return;
+        }
+        vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
+                        irq | INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
+}
+
 static void kvm_do_inject_irq(struct kvm_vcpu *vcpu)
 {
         int word_index = __ffs(vcpu->irq_summary);
@@ -1478,13 +1670,7 @@ static void kvm_do_inject_irq(struct kvm_vcpu *vcpu)
         clear_bit(bit_index, &vcpu->irq_pending[word_index]);
         if (!vcpu->irq_pending[word_index])
                 clear_bit(word_index, &vcpu->irq_summary);
-
-        if (vcpu->rmode.active) {
-                inject_rmode_irq(vcpu, irq);
-                return;
-        }
-        vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
-                        irq | INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
+        vmx_inject_irq(vcpu, irq);
 }
 
 
@@ -1568,7 +1754,7 @@ static int handle_exception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                        "intr info 0x%x\n", __FUNCTION__, vect_info, intr_info);
         }
 
-        if (is_external_interrupt(vect_info)) {
+        if (!irqchip_in_kernel(vcpu->kvm) && is_external_interrupt(vect_info)) {
                 int irq = vect_info & VECTORING_INFO_VECTOR_MASK;
                 set_bit(irq, vcpu->irq_pending);
                 set_bit(irq / BITS_PER_LONG, &vcpu->irq_summary);
@@ -1591,29 +1777,28 @@ static int handle_exception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         if (is_page_fault(intr_info)) {
                 cr2 = vmcs_readl(EXIT_QUALIFICATION);
 
-                spin_lock(&vcpu->kvm->lock);
+                mutex_lock(&vcpu->kvm->lock);
                 r = kvm_mmu_page_fault(vcpu, cr2, error_code);
                 if (r < 0) {
-                        spin_unlock(&vcpu->kvm->lock);
+                        mutex_unlock(&vcpu->kvm->lock);
                         return r;
                 }
                 if (!r) {
-                        spin_unlock(&vcpu->kvm->lock);
+                        mutex_unlock(&vcpu->kvm->lock);
                         return 1;
                 }
 
                 er = emulate_instruction(vcpu, kvm_run, cr2, error_code);
-                spin_unlock(&vcpu->kvm->lock);
+                mutex_unlock(&vcpu->kvm->lock);
 
                 switch (er) {
                 case EMULATE_DONE:
                         return 1;
                 case EMULATE_DO_MMIO:
                         ++vcpu->stat.mmio_exits;
-                        kvm_run->exit_reason = KVM_EXIT_MMIO;
                         return 0;
                  case EMULATE_FAIL:
-                        vcpu_printf(vcpu, "%s: emulate fail\n", __FUNCTION__);
+                        kvm_report_emulation_failure(vcpu, "pagetable");
                         break;
                 default:
                         BUG();
@@ -1653,80 +1838,29 @@ static int handle_triple_fault(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         return 0;
 }
 
-static int get_io_count(struct kvm_vcpu *vcpu, unsigned long *count)
-{
-        u64 inst;
-        gva_t rip;
-        int countr_size;
-        int i, n;
-
-        if ((vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_VM)) {
-                countr_size = 2;
-        } else {
-                u32 cs_ar = vmcs_read32(GUEST_CS_AR_BYTES);
-
-                countr_size = (cs_ar & AR_L_MASK) ? 8:
-                              (cs_ar & AR_DB_MASK) ? 4: 2;
-        }
-
-        rip =  vmcs_readl(GUEST_RIP);
-        if (countr_size != 8)
-                rip += vmcs_readl(GUEST_CS_BASE);
-
-        n = kvm_read_guest(vcpu, rip, sizeof(inst), &inst);
-
-        for (i = 0; i < n; i++) {
-                switch (((u8*)&inst)[i]) {
-                case 0xf0:
-                case 0xf2:
-                case 0xf3:
-                case 0x2e:
-                case 0x36:
-                case 0x3e:
-                case 0x26:
-                case 0x64:
-                case 0x65:
-                case 0x66:
-                        break;
-                case 0x67:
-                        countr_size = (countr_size == 2) ? 4: (countr_size >> 1);
-                default:
-                        goto done;
-                }
-        }
-        return 0;
-done:
-        countr_size *= 8;
-        *count = vcpu->regs[VCPU_REGS_RCX] & (~0ULL >> (64 - countr_size));
-        //printk("cx: %lx\n", vcpu->regs[VCPU_REGS_RCX]);
-        return 1;
-}
-
 static int handle_io(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification;
+        unsigned long exit_qualification;
         int size, down, in, string, rep;
         unsigned port;
-        unsigned long count;
-        gva_t address;
 
         ++vcpu->stat.io_exits;
-        exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
-        in = (exit_qualification & 8) != 0;
-        size = (exit_qualification & 7) + 1;
+        exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
         string = (exit_qualification & 16) != 0;
+
+        if (string) {
+                if (emulate_instruction(vcpu, kvm_run, 0, 0) == EMULATE_DO_MMIO)
+                        return 0;
+                return 1;
+        }
+
+        size = (exit_qualification & 7) + 1;
+        in = (exit_qualification & 8) != 0;
         down = (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_DF) != 0;
-        count = 1;
         rep = (exit_qualification & 32) != 0;
         port = exit_qualification >> 16;
-        address = 0;
-        if (string) {
-                if (rep && !get_io_count(vcpu, &count))
-                        return 1;
-                address = vmcs_readl(GUEST_LINEAR_ADDRESS);
-        }
-        return kvm_setup_pio(vcpu, kvm_run, in, size, count, string, down,
-                             address, rep, port);
+
+        return kvm_emulate_pio(vcpu, kvm_run, in, size, port);
 }
 
 static void
@@ -1743,11 +1877,11 @@ vmx_patch_hypercall(struct kvm_vcpu *vcpu, unsigned char *hypercall)
 
 static int handle_cr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification;
+        unsigned long exit_qualification;
         int cr;
         int reg;
 
-        exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
+        exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
         cr = exit_qualification & 15;
         reg = (exit_qualification >> 8) & 15;
         switch ((exit_qualification >> 4) & 3) {
@@ -1772,13 +1906,14 @@ static int handle_cr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                         vcpu_load_rsp_rip(vcpu);
                         set_cr8(vcpu, vcpu->regs[reg]);
                         skip_emulated_instruction(vcpu);
-                        return 1;
+                        kvm_run->exit_reason = KVM_EXIT_SET_TPR;
+                        return 0;
                 };
                 break;
         case 2: /* clts */
                 vcpu_load_rsp_rip(vcpu);
                 vmx_fpu_deactivate(vcpu);
-                vcpu->cr0 &= ~CR0_TS_MASK;
+                vcpu->cr0 &= ~X86_CR0_TS;
                 vmcs_writel(CR0_READ_SHADOW, vcpu->cr0);
                 vmx_fpu_activate(vcpu);
                 skip_emulated_instruction(vcpu);
@@ -1793,7 +1928,7 @@ static int handle_cr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                         return 1;
                 case 8:
                         vcpu_load_rsp_rip(vcpu);
-                        vcpu->regs[reg] = vcpu->cr8;
+                        vcpu->regs[reg] = get_cr8(vcpu);
                         vcpu_put_rsp_rip(vcpu);
                         skip_emulated_instruction(vcpu);
                         return 1;
@@ -1808,14 +1943,14 @@ static int handle_cr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 break;
         }
         kvm_run->exit_reason = 0;
-        printk(KERN_ERR "kvm: unhandled control register: op %d cr %d\n",
+        pr_unimpl(vcpu, "unhandled control register: op %d cr %d\n",
                (int)(exit_qualification >> 4) & 3, cr);
         return 0;
 }
 
 static int handle_dr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification;
+        unsigned long exit_qualification;
         unsigned long val;
         int dr, reg;
 
@@ -1823,7 +1958,7 @@ static int handle_dr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
          * FIXME: this code assumes the host is debugging the guest.
          *        need to deal with guest debugging itself too.
          */
-        exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
+        exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
         dr = exit_qualification & 7;
         reg = (exit_qualification >> 8) & 15;
         vcpu_load_rsp_rip(vcpu);
@@ -1886,19 +2021,21 @@ static int handle_wrmsr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         return 1;
 }
 
-static void post_kvm_run_save(struct kvm_vcpu *vcpu,
-                              struct kvm_run *kvm_run)
+static int handle_tpr_below_threshold(struct kvm_vcpu *vcpu,
+                                      struct kvm_run *kvm_run)
 {
-        kvm_run->if_flag = (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) != 0;
-        kvm_run->cr8 = vcpu->cr8;
-        kvm_run->apic_base = vcpu->apic_base;
-        kvm_run->ready_for_interrupt_injection = (vcpu->interrupt_window_open &&
-                                                  vcpu->irq_summary == 0);
+        return 1;
 }
 
 static int handle_interrupt_window(struct kvm_vcpu *vcpu,
                                    struct kvm_run *kvm_run)
 {
+        u32 cpu_based_vm_exec_control;
+
+        /* clear pending irq */
+        cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
+        cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING;
+        vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
         /*
          * If the user space waits to inject interrupts, exit as soon as
          * possible
@@ -1943,6 +2080,7 @@ static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu,
         [EXIT_REASON_PENDING_INTERRUPT]       = handle_interrupt_window,
         [EXIT_REASON_HLT]                     = handle_halt,
         [EXIT_REASON_VMCALL]                  = handle_vmcall,
+        [EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold
 };
 
 static const int kvm_vmx_max_exit_handlers =
@@ -1956,6 +2094,14 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 {
         u32 vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD);
         u32 exit_reason = vmcs_read32(VM_EXIT_REASON);
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+
+        if (unlikely(vmx->fail)) {
+                kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
+                kvm_run->fail_entry.hardware_entry_failure_reason
+                        = vmcs_read32(VM_INSTRUCTION_ERROR);
+                return 0;
+        }
 
         if ( (vectoring_info & VECTORING_INFO_VALID_MASK) &&
                                 exit_reason != EXIT_REASON_EXCEPTION_NMI )
@@ -1971,57 +2117,91 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
         return 0;
 }
 
-/*
- * Check if userspace requested an interrupt window, and that the
- * interrupt window is open.
- *
- * No need to exit to userspace if we already have an interrupt queued.
- */
-static int dm_request_for_irq_injection(struct kvm_vcpu *vcpu,
-                                          struct kvm_run *kvm_run)
+static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
 {
-        return (!vcpu->irq_summary &&
-                kvm_run->request_interrupt_window &&
-                vcpu->interrupt_window_open &&
-                (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF));
 }
 
-static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
+static void update_tpr_threshold(struct kvm_vcpu *vcpu)
 {
+        int max_irr, tpr;
+
+        if (!vm_need_tpr_shadow(vcpu->kvm))
+                return;
+
+        if (!kvm_lapic_enabled(vcpu) ||
+            ((max_irr = kvm_lapic_find_highest_irr(vcpu)) == -1)) {
+                vmcs_write32(TPR_THRESHOLD, 0);
+                return;
+        }
+
+        tpr = (kvm_lapic_get_cr8(vcpu) & 0x0f) << 4;
+        vmcs_write32(TPR_THRESHOLD, (max_irr > tpr) ? tpr >> 4 : max_irr >> 4);
 }
 
-static int vmx_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static void enable_irq_window(struct kvm_vcpu *vcpu)
 {
-        u8 fail;
-        int r;
+        u32 cpu_based_vm_exec_control;
 
-preempted:
-        if (vcpu->guest_debug.enabled)
-                kvm_guest_debug_pre(vcpu);
+        cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
+        cpu_based_vm_exec_control |= CPU_BASED_VIRTUAL_INTR_PENDING;
+        vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
+}
 
-again:
-        if (!vcpu->mmio_read_completed)
-                do_interrupt_requests(vcpu, kvm_run);
+static void vmx_intr_assist(struct kvm_vcpu *vcpu)
+{
+        u32 idtv_info_field, intr_info_field;
+        int has_ext_irq, interrupt_window_open;
+        int vector;
 
-        vmx_save_host_state(vcpu);
-        kvm_load_guest_fpu(vcpu);
+        kvm_inject_pending_timer_irqs(vcpu);
+        update_tpr_threshold(vcpu);
 
-        r = kvm_mmu_reload(vcpu);
-        if (unlikely(r))
-                goto out;
+        has_ext_irq = kvm_cpu_has_interrupt(vcpu);
+        intr_info_field = vmcs_read32(VM_ENTRY_INTR_INFO_FIELD);
+        idtv_info_field = vmcs_read32(IDT_VECTORING_INFO_FIELD);
+        if (intr_info_field & INTR_INFO_VALID_MASK) {
+                if (idtv_info_field & INTR_INFO_VALID_MASK) {
+                        /* TODO: fault when IDT_Vectoring */
+                        printk(KERN_ERR "Fault when IDT_Vectoring\n");
+                }
+                if (has_ext_irq)
+                        enable_irq_window(vcpu);
+                return;
+        }
+        if (unlikely(idtv_info_field & INTR_INFO_VALID_MASK)) {
+                vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, idtv_info_field);
+                vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
+                                vmcs_read32(VM_EXIT_INSTRUCTION_LEN));
+
+                if (unlikely(idtv_info_field & INTR_INFO_DELIEVER_CODE_MASK))
+                        vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE,
+                                vmcs_read32(IDT_VECTORING_ERROR_CODE));
+                if (unlikely(has_ext_irq))
+                        enable_irq_window(vcpu);
+                return;
+        }
+        if (!has_ext_irq)
+                return;
+        interrupt_window_open =
+                ((vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
+                 (vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & 3) == 0);
+        if (interrupt_window_open) {
+                vector = kvm_cpu_get_interrupt(vcpu);
+                vmx_inject_irq(vcpu, vector);
+                kvm_timer_intr_post(vcpu, vector);
+        } else
+                enable_irq_window(vcpu);
+}
+
+static void vmx_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+{
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
 
         /*
          * Loading guest fpu may have cleared host cr0.ts
          */
         vmcs_writel(HOST_CR0, read_cr0());
 
-        local_irq_disable();
-
-        vcpu->guest_mode = 1;
-        if (vcpu->requests)
-                if (test_and_clear_bit(KVM_TLB_FLUSH, &vcpu->requests))
-                    vmx_flush_tlb(vcpu);
-
         asm (
                 /* Store host registers */
 #ifdef CONFIG_X86_64
@@ -2115,8 +2295,8 @@ again:
                 "pop %%ecx; popa \n\t"
 #endif
                 "setbe %0 \n\t"
-              : "=q" (fail)
-              : "r"(vcpu->launched), "d"((unsigned long)HOST_RSP),
+              : "=q" (vmx->fail)
+              : "r"(vmx->launched), "d"((unsigned long)HOST_RSP),
                 "c"(vcpu),
                 [rax]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RAX])),
                 [rbx]"i"(offsetof(struct kvm_vcpu, regs[VCPU_REGS_RBX])),
@@ -2138,59 +2318,10 @@ again:
                 [cr2]"i"(offsetof(struct kvm_vcpu, cr2))
               : "cc", "memory" );
 
-        vcpu->guest_mode = 0;
-        local_irq_enable();
-
-        ++vcpu->stat.exits;
-
         vcpu->interrupt_window_open = (vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & 3) == 0;
 
         asm ("mov %0, %%ds; mov %0, %%es" : : "r"(__USER_DS));
-
-        if (unlikely(fail)) {
-                kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
-                kvm_run->fail_entry.hardware_entry_failure_reason
-                        = vmcs_read32(VM_INSTRUCTION_ERROR);
-                r = 0;
-                goto out;
-        }
-        /*
-         * Profile KVM exit RIPs:
-         */
-        if (unlikely(prof_on == KVM_PROFILING))
-                profile_hit(KVM_PROFILING, (void *)vmcs_readl(GUEST_RIP));
-
-        vcpu->launched = 1;
-        r = kvm_handle_exit(kvm_run, vcpu);
-        if (r > 0) {
-                /* Give scheduler a change to reschedule. */
-                if (signal_pending(current)) {
-                        r = -EINTR;
-                        kvm_run->exit_reason = KVM_EXIT_INTR;
-                        ++vcpu->stat.signal_exits;
-                        goto out;
-                }
-
-                if (dm_request_for_irq_injection(vcpu, kvm_run)) {
-                        r = -EINTR;
-                        kvm_run->exit_reason = KVM_EXIT_INTR;
-                        ++vcpu->stat.request_irq_exits;
-                        goto out;
-                }
-                if (!need_resched()) {
-                        ++vcpu->stat.light_exits;
-                        goto again;
-                }
-        }
-
-out:
-        if (r > 0) {
-                kvm_resched(vcpu);
-                goto preempted;
-        }
-
-        post_kvm_run_save(vcpu, kvm_run);
-        return r;
+        vmx->launched = 1;
 }
 
 static void vmx_inject_page_fault(struct kvm_vcpu *vcpu,
@@ -2225,67 +2356,118 @@ static void vmx_inject_page_fault(struct kvm_vcpu *vcpu,
 
 static void vmx_free_vmcs(struct kvm_vcpu *vcpu)
 {
-        if (vcpu->vmcs) {
-                on_each_cpu(__vcpu_clear, vcpu, 0, 1);
-                free_vmcs(vcpu->vmcs);
-                vcpu->vmcs = NULL;
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+
+        if (vmx->vmcs) {
+                on_each_cpu(__vcpu_clear, vmx, 0, 1);
+                free_vmcs(vmx->vmcs);
+                vmx->vmcs = NULL;
         }
 }
 
 static void vmx_free_vcpu(struct kvm_vcpu *vcpu)
 {
+        struct vcpu_vmx *vmx = to_vmx(vcpu);
+
         vmx_free_vmcs(vcpu);
+        kfree(vmx->host_msrs);
+        kfree(vmx->guest_msrs);
+        kvm_vcpu_uninit(vcpu);
+        kmem_cache_free(kvm_vcpu_cache, vmx);
 }
 
-static int vmx_create_vcpu(struct kvm_vcpu *vcpu)
+static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
 {
-        struct vmcs *vmcs;
+        int err;
+        struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
+        int cpu;
 
-        vcpu->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!vcpu->guest_msrs)
-                return -ENOMEM;
+        if (!vmx)
+                return ERR_PTR(-ENOMEM);
 
-        vcpu->host_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!vcpu->host_msrs)
-                goto out_free_guest_msrs;
+        err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
+        if (err)
+                goto free_vcpu;
 
-        vmcs = alloc_vmcs();
-        if (!vmcs)
-                goto out_free_msrs;
+        if (irqchip_in_kernel(kvm)) {
+                err = kvm_create_lapic(&vmx->vcpu);
+                if (err < 0)
+                        goto free_vcpu;
+        }
 
-        vmcs_clear(vmcs);
-        vcpu->vmcs = vmcs;
-        vcpu->launched = 0;
+        vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!vmx->guest_msrs) {
+                err = -ENOMEM;
+                goto uninit_vcpu;
+        }
 
-        return 0;
+        vmx->host_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!vmx->host_msrs)
+                goto free_guest_msrs;
 
-out_free_msrs:
-        kfree(vcpu->host_msrs);
-        vcpu->host_msrs = NULL;
+        vmx->vmcs = alloc_vmcs();
+        if (!vmx->vmcs)
+                goto free_msrs;
 
-out_free_guest_msrs:
-        kfree(vcpu->guest_msrs);
-        vcpu->guest_msrs = NULL;
+        vmcs_clear(vmx->vmcs);
 
-        return -ENOMEM;
+        cpu = get_cpu();
+        vmx_vcpu_load(&vmx->vcpu, cpu);
+        err = vmx_vcpu_setup(vmx);
+        vmx_vcpu_put(&vmx->vcpu);
+        put_cpu();
+        if (err)
+                goto free_vmcs;
+
+        return &vmx->vcpu;
+
+free_vmcs:
+        free_vmcs(vmx->vmcs);
+free_msrs:
+        kfree(vmx->host_msrs);
+free_guest_msrs:
+        kfree(vmx->guest_msrs);
+uninit_vcpu:
+        kvm_vcpu_uninit(&vmx->vcpu);
+free_vcpu:
+        kmem_cache_free(kvm_vcpu_cache, vmx);
+        return ERR_PTR(err);
+}
+
+static void __init vmx_check_processor_compat(void *rtn)
+{
+        struct vmcs_config vmcs_conf;
+
+        *(int *)rtn = 0;
+        if (setup_vmcs_config(&vmcs_conf) < 0)
+                *(int *)rtn = -EIO;
+        if (memcmp(&vmcs_config, &vmcs_conf, sizeof(struct vmcs_config)) != 0) {
+                printk(KERN_ERR "kvm: CPU %d feature inconsistency!\n",
+                                smp_processor_id());
+                *(int *)rtn = -EIO;
+        }
 }
 
-static struct kvm_arch_ops vmx_arch_ops = {
+static struct kvm_x86_ops vmx_x86_ops = {
         .cpu_has_kvm_support = cpu_has_kvm_support,
         .disabled_by_bios = vmx_disabled_by_bios,
         .hardware_setup = hardware_setup,
         .hardware_unsetup = hardware_unsetup,
+        .check_processor_compatibility = vmx_check_processor_compat,
         .hardware_enable = hardware_enable,
         .hardware_disable = hardware_disable,
 
         .vcpu_create = vmx_create_vcpu,
         .vcpu_free = vmx_free_vcpu,
+        .vcpu_reset = vmx_vcpu_reset,
 
+        .prepare_guest_switch = vmx_save_host_state,
         .vcpu_load = vmx_vcpu_load,
         .vcpu_put = vmx_vcpu_put,
         .vcpu_decache = vmx_vcpu_decache,
 
         .set_guest_debug = set_guest_debug,
+        .guest_debug_pre = kvm_guest_debug_pre,
         .get_msr = vmx_get_msr,
         .set_msr = vmx_set_msr,
         .get_segment_base = vmx_get_segment_base,
@@ -2314,9 +2496,13 @@ static struct kvm_arch_ops vmx_arch_ops = {
         .inject_gp = vmx_inject_gp,
 
         .run = vmx_vcpu_run,
+        .handle_exit = kvm_handle_exit,
         .skip_emulated_instruction = skip_emulated_instruction,
-        .vcpu_setup = vmx_vcpu_setup,
         .patch_hypercall = vmx_patch_hypercall,
+        .get_irq = vmx_get_irq,
+        .set_irq = vmx_inject_irq,
+        .inject_pending_irq = vmx_intr_assist,
+        .inject_pending_vectors = do_interrupt_requests,
 };
 
 static int __init vmx_init(void)
@@ -2347,7 +2533,7 @@ static int __init vmx_init(void)
         memset(iova, 0xff, PAGE_SIZE);
         kunmap(vmx_io_bitmap_b);
 
-        r = kvm_init_arch(&vmx_arch_ops, THIS_MODULE);
+        r = kvm_init_x86(&vmx_x86_ops, sizeof(struct vcpu_vmx), THIS_MODULE);
         if (r)
                 goto out1;
 
@@ -2365,7 +2551,7 @@ static void __exit vmx_exit(void)
         __free_page(vmx_io_bitmap_b);
         __free_page(vmx_io_bitmap_a);
 
-        kvm_exit_arch();
+        kvm_exit_x86();
 }
 
 module_init(vmx_init)
diff --git a/drivers/kvm/vmx.h b/drivers/kvm/vmx.h
index d0dc93df41..fd4e146660 100644
--- a/drivers/kvm/vmx.h
+++ b/drivers/kvm/vmx.h
@@ -25,29 +25,36 @@
  *
  */
 
-#define CPU_BASED_VIRTUAL_INTR_PENDING  0x00000004
-#define CPU_BASED_USE_TSC_OFFSETING     0x00000008
-#define CPU_BASED_HLT_EXITING           0x00000080
-#define CPU_BASED_INVDPG_EXITING        0x00000200
-#define CPU_BASED_MWAIT_EXITING         0x00000400
-#define CPU_BASED_RDPMC_EXITING         0x00000800
-#define CPU_BASED_RDTSC_EXITING         0x00001000
-#define CPU_BASED_CR8_LOAD_EXITING      0x00080000
-#define CPU_BASED_CR8_STORE_EXITING     0x00100000
-#define CPU_BASED_TPR_SHADOW            0x00200000
-#define CPU_BASED_MOV_DR_EXITING        0x00800000
-#define CPU_BASED_UNCOND_IO_EXITING     0x01000000
-#define CPU_BASED_ACTIVATE_IO_BITMAP    0x02000000
-#define CPU_BASED_MSR_BITMAPS           0x10000000
-#define CPU_BASED_MONITOR_EXITING       0x20000000
-#define CPU_BASED_PAUSE_EXITING         0x40000000
+#define CPU_BASED_VIRTUAL_INTR_PENDING          0x00000004
+#define CPU_BASED_USE_TSC_OFFSETING             0x00000008
+#define CPU_BASED_HLT_EXITING                   0x00000080
+#define CPU_BASED_INVLPG_EXITING                0x00000200
+#define CPU_BASED_MWAIT_EXITING                 0x00000400
+#define CPU_BASED_RDPMC_EXITING                 0x00000800
+#define CPU_BASED_RDTSC_EXITING                 0x00001000
+#define CPU_BASED_CR8_LOAD_EXITING              0x00080000
+#define CPU_BASED_CR8_STORE_EXITING             0x00100000
+#define CPU_BASED_TPR_SHADOW                    0x00200000
+#define CPU_BASED_MOV_DR_EXITING                0x00800000
+#define CPU_BASED_UNCOND_IO_EXITING             0x01000000
+#define CPU_BASED_USE_IO_BITMAPS                0x02000000
+#define CPU_BASED_USE_MSR_BITMAPS               0x10000000
+#define CPU_BASED_MONITOR_EXITING               0x20000000
+#define CPU_BASED_PAUSE_EXITING                 0x40000000
+#define CPU_BASED_ACTIVATE_SECONDARY_CONTROLS   0x80000000
 
-#define PIN_BASED_EXT_INTR_MASK 0x1
-#define PIN_BASED_NMI_EXITING   0x8
+#define PIN_BASED_EXT_INTR_MASK                 0x00000001
+#define PIN_BASED_NMI_EXITING                   0x00000008
+#define PIN_BASED_VIRTUAL_NMIS                  0x00000020
 
-#define VM_EXIT_ACK_INTR_ON_EXIT        0x00008000
-#define VM_EXIT_HOST_ADD_SPACE_SIZE     0x00000200
+#define VM_EXIT_HOST_ADDR_SPACE_SIZE            0x00000200
+#define VM_EXIT_ACK_INTR_ON_EXIT                0x00008000
 
+#define VM_ENTRY_IA32E_MODE                     0x00000200
+#define VM_ENTRY_SMM                            0x00000400
+#define VM_ENTRY_DEACT_DUAL_MONITOR             0x00000800
+
+#define SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES 0x00000001
 
 /* VMCS Encodings */
 enum vmcs_field {
@@ -206,6 +213,7 @@ enum vmcs_field {
 #define EXIT_REASON_MSR_READ            31
 #define EXIT_REASON_MSR_WRITE           32
 #define EXIT_REASON_MWAIT_INSTRUCTION   36
+#define EXIT_REASON_TPR_BELOW_THRESHOLD 43
 
 /*
  * Interruption-information format
@@ -261,9 +269,6 @@ enum vmcs_field {
 /* segment AR */
 #define SEGMENT_AR_L_MASK (1 << 13)
 
-/* entry controls */
-#define VM_ENTRY_CONTROLS_IA32E_MASK (1 << 9)
-
 #define AR_TYPE_ACCESSES_MASK 1
 #define AR_TYPE_READABLE_MASK (1 << 1)
 #define AR_TYPE_WRITEABLE_MASK (1 << 2)
@@ -285,13 +290,21 @@ enum vmcs_field {
 
 #define AR_RESERVD_MASK 0xfffe0f00
 
-#define CR4_VMXE 0x2000
+#define MSR_IA32_VMX_BASIC                      0x480
+#define MSR_IA32_VMX_PINBASED_CTLS              0x481
+#define MSR_IA32_VMX_PROCBASED_CTLS             0x482
+#define MSR_IA32_VMX_EXIT_CTLS                  0x483
+#define MSR_IA32_VMX_ENTRY_CTLS                 0x484
+#define MSR_IA32_VMX_MISC                       0x485
+#define MSR_IA32_VMX_CR0_FIXED0                 0x486
+#define MSR_IA32_VMX_CR0_FIXED1                 0x487
+#define MSR_IA32_VMX_CR4_FIXED0                 0x488
+#define MSR_IA32_VMX_CR4_FIXED1                 0x489
+#define MSR_IA32_VMX_VMCS_ENUM                  0x48a
+#define MSR_IA32_VMX_PROCBASED_CTLS2            0x48b
 
-#define MSR_IA32_VMX_BASIC              0x480
-#define MSR_IA32_FEATURE_CONTROL                0x03a
-#define MSR_IA32_VMX_PINBASED_CTLS              0x481
-#define MSR_IA32_VMX_PROCBASED_CTLS             0x482
-#define MSR_IA32_VMX_EXIT_CTLS          0x483
-#define MSR_IA32_VMX_ENTRY_CTLS         0x484
+#define MSR_IA32_FEATURE_CONTROL                0x3a
+#define MSR_IA32_FEATURE_CONTROL_LOCKED         0x1
+#define MSR_IA32_FEATURE_CONTROL_VMXON_ENABLED  0x4
 
 #endif
diff --git a/drivers/kvm/x86_emulate.c b/drivers/kvm/x86_emulate.c
index 4b8a0cc966..9737c3b2f4 100644
--- a/drivers/kvm/x86_emulate.c
+++ b/drivers/kvm/x86_emulate.c
@@ -6,7 +6,7 @@
  * Copyright (c) 2005 Keir Fraser
  *
  * Linux coding style, mod r/m decoder, segment base fixes, real-mode
- * privieged instructions:
+ * privileged instructions:
  *
  * Copyright (C) 2006 Qumranet
  *
@@ -83,7 +83,7 @@ static u8 opcode_table[256] = {
         /* 0x20 - 0x27 */
         ByteOp | DstMem | SrcReg | ModRM, DstMem | SrcReg | ModRM,
         ByteOp | DstReg | SrcMem | ModRM, DstReg | SrcMem | ModRM,
-        0, 0, 0, 0,
+        SrcImmByte, SrcImm, 0, 0,
         /* 0x28 - 0x2F */
         ByteOp | DstMem | SrcReg | ModRM, DstMem | SrcReg | ModRM,
         ByteOp | DstReg | SrcMem | ModRM, DstReg | SrcMem | ModRM,
@@ -99,15 +99,24 @@ static u8 opcode_table[256] = {
         /* 0x40 - 0x4F */
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0x50 - 0x57 */
-        0, 0, 0, 0, 0, 0, 0, 0,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
         /* 0x58 - 0x5F */
         ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
         ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        /* 0x60 - 0x6F */
+        /* 0x60 - 0x67 */
         0, 0, 0, DstReg | SrcMem32 | ModRM | Mov /* movsxd (x86/64) */ ,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        /* 0x70 - 0x7F */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0,
+        /* 0x68 - 0x6F */
+        0, 0, ImplicitOps|Mov, 0,
+        SrcNone  | ByteOp  | ImplicitOps, SrcNone  | ImplicitOps, /* insb, insw/insd */
+        SrcNone  | ByteOp  | ImplicitOps, SrcNone  | ImplicitOps, /* outsb, outsw/outsd */
+        /* 0x70 - 0x77 */
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        /* 0x78 - 0x7F */
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
         /* 0x80 - 0x87 */
         ByteOp | DstMem | SrcImm | ModRM, DstMem | SrcImm | ModRM,
         ByteOp | DstMem | SrcImm | ModRM, DstMem | SrcImmByte | ModRM,
@@ -116,9 +125,9 @@ static u8 opcode_table[256] = {
         /* 0x88 - 0x8F */
         ByteOp | DstMem | SrcReg | ModRM | Mov, DstMem | SrcReg | ModRM | Mov,
         ByteOp | DstReg | SrcMem | ModRM | Mov, DstReg | SrcMem | ModRM | Mov,
-        0, 0, 0, DstMem | SrcNone | ModRM | Mov,
+        0, ModRM | DstReg, 0, DstMem | SrcNone | ModRM | Mov,
         /* 0x90 - 0x9F */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ImplicitOps, ImplicitOps, 0, 0,
         /* 0xA0 - 0xA7 */
         ByteOp | DstReg | SrcMem | Mov, DstReg | SrcMem | Mov,
         ByteOp | DstMem | SrcReg | Mov, DstMem | SrcReg | Mov,
@@ -142,8 +151,10 @@ static u8 opcode_table[256] = {
         0, 0, 0, 0,
         /* 0xD8 - 0xDF */
         0, 0, 0, 0, 0, 0, 0, 0,
-        /* 0xE0 - 0xEF */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        /* 0xE0 - 0xE7 */
+        0, 0, 0, 0, 0, 0, 0, 0,
+        /* 0xE8 - 0xEF */
+        ImplicitOps, SrcImm|ImplicitOps, 0, SrcImmByte|ImplicitOps, 0, 0, 0, 0,
         /* 0xF0 - 0xF7 */
         0, 0, 0, 0,
         ImplicitOps, 0,
@@ -181,7 +192,10 @@ static u16 twobyte_table[256] = {
         /* 0x70 - 0x7F */
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0x80 - 0x8F */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
         /* 0x90 - 0x9F */
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0xA0 - 0xA7 */
@@ -207,19 +221,6 @@ static u16 twobyte_table[256] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
-/*
- * Tell the emulator that of the Group 7 instructions (sgdt, lidt, etc.) we
- * are interested only in invlpg and not in any of the rest.
- *
- * invlpg is a special instruction in that the data it references may not
- * be mapped.
- */
-void kvm_emulator_want_group7_invlpg(void)
-{
-        twobyte_table[1] &= ~SrcMem;
-}
-EXPORT_SYMBOL_GPL(kvm_emulator_want_group7_invlpg);
-
 /* Type, address-of, and value of an instruction's operand. */
 struct operand {
         enum { OP_REG, OP_MEM, OP_IMM } type;
@@ -420,7 +421,7 @@ struct operand {
 #define insn_fetch(_type, _size, _eip)                                  \
 ({      unsigned long _x;                                               \
         rc = ops->read_std((unsigned long)(_eip) + ctxt->cs_base, &_x,  \
-                                                  (_size), ctxt);       \
+                                                  (_size), ctxt->vcpu); \
         if ( rc != 0 )                                                  \
                 goto done;                                              \
         (_eip) += (_size);                                              \
@@ -428,10 +429,11 @@ struct operand {
 })
 
 /* Access/update address held in a register, based on addressing mode. */
+#define address_mask(reg)                                               \
+        ((ad_bytes == sizeof(unsigned long)) ?                          \
+                (reg) : ((reg) & ((1UL << (ad_bytes << 3)) - 1)))
 #define register_address(base, reg)                                     \
-        ((base) + ((ad_bytes == sizeof(unsigned long)) ? (reg) :        \
-                   ((reg) & ((1UL << (ad_bytes << 3)) - 1))))
-
+        ((base) + address_mask(reg))
 #define register_address_increment(reg, inc)                            \
         do {                                                            \
                 /* signed type ensures sign extension to long */        \
@@ -443,8 +445,19 @@ struct operand {
                            (((reg) + _inc) & ((1UL << (ad_bytes << 3)) - 1)); \
         } while (0)
 
-void *decode_register(u8 modrm_reg, unsigned long *regs,
-                      int highbyte_regs)
+#define JMP_REL(rel)                                                    \
+        do {                                                            \
+                _eip += (int)(rel);                                     \
+                _eip = ((op_bytes == 2) ? (uint16_t)_eip : (uint32_t)_eip); \
+        } while (0)
+
+/*
+ * Given the 'reg' portion of a ModRM byte, and a register block, return a
+ * pointer into the block that addresses the relevant register.
+ * @highbyte_regs specifies whether to decode AH,CH,DH,BH.
+ */
+static void *decode_register(u8 modrm_reg, unsigned long *regs,
+                             int highbyte_regs)
 {
         void *p;
 
@@ -464,13 +477,50 @@ static int read_descriptor(struct x86_emulate_ctxt *ctxt,
         if (op_bytes == 2)
                 op_bytes = 3;
         *address = 0;
-        rc = ops->read_std((unsigned long)ptr, (unsigned long *)size, 2, ctxt);
+        rc = ops->read_std((unsigned long)ptr, (unsigned long *)size, 2,
+                           ctxt->vcpu);
         if (rc)
                 return rc;
-        rc = ops->read_std((unsigned long)ptr + 2, address, op_bytes, ctxt);
+        rc = ops->read_std((unsigned long)ptr + 2, address, op_bytes,
+                           ctxt->vcpu);
         return rc;
 }
 
+static int test_cc(unsigned int condition, unsigned int flags)
+{
+        int rc = 0;
+
+        switch ((condition & 15) >> 1) {
+        case 0: /* o */
+                rc |= (flags & EFLG_OF);
+                break;
+        case 1: /* b/c/nae */
+                rc |= (flags & EFLG_CF);
+                break;
+        case 2: /* z/e */
+                rc |= (flags & EFLG_ZF);
+                break;
+        case 3: /* be/na */
+                rc |= (flags & (EFLG_CF|EFLG_ZF));
+                break;
+        case 4: /* s */
+                rc |= (flags & EFLG_SF);
+                break;
+        case 5: /* p/pe */
+                rc |= (flags & EFLG_PF);
+                break;
+        case 7: /* le/ng */
+                rc |= (flags & EFLG_ZF);
+                /* fall through */
+        case 6: /* l/nge */
+                rc |= (!(flags & EFLG_SF) != !(flags & EFLG_OF));
+                break;
+        }
+
+        /* Odd condition identifiers (lsb == 1) have inverted sense. */
+        return (!!rc ^ (condition & 1));
+}
+
 int
 x86_emulate_memop(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
 {
@@ -771,11 +821,15 @@ done_prefixes:
                 goto srcmem_common;
         case SrcMem:
                 src.bytes = (d & ByteOp) ? 1 : op_bytes;
+                /* Don't fetch the address for invlpg: it could be unmapped. */
+                if (twobyte && b == 0x01 && modrm_reg == 7)
+                        break;
               srcmem_common:
                 src.type = OP_MEM;
                 src.ptr = (unsigned long *)cr2;
+                src.val = 0;
                 if ((rc = ops->read_emulated((unsigned long)src.ptr,
-                                             &src.val, src.bytes, ctxt)) != 0)
+                                             &src.val, src.bytes, ctxt->vcpu)) != 0)
                         goto done;
                 src.orig_val = src.val;
                 break;
@@ -814,7 +868,7 @@ done_prefixes:
         case DstReg:
                 dst.type = OP_REG;
                 if ((d & ByteOp)
-                    && !(twobyte_table && (b == 0xb6 || b == 0xb7))) {
+                    && !(twobyte && (b == 0xb6 || b == 0xb7))) {
                         dst.ptr = decode_register(modrm_reg, _regs,
                                                   (rex_prefix == 0));
                         dst.val = *(u8 *) dst.ptr;
@@ -838,6 +892,7 @@ done_prefixes:
                 dst.type = OP_MEM;
                 dst.ptr = (unsigned long *)cr2;
                 dst.bytes = (d & ByteOp) ? 1 : op_bytes;
+                dst.val = 0;
                 if (d & BitOp) {
                         unsigned long mask = ~(dst.bytes * 8 - 1);
 
@@ -845,7 +900,7 @@ done_prefixes:
                 }
                 if (!(d & Mov) && /* optimisation - avoid slow emulated read */
                     ((rc = ops->read_emulated((unsigned long)dst.ptr,
-                                              &dst.val, dst.bytes, ctxt)) != 0))
+                                              &dst.val, dst.bytes, ctxt->vcpu)) != 0))
                         goto done;
                 break;
         }
@@ -871,10 +926,27 @@ done_prefixes:
               sbb:              /* sbb */
                 emulate_2op_SrcV("sbb", src, dst, _eflags);
                 break;
-        case 0x20 ... 0x25:
+        case 0x20 ... 0x23:
               and:              /* and */
                 emulate_2op_SrcV("and", src, dst, _eflags);
                 break;
+        case 0x24:              /* and al imm8 */
+                dst.type = OP_REG;
+                dst.ptr = &_regs[VCPU_REGS_RAX];
+                dst.val = *(u8 *)dst.ptr;
+                dst.bytes = 1;
+                dst.orig_val = dst.val;
+                goto and;
+        case 0x25:              /* and ax imm16, or eax imm32 */
+                dst.type = OP_REG;
+                dst.bytes = op_bytes;
+                dst.ptr = &_regs[VCPU_REGS_RAX];
+                if (op_bytes == 2)
+                        dst.val = *(u16 *)dst.ptr;
+                else
+                        dst.val = *(u32 *)dst.ptr;
+                dst.orig_val = dst.val;
+                goto and;
         case 0x28 ... 0x2d:
               sub:              /* sub */
                 emulate_2op_SrcV("sub", src, dst, _eflags);
@@ -892,6 +964,17 @@ done_prefixes:
                         goto cannot_emulate;
                 dst.val = (s32) src.val;
                 break;
+        case 0x6a: /* push imm8 */
+                src.val = 0L;
+                src.val = insn_fetch(s8, 1, _eip);
+push:
+                dst.type  = OP_MEM;
+                dst.bytes = op_bytes;
+                dst.val = src.val;
+                register_address_increment(_regs[VCPU_REGS_RSP], -op_bytes);
+                dst.ptr = (void *) register_address(ctxt->ss_base,
+                                                        _regs[VCPU_REGS_RSP]);
+                break;
         case 0x80 ... 0x83:     /* Grp1 */
                 switch (modrm_reg) {
                 case 0:
@@ -939,18 +1022,10 @@ done_prefixes:
                 dst.val = src.val;
                 lock_prefix = 1;
                 break;
-        case 0xa0 ... 0xa1:     /* mov */
-                dst.ptr = (unsigned long *)&_regs[VCPU_REGS_RAX];
-                dst.val = src.val;
-                _eip += ad_bytes;       /* skip src displacement */
-                break;
-        case 0xa2 ... 0xa3:     /* mov */
-                dst.val = (unsigned long)_regs[VCPU_REGS_RAX];
-                _eip += ad_bytes;       /* skip dst displacement */
-                break;
         case 0x88 ... 0x8b:     /* mov */
-        case 0xc6 ... 0xc7:     /* mov (sole member of Grp11) */
-                dst.val = src.val;
+                goto mov;
+        case 0x8d: /* lea r16/r32, m */
+                dst.val = modrm_val;
                 break;
         case 0x8f:              /* pop (sole member of Grp1a) */
                 /* 64-bit mode: POP always pops a 64-bit operand. */
@@ -958,10 +1033,19 @@ done_prefixes:
                         dst.bytes = 8;
                 if ((rc = ops->read_std(register_address(ctxt->ss_base,
                                                          _regs[VCPU_REGS_RSP]),
-                                        &dst.val, dst.bytes, ctxt)) != 0)
+                                        &dst.val, dst.bytes, ctxt->vcpu)) != 0)
                         goto done;
                 register_address_increment(_regs[VCPU_REGS_RSP], dst.bytes);
                 break;
+        case 0xa0 ... 0xa1:     /* mov */
+                dst.ptr = (unsigned long *)&_regs[VCPU_REGS_RAX];
+                dst.val = src.val;
+                _eip += ad_bytes;       /* skip src displacement */
+                break;
+        case 0xa2 ... 0xa3:     /* mov */
+                dst.val = (unsigned long)_regs[VCPU_REGS_RAX];
+                _eip += ad_bytes;       /* skip dst displacement */
+                break;
         case 0xc0 ... 0xc1:
               grp2:             /* Grp2 */
                 switch (modrm_reg) {
@@ -989,12 +1073,41 @@ done_prefixes:
                         break;
                 }
                 break;
+        case 0xc6 ... 0xc7:     /* mov (sole member of Grp11) */
+        mov:
+                dst.val = src.val;
+                break;
         case 0xd0 ... 0xd1:     /* Grp2 */
                 src.val = 1;
                 goto grp2;
         case 0xd2 ... 0xd3:     /* Grp2 */
                 src.val = _regs[VCPU_REGS_RCX];
                 goto grp2;
+        case 0xe8: /* call (near) */ {
+                long int rel;
+                switch (op_bytes) {
+                case 2:
+                        rel = insn_fetch(s16, 2, _eip);
+                        break;
+                case 4:
+                        rel = insn_fetch(s32, 4, _eip);
+                        break;
+                case 8:
+                        rel = insn_fetch(s64, 8, _eip);
+                        break;
+                default:
+                        DPRINTF("Call: Invalid op_bytes\n");
+                        goto cannot_emulate;
+                }
+                src.val = (unsigned long) _eip;
+                JMP_REL(rel);
+                goto push;
+        }
+        case 0xe9: /* jmp rel */
+        case 0xeb: /* jmp rel short */
+                JMP_REL(src.val);
+                no_wb = 1; /* Disable writeback. */
+                break;
         case 0xf6 ... 0xf7:     /* Grp3 */
                 switch (modrm_reg) {
                 case 0 ... 1:   /* test */
@@ -1037,13 +1150,19 @@ done_prefixes:
                 case 1: /* dec */
                         emulate_1op("dec", dst, _eflags);
                         break;
+                case 4: /* jmp abs */
+                        if (b == 0xff)
+                                _eip = dst.val;
+                        else
+                                goto cannot_emulate;
+                        break;
                 case 6: /* push */
                         /* 64-bit mode: PUSH always pushes a 64-bit operand. */
                         if (mode == X86EMUL_MODE_PROT64) {
                                 dst.bytes = 8;
                                 if ((rc = ops->read_std((unsigned long)dst.ptr,
                                                         &dst.val, 8,
-                                                        ctxt)) != 0)
+                                                        ctxt->vcpu)) != 0)
                                         goto done;
                         }
                         register_address_increment(_regs[VCPU_REGS_RSP],
@@ -1051,7 +1170,7 @@ done_prefixes:
                         if ((rc = ops->write_std(
                                      register_address(ctxt->ss_base,
                                                       _regs[VCPU_REGS_RSP]),
-                                     &dst.val, dst.bytes, ctxt)) != 0)
+                                     &dst.val, dst.bytes, ctxt->vcpu)) != 0)
                                 goto done;
                         no_wb = 1;
                         break;
@@ -1086,11 +1205,11 @@ writeback:
                                 rc = ops->cmpxchg_emulated((unsigned long)dst.
                                                            ptr, &dst.orig_val,
                                                            &dst.val, dst.bytes,
-                                                           ctxt);
+                                                           ctxt->vcpu);
                         else
                                 rc = ops->write_emulated((unsigned long)dst.ptr,
                                                          &dst.val, dst.bytes,
-                                                         ctxt);
+                                                         ctxt->vcpu);
                         if (rc != 0)
                                 goto done;
                 default:
@@ -1109,6 +1228,81 @@ done:
 special_insn:
         if (twobyte)
                 goto twobyte_special_insn;
+        switch(b) {
+        case 0x50 ... 0x57:  /* push reg */
+                if (op_bytes == 2)
+                        src.val = (u16) _regs[b & 0x7];
+                else
+                        src.val = (u32) _regs[b & 0x7];
+                dst.type  = OP_MEM;
+                dst.bytes = op_bytes;
+                dst.val = src.val;
+                register_address_increment(_regs[VCPU_REGS_RSP], -op_bytes);
+                dst.ptr = (void *) register_address(
+                        ctxt->ss_base, _regs[VCPU_REGS_RSP]);
+                break;
+        case 0x58 ... 0x5f: /* pop reg */
+                dst.ptr = (unsigned long *)&_regs[b & 0x7];
+        pop_instruction:
+                if ((rc = ops->read_std(register_address(ctxt->ss_base,
+                        _regs[VCPU_REGS_RSP]), dst.ptr, op_bytes, ctxt->vcpu))
+                        != 0)
+                        goto done;
+
+                register_address_increment(_regs[VCPU_REGS_RSP], op_bytes);
+                no_wb = 1; /* Disable writeback. */
+                break;
+        case 0x6c:              /* insb */
+        case 0x6d:              /* insw/insd */
+                 if (kvm_emulate_pio_string(ctxt->vcpu, NULL,
+                                1,                                      /* in */
+                                (d & ByteOp) ? 1 : op_bytes,            /* size */
+                                rep_prefix ?
+                                address_mask(_regs[VCPU_REGS_RCX]) : 1, /* count */
+                                (_eflags & EFLG_DF),                    /* down */
+                                register_address(ctxt->es_base,
+                                                 _regs[VCPU_REGS_RDI]), /* address */
+                                rep_prefix,
+                                _regs[VCPU_REGS_RDX]                    /* port */
+                                ) == 0)
+                        return -1;
+                return 0;
+        case 0x6e:              /* outsb */
+        case 0x6f:              /* outsw/outsd */
+                if (kvm_emulate_pio_string(ctxt->vcpu, NULL,
+                                0,                                      /* in */
+                                (d & ByteOp) ? 1 : op_bytes,            /* size */
+                                rep_prefix ?
+                                address_mask(_regs[VCPU_REGS_RCX]) : 1, /* count */
+                                (_eflags & EFLG_DF),                    /* down */
+                                register_address(override_base ?
+                                                 *override_base : ctxt->ds_base,
+                                                 _regs[VCPU_REGS_RSI]), /* address */
+                                rep_prefix,
+                                _regs[VCPU_REGS_RDX]                    /* port */
+                                ) == 0)
+                        return -1;
+                return 0;
+        case 0x70 ... 0x7f: /* jcc (short) */ {
+                int rel = insn_fetch(s8, 1, _eip);
+
+                if (test_cc(b, _eflags))
+                JMP_REL(rel);
+                break;
+        }
+        case 0x9c: /* pushf */
+                src.val =  (unsigned long) _eflags;
+                goto push;
+        case 0x9d: /* popf */
+                dst.ptr = (unsigned long *) &_eflags;
+                goto pop_instruction;
+        case 0xc3: /* ret */
+                dst.ptr = &_eip;
+                goto pop_instruction;
+        case 0xf4:              /* hlt */
+                ctxt->vcpu->halt_request = 1;
+                goto done;
+        }
         if (rep_prefix) {
                 if (_regs[VCPU_REGS_RCX] == 0) {
                         ctxt->vcpu->rip = _eip;
@@ -1125,7 +1319,7 @@ special_insn:
                                                         _regs[VCPU_REGS_RDI]);
                 if ((rc = ops->read_emulated(register_address(
                       override_base ? *override_base : ctxt->ds_base,
-                      _regs[VCPU_REGS_RSI]), &dst.val, dst.bytes, ctxt)) != 0)
+                      _regs[VCPU_REGS_RSI]), &dst.val, dst.bytes, ctxt->vcpu)) != 0)
                         goto done;
                 register_address_increment(_regs[VCPU_REGS_RSI],
                              (_eflags & EFLG_DF) ? -dst.bytes : dst.bytes);
@@ -1147,7 +1341,8 @@ special_insn:
                 dst.type = OP_REG;
                 dst.bytes = (d & ByteOp) ? 1 : op_bytes;
                 dst.ptr = (unsigned long *)&_regs[VCPU_REGS_RAX];
-                if ((rc = ops->read_emulated(cr2, &dst.val, dst.bytes, ctxt)) != 0)
+                if ((rc = ops->read_emulated(cr2, &dst.val, dst.bytes,
+                                             ctxt->vcpu)) != 0)
                         goto done;
                 register_address_increment(_regs[VCPU_REGS_RSI],
                            (_eflags & EFLG_DF) ? -dst.bytes : dst.bytes);
@@ -1155,23 +1350,7 @@ special_insn:
         case 0xae ... 0xaf:     /* scas */
                 DPRINTF("Urk! I don't handle SCAS.\n");
                 goto cannot_emulate;
-        case 0xf4:              /* hlt */
-                ctxt->vcpu->halt_request = 1;
-                goto done;
-        case 0xc3: /* ret */
-                dst.ptr = &_eip;
-                goto pop_instruction;
-        case 0x58 ... 0x5f: /* pop reg */
-                dst.ptr = (unsigned long *)&_regs[b & 0x7];
 
-pop_instruction:
-                if ((rc = ops->read_std(register_address(ctxt->ss_base,
-                        _regs[VCPU_REGS_RSP]), dst.ptr, op_bytes, ctxt)) != 0)
-                        goto done;
-
-                register_address_increment(_regs[VCPU_REGS_RSP], op_bytes);
-                no_wb = 1; /* Disable writeback. */
-                break;
         }
         goto writeback;
 
@@ -1230,40 +1409,50 @@ twobyte_insn:
                 break;
         case 0x40 ... 0x4f:     /* cmov */
                 dst.val = dst.orig_val = src.val;
-                d &= ~Mov;      /* default to no move */
+                no_wb = 1;
                 /*
                  * First, assume we're decoding an even cmov opcode
                  * (lsb == 0).
                  */
                 switch ((b & 15) >> 1) {
                 case 0: /* cmovo */
-                        d |= (_eflags & EFLG_OF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_OF) ? 0 : 1;
                         break;
                 case 1: /* cmovb/cmovc/cmovnae */
-                        d |= (_eflags & EFLG_CF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_CF) ? 0 : 1;
                         break;
                 case 2: /* cmovz/cmove */
-                        d |= (_eflags & EFLG_ZF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_ZF) ? 0 : 1;
                         break;
                 case 3: /* cmovbe/cmovna */
-                        d |= (_eflags & (EFLG_CF | EFLG_ZF)) ? Mov : 0;
+                        no_wb = (_eflags & (EFLG_CF | EFLG_ZF)) ? 0 : 1;
                         break;
                 case 4: /* cmovs */
-                        d |= (_eflags & EFLG_SF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_SF) ? 0 : 1;
                         break;
                 case 5: /* cmovp/cmovpe */
-                        d |= (_eflags & EFLG_PF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_PF) ? 0 : 1;
                         break;
                 case 7: /* cmovle/cmovng */
-                        d |= (_eflags & EFLG_ZF) ? Mov : 0;
+                        no_wb = (_eflags & EFLG_ZF) ? 0 : 1;
                         /* fall through */
                 case 6: /* cmovl/cmovnge */
-                        d |= (!(_eflags & EFLG_SF) !=
-                              !(_eflags & EFLG_OF)) ? Mov : 0;
+                        no_wb &= (!(_eflags & EFLG_SF) !=
+                              !(_eflags & EFLG_OF)) ? 0 : 1;
                         break;
                 }
                 /* Odd cmov opcodes (lsb == 1) have inverted sense. */
-                d ^= (b & 1) ? Mov : 0;
+                no_wb ^= b & 1;
+                break;
+        case 0xa3:
+              bt:               /* bt */
+                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
+                emulate_2op_SrcV_nobyte("bt", src, dst, _eflags);
+                break;
+        case 0xab:
+              bts:              /* bts */
+                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
+                emulate_2op_SrcV_nobyte("bts", src, dst, _eflags);
                 break;
         case 0xb0 ... 0xb1:     /* cmpxchg */
                 /*
@@ -1273,8 +1462,6 @@ twobyte_insn:
                 src.orig_val = src.val;
                 src.val = _regs[VCPU_REGS_RAX];
                 emulate_2op_SrcV("cmp", src, dst, _eflags);
-                /* Always write back. The question is: where to? */
-                d |= Mov;
                 if (_eflags & EFLG_ZF) {
                         /* Success: write back to memory. */
                         dst.val = src.orig_val;
@@ -1284,30 +1471,15 @@ twobyte_insn:
                         dst.ptr = (unsigned long *)&_regs[VCPU_REGS_RAX];
                 }
                 break;
-        case 0xa3:
-              bt:               /* bt */
-                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
-                emulate_2op_SrcV_nobyte("bt", src, dst, _eflags);
-                break;
         case 0xb3:
               btr:              /* btr */
                 src.val &= (dst.bytes << 3) - 1; /* only subword offset */
                 emulate_2op_SrcV_nobyte("btr", src, dst, _eflags);
                 break;
-        case 0xab:
-              bts:              /* bts */
-                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
-                emulate_2op_SrcV_nobyte("bts", src, dst, _eflags);
-                break;
         case 0xb6 ... 0xb7:     /* movzx */
                 dst.bytes = op_bytes;
                 dst.val = (d & ByteOp) ? (u8) src.val : (u16) src.val;
                 break;
-        case 0xbb:
-              btc:              /* btc */
-                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
-                emulate_2op_SrcV_nobyte("btc", src, dst, _eflags);
-                break;
         case 0xba:              /* Grp8 */
                 switch (modrm_reg & 3) {
                 case 0:
@@ -1320,6 +1492,11 @@ twobyte_insn:
                         goto btc;
                 }
                 break;
+        case 0xbb:
+              btc:              /* btc */
+                src.val &= (dst.bytes << 3) - 1; /* only subword offset */
+                emulate_2op_SrcV_nobyte("btc", src, dst, _eflags);
+                break;
         case 0xbe ... 0xbf:     /* movsx */
                 dst.bytes = op_bytes;
                 dst.val = (d & ByteOp) ? (s8) src.val : (s16) src.val;
@@ -1331,14 +1508,14 @@ twobyte_special_insn:
         /* Disable writeback. */
         no_wb = 1;
         switch (b) {
+        case 0x06:
+                emulate_clts(ctxt->vcpu);
+                break;
         case 0x09:              /* wbinvd */
                 break;
         case 0x0d:              /* GrpP (prefetch) */
         case 0x18:              /* Grp16 (prefetch/nop) */
                 break;
-        case 0x06:
-                emulate_clts(ctxt->vcpu);
-                break;
         case 0x20: /* mov cr, reg */
                 if (modrm_mod != 3)
                         goto cannot_emulate;
@@ -1355,7 +1532,7 @@ twobyte_special_insn:
                         | ((u64)_regs[VCPU_REGS_RDX] << 32);
                 rc = kvm_set_msr(ctxt->vcpu, _regs[VCPU_REGS_RCX], msr_data);
                 if (rc) {
-                        kvm_arch_ops->inject_gp(ctxt->vcpu, 0);
+                        kvm_x86_ops->inject_gp(ctxt->vcpu, 0);
                         _eip = ctxt->vcpu->rip;
                 }
                 rc = X86EMUL_CONTINUE;
@@ -1364,7 +1541,7 @@ twobyte_special_insn:
                 /* rdmsr */
                 rc = kvm_get_msr(ctxt->vcpu, _regs[VCPU_REGS_RCX], &msr_data);
                 if (rc) {
-                        kvm_arch_ops->inject_gp(ctxt->vcpu, 0);
+                        kvm_x86_ops->inject_gp(ctxt->vcpu, 0);
                         _eip = ctxt->vcpu->rip;
                 } else {
                         _regs[VCPU_REGS_RAX] = (u32)msr_data;
@@ -1372,10 +1549,32 @@ twobyte_special_insn:
                 }
                 rc = X86EMUL_CONTINUE;
                 break;
+        case 0x80 ... 0x8f: /* jnz rel, etc*/ {
+                long int rel;
+
+                switch (op_bytes) {
+                case 2:
+                        rel = insn_fetch(s16, 2, _eip);
+                        break;
+                case 4:
+                        rel = insn_fetch(s32, 4, _eip);
+                        break;
+                case 8:
+                        rel = insn_fetch(s64, 8, _eip);
+                        break;
+                default:
+                        DPRINTF("jnz: Invalid op_bytes\n");
+                        goto cannot_emulate;
+                }
+                if (test_cc(b, _eflags))
+                        JMP_REL(rel);
+                break;
+        }
         case 0xc7:              /* Grp9 (cmpxchg8b) */
                 {
                         u64 old, new;
-                        if ((rc = ops->read_emulated(cr2, &old, 8, ctxt)) != 0)
+                        if ((rc = ops->read_emulated(cr2, &old, 8, ctxt->vcpu))
+                                                                        != 0)
                                 goto done;
                         if (((u32) (old >> 0) != (u32) _regs[VCPU_REGS_RAX]) ||
                             ((u32) (old >> 32) != (u32) _regs[VCPU_REGS_RDX])) {
@@ -1386,7 +1585,7 @@ twobyte_special_insn:
                                 new = ((u64)_regs[VCPU_REGS_RCX] << 32)
                                         | (u32) _regs[VCPU_REGS_RBX];
                                 if ((rc = ops->cmpxchg_emulated(cr2, &old,
-                                                          &new, 8, ctxt)) != 0)
+                                                          &new, 8, ctxt->vcpu)) != 0)
                                         goto done;
                                 _eflags |= EFLG_ZF;
                         }
diff --git a/drivers/kvm/x86_emulate.h b/drivers/kvm/x86_emulate.h
index ea3407d7fe..92c73aa7f9 100644
--- a/drivers/kvm/x86_emulate.h
+++ b/drivers/kvm/x86_emulate.h
@@ -60,7 +60,7 @@ struct x86_emulate_ops {
          *  @bytes: [IN ] Number of bytes to read from memory.
          */
         int (*read_std)(unsigned long addr, void *val,
-                        unsigned int bytes, struct x86_emulate_ctxt * ctxt);
+                        unsigned int bytes, struct kvm_vcpu *vcpu);
 
         /*
          * write_std: Write bytes of standard (non-emulated/special) memory.
@@ -71,7 +71,7 @@ struct x86_emulate_ops {
          *  @bytes: [IN ] Number of bytes to write to memory.
          */
         int (*write_std)(unsigned long addr, const void *val,
-                         unsigned int bytes, struct x86_emulate_ctxt * ctxt);
+                         unsigned int bytes, struct kvm_vcpu *vcpu);
 
         /*
          * read_emulated: Read bytes from emulated/special memory area.
@@ -82,7 +82,7 @@ struct x86_emulate_ops {
         int (*read_emulated) (unsigned long addr,
                               void *val,
                               unsigned int bytes,
-                              struct x86_emulate_ctxt * ctxt);
+                              struct kvm_vcpu *vcpu);
 
         /*
          * write_emulated: Read bytes from emulated/special memory area.
@@ -94,7 +94,7 @@ struct x86_emulate_ops {
         int (*write_emulated) (unsigned long addr,
                                const void *val,
                                unsigned int bytes,
-                               struct x86_emulate_ctxt * ctxt);
+                               struct kvm_vcpu *vcpu);
 
         /*
          * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
@@ -108,12 +108,10 @@ struct x86_emulate_ops {
                                  const void *old,
                                  const void *new,
                                  unsigned int bytes,
-                                 struct x86_emulate_ctxt * ctxt);
+                                 struct kvm_vcpu *vcpu);
 
 };
 
-struct cpu_user_regs;
-
 struct x86_emulate_ctxt {
         /* Register state before/after emulation. */
         struct kvm_vcpu *vcpu;
@@ -154,12 +152,4 @@ struct x86_emulate_ctxt {
 int x86_emulate_memop(struct x86_emulate_ctxt *ctxt,
                       struct x86_emulate_ops *ops);
 
-/*
- * Given the 'reg' portion of a ModRM byte, and a register block, return a
- * pointer into the block that addresses the relevant register.
- * @highbyte_regs specifies whether to decode AH,CH,DH,BH.
- */
-void *decode_register(u8 modrm_reg, unsigned long *regs,
-                      int highbyte_regs);
-
 #endif                          /* __X86_EMULATE_H__ */
diff --git a/drivers/md/dm-emc.c b/drivers/md/dm-emc.c
index a2191a4fcf..342517261e 100644
--- a/drivers/md/dm-emc.c
+++ b/drivers/md/dm-emc.c
@@ -54,8 +54,6 @@ static void emc_endio(struct bio *bio, int error)
 
         /* request is freed in block layer */
         free_bio(bio);
-
-        return 0;
 }
 
 static struct bio *get_failover_bio(struct dm_path *path, unsigned data_size)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index e8f102ea9b..acf1b81b47 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -3076,8 +3076,7 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         mddev->gendisk = disk;
         mutex_unlock(&disks_mutex);
         mddev->kobj.parent = &disk->kobj;
-        mddev->kobj.k_name = NULL;
-        snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
+        kobject_set_name(&mddev->kobj, "%s", "md");
         mddev->kobj.ktype = &md_ktype;
         if (kobject_register(&mddev->kobj))
                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 56231d8edc..18738faecb 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -103,10 +103,7 @@ static struct file_operations dvb_device_fops =
         .open =         dvb_device_open,
 };
 
-static struct cdev dvb_device_cdev = {
-        .kobj   = {.name = "dvb", },
-        .owner  =       THIS_MODULE,
-};
+static struct cdev dvb_device_cdev;
 
 int dvb_generic_open(struct inode *inode, struct file *file)
 {
diff --git a/drivers/media/video/bt8xx/bttv-i2c.c b/drivers/media/video/bt8xx/bttv-i2c.c
index 844f1762c4..4d5b8035e4 100644
--- a/drivers/media/video/bt8xx/bttv-i2c.c
+++ b/drivers/media/video/bt8xx/bttv-i2c.c
@@ -124,12 +124,6 @@ static struct i2c_adapter bttv_i2c_adap_sw_template = {
 /* ----------------------------------------------------------------------- */
 /* I2C functions - hardware i2c                                            */
 
-static int algo_control(struct i2c_adapter *adapter,
-                        unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
 static u32 functionality(struct i2c_adapter *adap)
 {
         return I2C_FUNC_SMBUS_EMUL;
@@ -278,7 +272,6 @@ static int bttv_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int
 
 static struct i2c_algorithm bttv_algo = {
         .master_xfer   = bttv_i2c_xfer,
-        .algo_control  = algo_control,
         .functionality = functionality,
 };
 
diff --git a/drivers/media/video/cx23885/cx23885-i2c.c b/drivers/media/video/cx23885/cx23885-i2c.c
index b517c8b5a5..71da528932 100644
--- a/drivers/media/video/cx23885/cx23885-i2c.c
+++ b/drivers/media/video/cx23885/cx23885-i2c.c
@@ -272,12 +272,6 @@ void cx23885_call_i2c_clients(struct cx23885_i2c *bus,
         i2c_clients_command(&bus->i2c_adap, cmd, arg);
 }
 
-static int cx23885_algo_control(struct i2c_adapter *adap,
-                                unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
 static u32 cx23885_functionality(struct i2c_adapter *adap)
 {
         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
@@ -285,7 +279,6 @@ static u32 cx23885_functionality(struct i2c_adapter *adap)
 
 static struct i2c_algorithm cx23885_i2c_algo_template = {
         .master_xfer    = i2c_xfer,
-        .algo_control   = cx23885_algo_control,
         .functionality  = cx23885_functionality,
 };
 
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 54ccc6e1f9..997d067e32 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -383,15 +383,6 @@ static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 /* ----------------------------------------------------------- */
 
 /*
- * algo_control()
- */
-static int algo_control(struct i2c_adapter *adapter,
-                        unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
-/*
  * functionality()
  */
 static u32 functionality(struct i2c_adapter *adap)
@@ -475,7 +466,6 @@ static int attach_inform(struct i2c_client *client)
 
 static struct i2c_algorithm em28xx_algo = {
         .master_xfer   = em28xx_i2c_xfer,
-        .algo_control  = algo_control,
         .functionality = functionality,
 };
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c b/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
index 898c9d2e4c..c817c864e6 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-i2c-core.c
@@ -520,12 +520,6 @@ static int pvr2_i2c_xfer(struct i2c_adapter *i2c_adap,
         return ret;
 }
 
-static int pvr2_i2c_control(struct i2c_adapter *adapter,
-                            unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap)
 {
         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
@@ -942,7 +936,6 @@ static int pvr2_i2c_detach_inform(struct i2c_client *client)
 
 static struct i2c_algorithm pvr2_i2c_algo_template = {
         .master_xfer   = pvr2_i2c_xfer,
-        .algo_control  = pvr2_i2c_control,
         .functionality = pvr2_i2c_functionality,
 };
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-sysfs.c b/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
index 7a78d6b347..2ee3c3049e 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
@@ -905,8 +905,8 @@ struct pvr2_sysfs *pvr2_sysfs_create(struct pvr2_context *mp,
 }
 
 
-static int pvr2_sysfs_hotplug(struct device *cd,char **envp,
-                              int numenvp,char *buf,int size)
+static int pvr2_sysfs_hotplug(struct device *d,
+                              struct kobj_uevent_env *env)
 {
         /* Even though we don't do anything here, we still need this function
            because sysfs will still try to call it. */
diff --git a/drivers/media/video/saa7134/saa7134-i2c.c b/drivers/media/video/saa7134/saa7134-i2c.c
index cc87f5855a..6deaad1a54 100644
--- a/drivers/media/video/saa7134/saa7134-i2c.c
+++ b/drivers/media/video/saa7134/saa7134-i2c.c
@@ -314,12 +314,6 @@ static int saa7134_i2c_xfer(struct i2c_adapter *i2c_adap,
 
 /* ----------------------------------------------------------- */
 
-static int algo_control(struct i2c_adapter *adapter,
-                        unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
 static u32 functionality(struct i2c_adapter *adap)
 {
         return I2C_FUNC_SMBUS_EMUL;
@@ -387,7 +381,6 @@ static int attach_inform(struct i2c_client *client)
 
 static struct i2c_algorithm saa7134_algo = {
         .master_xfer   = saa7134_i2c_xfer,
-        .algo_control  = algo_control,
         .functionality = functionality,
 };
 
diff --git a/drivers/media/video/usbvision/usbvision-i2c.c b/drivers/media/video/usbvision/usbvision-i2c.c
index c66aef6391..aabc42cae9 100644
--- a/drivers/media/video/usbvision/usbvision-i2c.c
+++ b/drivers/media/video/usbvision/usbvision-i2c.c
@@ -183,11 +183,6 @@ usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
         return num;
 }
 
-static int algo_control(struct i2c_adapter *adapter, unsigned int cmd, unsigned long arg)
-{
-        return 0;
-}
-
 static u32 functionality(struct i2c_adapter *adap)
 {
         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR;
@@ -199,7 +194,6 @@ static u32 functionality(struct i2c_adapter *adap)
 static struct i2c_algorithm usbvision_algo = {
         .master_xfer   = usbvision_i2c_xfer,
         .smbus_xfer    = NULL,
-        .algo_control  = algo_control,
         .functionality = functionality,
 };
 
diff --git a/drivers/media/video/videobuf-core.c b/drivers/media/video/videobuf-core.c
index c606332512..5599a36490 100644
--- a/drivers/media/video/videobuf-core.c
+++ b/drivers/media/video/videobuf-core.c
@@ -674,7 +674,7 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
         }
 
         /* Copy to userspace */
-        retval=CALL(q,copy_to_user,q,data,count,nonblocking);
+        retval=CALL(q,video_copy_to_user,q,data,count,nonblocking);
         if (retval<0)
                 goto done;
 
diff --git a/drivers/media/video/videobuf-dma-sg.c b/drivers/media/video/videobuf-dma-sg.c
index 8bb7fdd306..3eb6123227 100644
--- a/drivers/media/video/videobuf-dma-sg.c
+++ b/drivers/media/video/videobuf-dma-sg.c
@@ -670,7 +670,7 @@ static struct videobuf_qtype_ops pci_ops = {
         .sync         = __videobuf_sync,
         .mmap_free    = __videobuf_mmap_free,
         .mmap_mapper  = __videobuf_mmap_mapper,
-        .copy_to_user = __videobuf_copy_to_user,
+        .video_copy_to_user = __videobuf_copy_to_user,
         .copy_stream  = __videobuf_copy_stream,
 };
 
diff --git a/drivers/media/video/videobuf-vmalloc.c b/drivers/media/video/videobuf-vmalloc.c
index 2e3689a12a..cd74341c98 100644
--- a/drivers/media/video/videobuf-vmalloc.c
+++ b/drivers/media/video/videobuf-vmalloc.c
@@ -320,7 +320,7 @@ static struct videobuf_qtype_ops qops = {
         .sync         = __videobuf_sync,
         .mmap_free    = __videobuf_mmap_free,
         .mmap_mapper  = __videobuf_mmap_mapper,
-        .copy_to_user = __videobuf_copy_to_user,
+        .video_copy_to_user = __videobuf_copy_to_user,
         .copy_stream  = __videobuf_copy_stream,
 };
 
diff --git a/drivers/media/video/w9968cf.c b/drivers/media/video/w9968cf.c
index 5a1b5f5a7d..9e7f3e685d 100644
--- a/drivers/media/video/w9968cf.c
+++ b/drivers/media/video/w9968cf.c
@@ -444,8 +444,6 @@ static int w9968cf_i2c_smbus_xfer(struct i2c_adapter*, u16 addr,
 static u32 w9968cf_i2c_func(struct i2c_adapter*);
 static int w9968cf_i2c_attach_inform(struct i2c_client*);
 static int w9968cf_i2c_detach_inform(struct i2c_client*);
-static int w9968cf_i2c_control(struct i2c_adapter*, unsigned int cmd,
-                               unsigned long arg);
 
 /* Memory management */
 static void* rvmalloc(unsigned long size);
@@ -1543,21 +1541,12 @@ static int w9968cf_i2c_detach_inform(struct i2c_client* client)
 }
 
 
-static int
-w9968cf_i2c_control(struct i2c_adapter* adapter, unsigned int cmd,
-                    unsigned long arg)
-{
-        return 0;
-}
-
-
 static int w9968cf_i2c_init(struct w9968cf_device* cam)
 {
         int err = 0;
 
         static struct i2c_algorithm algo = {
                 .smbus_xfer =    w9968cf_i2c_smbus_xfer,
-                .algo_control =  w9968cf_i2c_control,
                 .functionality = w9968cf_i2c_func,
         };
 
diff --git a/drivers/misc/tifm_core.c b/drivers/misc/tifm_core.c
index d195fb088f..8f77949f93 100644
--- a/drivers/misc/tifm_core.c
+++ b/drivers/misc/tifm_core.c
@@ -57,16 +57,11 @@ static int tifm_bus_match(struct device *dev, struct device_driver *drv)
         return 0;
 }
 
-static int tifm_uevent(struct device *dev, char **envp, int num_envp,
-                       char *buffer, int buffer_size)
+static int tifm_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
-        int i = 0;
-        int length = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                           "TIFM_CARD_TYPE=%s",
-                           tifm_media_type_name(sock->type, 1)))
+        if (add_uevent_var(env, "TIFM_CARD_TYPE=%s", tifm_media_type_name(sock->type, 1)))
                 return -ENOMEM;
 
         return 0;
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 8d6f601487..b0c22cad94 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -58,12 +58,11 @@ static int mmc_bus_match(struct device *dev, struct device_driver *drv)
 }
 
 static int
-mmc_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf,
-                int buf_size)
+mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct mmc_card *card = dev_to_mmc_card(dev);
         const char *type;
-        int i = 0, length = 0;
+        int retval = 0;
 
         switch (card->type) {
         case MMC_TYPE_MMC:
@@ -80,20 +79,14 @@ mmc_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf,
         }
 
         if (type) {
-                if (add_uevent_var(envp, num_envp, &i,
-                                buf, buf_size, &length,
-                                "MMC_TYPE=%s", type))
-                        return -ENOMEM;
+                retval = add_uevent_var(env, "MMC_TYPE=%s", type);
+                if (retval)
+                        return retval;
         }
 
-        if (add_uevent_var(envp, num_envp, &i,
-                        buf, buf_size, &length,
-                        "MMC_NAME=%s", mmc_card_name(card)))
-                return -ENOMEM;
+        retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
 
-        envp[i] = NULL;
-
-        return 0;
+        return retval;
 }
 
 static int mmc_bus_probe(struct device *dev)
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 64fbc9759a..c65d203a84 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -143,7 +143,7 @@ void mmc_remove_host(struct mmc_host *host)
 
         device_del(&host->class_dev);
 
-        led_trigger_unregister(host->led);
+        led_trigger_unregister_simple(host->led);
 
         spin_lock(&mmc_host_lock);
         idr_remove(&mmc_host_idr, host->index);
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index fbec8cd55e..8848e8ac70 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -278,6 +278,14 @@ config SSFDC
           This enables read only access to SmartMedia formatted NAND
           flash. You can mount it with FAT file system.
 
+config MTD_OOPS
+        tristate "Log panic/oops to an MTD buffer"
+        depends on MTD
+        help
+          This enables panic and oops messages to be logged to a circular
+          buffer in a flash partition where it can be read back at some
+          later point.
+
 source "drivers/mtd/chips/Kconfig"
 
 source "drivers/mtd/maps/Kconfig"
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index 6d958a4566..7f0b04b4ca 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_NFTL)		+= nftl.o
 obj-$(CONFIG_INFTL)             += inftl.o
 obj-$(CONFIG_RFD_FTL)           += rfd_ftl.o
 obj-$(CONFIG_SSFDC)             += ssfdc.o
+obj-$(CONFIG_MTD_OOPS)          += mtdoops.o
 
 nftl-objs               := nftlcore.o nftlmount.o
 inftl-objs              := inftlcore.o inftlmount.o
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 2f19fa78d2..3aa3dca56a 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -526,7 +526,7 @@ static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
 
         /*
-         * Probing of multi-partition flash ships.
+         * Probing of multi-partition flash chips.
          *
          * To support multiple partitions when available, we simply arrange
          * for each of them to have their own flchip structure even if they
@@ -653,7 +653,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
  resettime:
         timeo = jiffies + HZ;
  retry:
-        if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE)) {
+        if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE || mode == FL_SHUTDOWN)) {
                 /*
                  * OK. We have possibility for contension on the write/erase
                  * operations which are global to the real chip and not per
@@ -798,6 +798,9 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                 if (mode == FL_READY && chip->oldstate == FL_READY)
                         return 0;
 
+        case FL_SHUTDOWN:
+                /* The machine is rebooting now,so no one can get chip anymore */
+                return -EIO;
         default:
         sleep:
                 set_current_state(TASK_UNINTERRUPTIBLE);
@@ -1166,28 +1169,34 @@ static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, si
 {
         struct map_info *map = mtd->priv;
         struct cfi_private *cfi = map->fldrv_priv;
-        unsigned long ofs;
+        unsigned long ofs, last_end = 0;
         int chipnum;
         int ret = 0;
 
         if (!map->virt || (from + len > mtd->size))
                 return -EINVAL;
 
-        *mtdbuf = (void *)map->virt + from;
-        *retlen = 0;
-
         /* Now lock the chip(s) to POINT state */
 
         /* ofs: offset within the first chip that the first read should start */
         chipnum = (from >> cfi->chipshift);
         ofs = from - (chipnum << cfi->chipshift);
 
+        *mtdbuf = (void *)map->virt + cfi->chips[chipnum].start + ofs;
+        *retlen = 0;
+
         while (len) {
                 unsigned long thislen;
 
                 if (chipnum >= cfi->numchips)
                         break;
 
+                /* We cannot point across chips that are virtually disjoint */
+                if (!last_end)
+                        last_end = cfi->chips[chipnum].start;
+                else if (cfi->chips[chipnum].start != last_end)
+                        break;
+
                 if ((len + ofs -1) >> cfi->chipshift)
                         thislen = (1<<cfi->chipshift) - ofs;
                 else
@@ -1201,6 +1210,7 @@ static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, si
                 len -= thislen;
 
                 ofs = 0;
+                last_end += 1 << cfi->chipshift;
                 chipnum++;
         }
         return 0;
@@ -1780,7 +1790,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
         return ret;
 }
 
-int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
+static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 {
         unsigned long ofs, len;
         int ret;
@@ -1930,7 +1940,7 @@ static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
                __FUNCTION__, ofs, len);
         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
-                ofs, len, 0);
+                ofs, len, NULL);
 #endif
 
         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
@@ -1940,7 +1950,7 @@ static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
                __FUNCTION__, ret);
         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
-                ofs, len, 0);
+                ofs, len, NULL);
 #endif
 
         return ret;
@@ -1954,7 +1964,7 @@ static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
                __FUNCTION__, ofs, len);
         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
-                ofs, len, 0);
+                ofs, len, NULL);
 #endif
 
         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
@@ -1964,7 +1974,7 @@ static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
                __FUNCTION__, ret);
         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
-                ofs, len, 0);
+                ofs, len, NULL);
 #endif
 
         return ret;
@@ -2255,7 +2265,7 @@ static void cfi_intelext_save_locks(struct mtd_info *mtd)
                         adr = region->offset + block * len;
 
                         status = cfi_varsize_frob(mtd,
-                                        do_getlockstatus_oneblock, adr, len, 0);
+                                        do_getlockstatus_oneblock, adr, len, NULL);
                         if (status)
                                 set_bit(block, region->lockmap);
                         else
@@ -2402,10 +2412,10 @@ static int cfi_intelext_reset(struct mtd_info *mtd)
                    and switch to array mode so any bootloader in
                    flash is accessible for soft reboot. */
                 spin_lock(chip->mutex);
-                ret = get_chip(map, chip, chip->start, FL_SYNCING);
+                ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
                 if (!ret) {
                         map_write(map, CMD(0xff), chip->start);
-                        chip->state = FL_READY;
+                        chip->state = FL_SHUTDOWN;
                 }
                 spin_unlock(chip->mutex);
         }
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index 1f64458404..389acc600f 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -1609,7 +1609,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 }
 
 
-int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
+static int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 {
         unsigned long ofs, len;
         int ret;
diff --git a/drivers/mtd/chips/jedec_probe.c b/drivers/mtd/chips/jedec_probe.c
index 58e561e876..a67b23b87f 100644
--- a/drivers/mtd/chips/jedec_probe.c
+++ b/drivers/mtd/chips/jedec_probe.c
@@ -17,7 +17,6 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
-#include <linux/init.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
@@ -70,6 +69,7 @@
 
 /* Fujitsu */
 #define MBM29F040C      0x00A4
+#define MBM29F800BA     0x2258
 #define MBM29LV650UE    0x22D7
 #define MBM29LV320TE    0x22F6
 #define MBM29LV320BE    0x22F9
@@ -129,6 +129,7 @@
 #define LH28F640BF      0x00b0
 
 /* ST - www.st.com */
+#define M29F800AB       0x0058
 #define M29W800DT       0x00D7
 #define M29W800DB       0x005B
 #define M29W160DT       0x22C4
@@ -646,6 +647,23 @@ static const struct amd_flash_info jedec_table[] = {
                 }
         }, {
                 .mfr_id         = MANUFACTURER_FUJITSU,
+                .dev_id         = MBM29F800BA,
+                .name           = "Fujitsu MBM29F800BA",
+                .uaddr          = {
+                        [0] = MTD_UADDR_0x0AAA_0x0555,  /* x8 */
+                        [1] = MTD_UADDR_0x0555_0x02AA,  /* x16 */
+                },
+                .DevSize        = SIZE_1MiB,
+                .CmdSet         = P_ID_AMD_STD,
+                .NumEraseRegions= 4,
+                .regions        = {
+                        ERASEINFO(0x04000,1),
+                        ERASEINFO(0x02000,2),
+                        ERASEINFO(0x08000,1),
+                        ERASEINFO(0x10000,15),
+                }
+        }, {
+                .mfr_id         = MANUFACTURER_FUJITSU,
                 .dev_id         = MBM29LV650UE,
                 .name           = "Fujitsu MBM29LV650UE",
                 .uaddr          = {
@@ -1510,6 +1528,23 @@ static const struct amd_flash_info jedec_table[] = {
                        ERASEINFO(0x1000,256)
                }
 
+        }, {
+                .mfr_id         = MANUFACTURER_ST,
+                .dev_id         = M29F800AB,
+                .name           = "ST M29F800AB",
+                .uaddr          = {
+                        [0] = MTD_UADDR_0x0AAA_0x0555,  /* x8 */
+                        [1] = MTD_UADDR_0x0555_0x02AA,  /* x16 */
+                },
+                .DevSize        = SIZE_1MiB,
+                .CmdSet         = P_ID_AMD_STD,
+                .NumEraseRegions= 4,
+                .regions        = {
+                        ERASEINFO(0x04000,1),
+                        ERASEINFO(0x02000,2),
+                        ERASEINFO(0x08000,1),
+                        ERASEINFO(0x10000,15),
+                }
        }, {
                 .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
                 .dev_id         = M29W800DT,
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index ff642f8fbe..811d56fd89 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -60,21 +60,22 @@ config MTD_DATAFLASH
           Sometimes DataFlash chips are packaged inside MMC-format
           cards; at this writing, the MMC stack won't handle those.
 
-config MTD_DATAFLASH26
-        tristate "AT91RM9200 DataFlash AT26xxx"
-        depends on MTD && ARCH_AT91RM9200 && AT91_SPI
-        help
-          This enables access to the DataFlash chip (AT26xxx) on an
-          AT91RM9200-based board.
-          If you have such a board and such a DataFlash, say 'Y'.
-
 config MTD_M25P80
-        tristate "Support for M25 SPI Flash"
+        tristate "Support most SPI Flash chips (AT26DF, M25P, W25X, ...)"
         depends on SPI_MASTER && EXPERIMENTAL
         help
-          This enables access to ST M25P80 and similar SPI flash chips,
-          used for program and data storage.  Set up your spi devices
-          with the right board-specific platform data.
+          This enables access to most modern SPI flash chips, used for
+          program and data storage.   Series supported include Atmel AT26DF,
+          Spansion S25SL, SST 25VF, ST M25P, and Winbond W25X.  Other chips
+          are supported as well.  See the driver source for the current list,
+          or to add other chips.
+
+          Note that the original DataFlash chips (AT45 series, not AT26DF),
+          need an entirely different driver.
+
+          Set up your spi devices with the right board-specific platform data,
+          if you want to specify device partitioning or to use a device which
+          doesn't support the JEDEC ID instruction.
 
 config MTD_SLRAM
         tristate "Uncached system RAM"
diff --git a/drivers/mtd/devices/Makefile b/drivers/mtd/devices/Makefile
index 8ab568b3f5..0f788d5c4b 100644
--- a/drivers/mtd/devices/Makefile
+++ b/drivers/mtd/devices/Makefile
@@ -16,5 +16,4 @@ obj-$(CONFIG_MTD_MTDRAM)	+= mtdram.o
 obj-$(CONFIG_MTD_LART)          += lart.o
 obj-$(CONFIG_MTD_BLOCK2MTD)     += block2mtd.o
 obj-$(CONFIG_MTD_DATAFLASH)     += mtd_dataflash.o
-obj-$(CONFIG_MTD_DATAFLASH26)   += at91_dataflash26.o
 obj-$(CONFIG_MTD_M25P80)        += m25p80.o
diff --git a/drivers/mtd/devices/at91_dataflash26.c b/drivers/mtd/devices/at91_dataflash26.c
deleted file mode 100644
index 64ce37f986..0000000000
--- a/drivers/mtd/devices/at91_dataflash26.c
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * Atmel DataFlash driver for Atmel AT91RM9200 (Thunder)
- * This is a largely modified version of at91_dataflash.c that
- * supports AT26xxx dataflash chips. The original driver supports
- * AT45xxx chips.
- *
- * Note: This driver was only tested with an AT26F004. It should be
- * easy to make it work with other AT26xxx dataflash devices, though.
- *
- * Copyright (C) 2007 Hans J. Koch <hjk@linutronix.de>
- * original Copyright (C) SAN People (Pty) Ltd
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
-*/
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/mtd/mtd.h>
-
-#include <asm/arch/at91_spi.h>
-
-#define DATAFLASH_MAX_DEVICES   4       /* max number of dataflash devices */
-
-#define MANUFACTURER_ID_ATMEL           0x1F
-
-/* command codes */
-
-#define AT26_OP_READ_STATUS             0x05
-#define AT26_OP_READ_DEV_ID             0x9F
-#define AT26_OP_ERASE_PAGE_4K           0x20
-#define AT26_OP_READ_ARRAY_FAST         0x0B
-#define AT26_OP_SEQUENTIAL_WRITE        0xAF
-#define AT26_OP_WRITE_ENABLE            0x06
-#define AT26_OP_WRITE_DISABLE           0x04
-#define AT26_OP_SECTOR_PROTECT          0x36
-#define AT26_OP_SECTOR_UNPROTECT        0x39
-
-/* status register bits */
-
-#define AT26_STATUS_BUSY                0x01
-#define AT26_STATUS_WRITE_ENABLE        0x02
-
-struct dataflash_local
-{
-        int spi;                        /* SPI chip-select number */
-        unsigned int page_size;         /* number of bytes per page */
-};
-
-
-/* Detected DataFlash devices */
-static struct mtd_info* mtd_devices[DATAFLASH_MAX_DEVICES];
-static int nr_devices = 0;
-
-/* Allocate a single SPI transfer descriptor.  We're assuming that if multiple
-   SPI transfers occur at the same time, spi_access_bus() will serialize them.
-   If this is not valid, then either (i) each dataflash 'priv' structure
-   needs it's own transfer descriptor, (ii) we lock this one, or (iii) use
-   another mechanism.   */
-static struct spi_transfer_list* spi_transfer_desc;
-
-/*
- * Perform a SPI transfer to access the DataFlash device.
- */
-static int do_spi_transfer(int nr, char* tx, int tx_len, char* rx, int rx_len,
-                char* txnext, int txnext_len, char* rxnext, int rxnext_len)
-{
-        struct spi_transfer_list* list = spi_transfer_desc;
-
-        list->tx[0] = tx;       list->txlen[0] = tx_len;
-        list->rx[0] = rx;       list->rxlen[0] = rx_len;
-
-        list->tx[1] = txnext;   list->txlen[1] = txnext_len;
-        list->rx[1] = rxnext;   list->rxlen[1] = rxnext_len;
-
-        list->nr_transfers = nr;
-        /* Note: spi_transfer() always returns 0, there are no error checks */
-        return spi_transfer(list);
-}
-
-/*
- * Return the status of the DataFlash device.
- */
-static unsigned char at91_dataflash26_status(void)
-{
-        unsigned char command[2];
-
-        command[0] = AT26_OP_READ_STATUS;
-        command[1] = 0;
-
-        do_spi_transfer(1, command, 2, command, 2, NULL, 0, NULL, 0);
-
-        return command[1];
-}
-
-/*
- * Poll the DataFlash device until it is READY.
- */
-static unsigned char at91_dataflash26_waitready(void)
-{
-        unsigned char status;
-
-        while (1) {
-                status = at91_dataflash26_status();
-                if (!(status & AT26_STATUS_BUSY))
-                        return status;
-        }
-}
-
-/*
- * Enable/disable write access
- */
- static void at91_dataflash26_write_enable(int enable)
-{
-        unsigned char cmd[2];
-
-        DEBUG(MTD_DEBUG_LEVEL3, "write_enable: enable=%i\n", enable);
-
-        if (enable)
-                cmd[0] = AT26_OP_WRITE_ENABLE;
-        else
-                cmd[0] = AT26_OP_WRITE_DISABLE;
-        cmd[1] = 0;
-
-        do_spi_transfer(1, cmd, 2, cmd, 2, NULL, 0, NULL, 0);
-}
-
-/*
- * Protect/unprotect sector
- */
- static void at91_dataflash26_sector_protect(loff_t addr, int protect)
-{
-        unsigned char cmd[4];
-
-        DEBUG(MTD_DEBUG_LEVEL3, "sector_protect: addr=0x%06x prot=%d\n",
-               addr, protect);
-
-        if (protect)
-                cmd[0] = AT26_OP_SECTOR_PROTECT;
-        else
-                cmd[0] = AT26_OP_SECTOR_UNPROTECT;
-        cmd[1] = (addr & 0x00FF0000) >> 16;
-        cmd[2] = (addr & 0x0000FF00) >> 8;
-        cmd[3] = (addr & 0x000000FF);
-
-        do_spi_transfer(1, cmd, 4, cmd, 4, NULL, 0, NULL, 0);
-}
-
-/*
- * Erase blocks of flash.
- */
-static int at91_dataflash26_erase(struct mtd_info *mtd,
-                                  struct erase_info *instr)
-{
-        struct dataflash_local *priv = (struct dataflash_local *) mtd->priv;
-        unsigned char cmd[4];
-
-        DEBUG(MTD_DEBUG_LEVEL1, "dataflash_erase: addr=0x%06x len=%i\n",
-               instr->addr, instr->len);
-
-        /* Sanity checks */
-        if (priv->page_size != 4096)
-                return -EINVAL; /* Can't handle other sizes at the moment */
-
-        if (   ((instr->len % mtd->erasesize) != 0)
-            || ((instr->len % priv->page_size) != 0)
-            || ((instr->addr % priv->page_size) != 0)
-            || ((instr->addr + instr->len) > mtd->size))
-                return -EINVAL;
-
-        spi_access_bus(priv->spi);
-
-        while (instr->len > 0) {
-                at91_dataflash26_write_enable(1);
-                at91_dataflash26_sector_protect(instr->addr, 0);
-                at91_dataflash26_write_enable(1);
-                cmd[0] = AT26_OP_ERASE_PAGE_4K;
-                cmd[1] = (instr->addr & 0x00FF0000) >> 16;
-                cmd[2] = (instr->addr & 0x0000FF00) >> 8;
-                cmd[3] = (instr->addr & 0x000000FF);
-
-                DEBUG(MTD_DEBUG_LEVEL3, "ERASE: (0x%02x) 0x%02x 0x%02x"
-                                        "0x%02x\n",
-                        cmd[0], cmd[1], cmd[2], cmd[3]);
-
-                do_spi_transfer(1, cmd, 4, cmd, 4, NULL, 0, NULL, 0);
-                at91_dataflash26_waitready();
-
-                instr->addr += priv->page_size;  /* next page */
-                instr->len -= priv->page_size;
-        }
-
-        at91_dataflash26_write_enable(0);
-        spi_release_bus(priv->spi);
-
-        /* Inform MTD subsystem that erase is complete */
-        instr->state = MTD_ERASE_DONE;
-        if (instr->callback)
-                instr->callback(instr);
-
-        return 0;
-}
-
-/*
- * Read from the DataFlash device.
- *   from   : Start offset in flash device
- *   len    : Number of bytes to read
- *   retlen : Number of bytes actually read
- *   buf    : Buffer that will receive data
- */
-static int at91_dataflash26_read(struct mtd_info *mtd, loff_t from, size_t len,
-                                 size_t *retlen, u_char *buf)
-{
-        struct dataflash_local *priv = (struct dataflash_local *) mtd->priv;
-        unsigned char cmd[5];
-
-        DEBUG(MTD_DEBUG_LEVEL1, "dataflash_read: %lli .. %lli\n",
-              from, from+len);
-
-        *retlen = 0;
-
-        /* Sanity checks */
-        if (!len)
-                return 0;
-        if (from + len > mtd->size)
-                return -EINVAL;
-
-        cmd[0] = AT26_OP_READ_ARRAY_FAST;
-        cmd[1] = (from & 0x00FF0000) >> 16;
-        cmd[2] = (from & 0x0000FF00) >> 8;
-        cmd[3] = (from & 0x000000FF);
-        /* cmd[4] is a "Don't care" byte  */
-
-        DEBUG(MTD_DEBUG_LEVEL3, "READ: (0x%02x) 0x%02x 0x%02x 0x%02x\n",
-               cmd[0], cmd[1], cmd[2], cmd[3]);
-
-        spi_access_bus(priv->spi);
-        do_spi_transfer(2, cmd, 5, cmd, 5, buf, len, buf, len);
-        spi_release_bus(priv->spi);
-
-        *retlen = len;
-        return 0;
-}
-
-/*
- * Write to the DataFlash device.
- *   to     : Start offset in flash device
- *   len    : Number of bytes to write
- *   retlen : Number of bytes actually written
- *   buf    : Buffer containing the data
- */
-static int at91_dataflash26_write(struct mtd_info *mtd, loff_t to, size_t len,
-                                  size_t *retlen, const u_char *buf)
-{
-        struct dataflash_local *priv = (struct dataflash_local *) mtd->priv;
-        unsigned int addr, buf_index = 0;
-        int ret = -EIO, sector, last_sector;
-        unsigned char status, cmd[5];
-
-        DEBUG(MTD_DEBUG_LEVEL1, "dataflash_write: %lli .. %lli\n", to, to+len);
-
-        *retlen = 0;
-
-        /* Sanity checks */
-        if (!len)
-                return 0;
-        if (to + len > mtd->size)
-                return -EINVAL;
-
-        spi_access_bus(priv->spi);
-
-        addr = to;
-        last_sector = -1;
-
-        while (buf_index < len) {
-                sector = addr / priv->page_size;
-                /* Write first byte if a new sector begins */
-                if (sector != last_sector) {
-                        at91_dataflash26_write_enable(1);
-                        at91_dataflash26_sector_protect(addr, 0);
-                        at91_dataflash26_write_enable(1);
-
-                        /* Program first byte of a new sector */
-                        cmd[0] = AT26_OP_SEQUENTIAL_WRITE;
-                        cmd[1] = (addr & 0x00FF0000) >> 16;
-                        cmd[2] = (addr & 0x0000FF00) >> 8;
-                        cmd[3] = (addr & 0x000000FF);
-                        cmd[4] = buf[buf_index++];
-                        do_spi_transfer(1, cmd, 5, cmd, 5, NULL, 0, NULL, 0);
-                        status = at91_dataflash26_waitready();
-                        addr++;
-                        /* On write errors, the chip resets the write enable
-                           flag. This also happens after the last byte of a
-                           sector is successfully programmed. */
-                        if (   ( !(status & AT26_STATUS_WRITE_ENABLE))
-                            && ((addr % priv->page_size) != 0) ) {
-                                DEBUG(MTD_DEBUG_LEVEL1,
-                                        "write error1: addr=0x%06x, "
-                                        "status=0x%02x\n", addr, status);
-                                goto write_err;
-                        }
-                        (*retlen)++;
-                        last_sector = sector;
-                }
-
-                /* Write subsequent bytes in the same sector */
-                cmd[0] = AT26_OP_SEQUENTIAL_WRITE;
-                cmd[1] = buf[buf_index++];
-                do_spi_transfer(1, cmd, 2, cmd, 2, NULL, 0, NULL, 0);
-                status = at91_dataflash26_waitready();
-                addr++;
-
-                if (   ( !(status & AT26_STATUS_WRITE_ENABLE))
-                    && ((addr % priv->page_size) != 0) ) {
-                        DEBUG(MTD_DEBUG_LEVEL1, "write error2: addr=0x%06x, "
-                                "status=0x%02x\n", addr, status);
-                        goto write_err;
-                }
-
-                (*retlen)++;
-        }
-
-        ret = 0;
-        at91_dataflash26_write_enable(0);
-write_err:
-        spi_release_bus(priv->spi);
-        return ret;
-}
-
-/*
- * Initialize and register DataFlash device with MTD subsystem.
- */
-static int __init add_dataflash(int channel, char *name, int nr_pages,
-                                int pagesize)
-{
-        struct mtd_info *device;
-        struct dataflash_local *priv;
-
-        if (nr_devices >= DATAFLASH_MAX_DEVICES) {
-                printk(KERN_ERR "at91_dataflash26: Too many devices "
-                                "detected\n");
-                return 0;
-        }
-
-        device = kzalloc(sizeof(struct mtd_info) + strlen(name) + 8,
-                         GFP_KERNEL);
-        if (!device)
-                return -ENOMEM;
-
-        device->name = (char *)&device[1];
-        sprintf(device->name, "%s.spi%d", name, channel);
-        device->size = nr_pages * pagesize;
-        device->erasesize = pagesize;
-        device->owner = THIS_MODULE;
-        device->type = MTD_DATAFLASH;
-        device->flags = MTD_CAP_NORFLASH;
-        device->erase = at91_dataflash26_erase;
-        device->read = at91_dataflash26_read;
-        device->write = at91_dataflash26_write;
-
-        priv = (struct dataflash_local *)kzalloc(sizeof(struct dataflash_local),
-                GFP_KERNEL);
-        if (!priv) {
-                kfree(device);
-                return -ENOMEM;
-        }
-
-        priv->spi = channel;
-        priv->page_size = pagesize;
-        device->priv = priv;
-
-        mtd_devices[nr_devices] = device;
-        nr_devices++;
-        printk(KERN_INFO "at91_dataflash26: %s detected [spi%i] (%i bytes)\n",
-               name, channel, device->size);
-
-        return add_mtd_device(device);
-}
-
-/*
- * Detect and initialize DataFlash device connected to specified SPI channel.
- *
- */
-
-struct dataflash26_types {
-        unsigned char id0;
-        unsigned char id1;
-        char *name;
-        int pagesize;
-        int nr_pages;
-};
-
-struct dataflash26_types df26_types[] = {
-        {
-                .id0 = 0x04,
-                .id1 = 0x00,
-                .name = "AT26F004",
-                .pagesize = 4096,
-                .nr_pages = 128,
-        },
-        {
-                .id0 = 0x45,
-                .id1 = 0x01,
-                .name = "AT26DF081A", /* Not tested ! */
-                .pagesize = 4096,
-                .nr_pages = 256,
-        },
-};
-
-static int __init at91_dataflash26_detect(int channel)
-{
-        unsigned char status, cmd[5];
-        int i;
-
-        spi_access_bus(channel);
-        status = at91_dataflash26_status();
-
-        if (status == 0 || status == 0xff) {
-                printk(KERN_ERR "at91_dataflash26_detect: status error %d\n",
-                        status);
-                spi_release_bus(channel);
-                return -ENODEV;
-        }
-
-        cmd[0] = AT26_OP_READ_DEV_ID;
-        do_spi_transfer(1, cmd, 5, cmd, 5, NULL, 0, NULL, 0);
-        spi_release_bus(channel);
-
-        if (cmd[1] != MANUFACTURER_ID_ATMEL)
-                return -ENODEV;
-
-        for (i = 0; i < ARRAY_SIZE(df26_types); i++) {
-                if (   cmd[2] == df26_types[i].id0
-                    && cmd[3] == df26_types[i].id1)
-                        return add_dataflash(channel,
-                                                df26_types[i].name,
-                                                df26_types[i].nr_pages,
-                                                df26_types[i].pagesize);
-        }
-
-        printk(KERN_ERR "at91_dataflash26_detect: Unsupported device "
-                        "(0x%02x/0x%02x)\n", cmd[2], cmd[3]);
-        return -ENODEV;
-}
-
-static int __init at91_dataflash26_init(void)
-{
-        spi_transfer_desc = kmalloc(sizeof(struct spi_transfer_list),
-                                    GFP_KERNEL);
-        if (!spi_transfer_desc)
-                return -ENOMEM;
-
-        /* DataFlash (SPI chip select 0) */
-        at91_dataflash26_detect(0);
-
-#ifdef CONFIG_MTD_AT91_DATAFLASH_CARD
-        /* DataFlash card (SPI chip select 3) */
-        at91_dataflash26_detect(3);
-#endif
-        return 0;
-}
-
-static void __exit at91_dataflash26_exit(void)
-{
-        int i;
-
-        for (i = 0; i < DATAFLASH_MAX_DEVICES; i++) {
-                if (mtd_devices[i]) {
-                        del_mtd_device(mtd_devices[i]);
-                        kfree(mtd_devices[i]->priv);
-                        kfree(mtd_devices[i]);
-                }
-        }
-        nr_devices = 0;
-        kfree(spi_transfer_desc);
-}
-
-module_init(at91_dataflash26_init);
-module_exit(at91_dataflash26_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Hans J. Koch");
-MODULE_DESCRIPTION("DataFlash AT26xxx driver for Atmel AT91RM9200");
diff --git a/drivers/mtd/devices/docprobe.c b/drivers/mtd/devices/docprobe.c
index 54aa759076..d8cc94ec4e 100644
--- a/drivers/mtd/devices/docprobe.c
+++ b/drivers/mtd/devices/docprobe.c
@@ -81,9 +81,7 @@ static unsigned long __initdata doc_locations[] = {
 #endif /*  CONFIG_MTD_DOCPROBE_HIGH */
 #elif defined(__PPC__)
         0xe4000000,
-#elif defined(CONFIG_MOMENCO_OCELOT_G)
-        0xff000000,
-##else
+#else
 #warning Unknown architecture for DiskOnChip. No default probe locations defined
 #endif
         0xffffffff };
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 78c2511ae9..98df5bcc02 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -1,5 +1,5 @@
 /*
- * MTD SPI driver for ST M25Pxx flash chips
+ * MTD SPI driver for ST M25Pxx (and similar) serial flash chips
  *
  * Author: Mike Lavender, mike@steroidmicros.com
  *
@@ -19,33 +19,32 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
-#include <linux/interrupt.h>
+#include <linux/mutex.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
+
 #include <linux/spi/spi.h>
 #include <linux/spi/flash.h>
 
-#include <asm/semaphore.h>
-
-
-/* NOTE: AT 25F and SST 25LF series are very similar,
- * but commands for sector erase and chip id differ...
- */
 
 #define FLASH_PAGESIZE          256
 
 /* Flash opcodes. */
-#define OPCODE_WREN             6       /* Write enable */
-#define OPCODE_RDSR             5       /* Read status register */
-#define OPCODE_READ             3       /* Read data bytes */
-#define OPCODE_PP               2       /* Page program */
-#define OPCODE_SE               0xd8    /* Sector erase */
-#define OPCODE_RES              0xab    /* Read Electronic Signature */
+#define OPCODE_WREN             0x06    /* Write enable */
+#define OPCODE_RDSR             0x05    /* Read status register */
+#define OPCODE_READ             0x03    /* Read data bytes (low frequency) */
+#define OPCODE_FAST_READ        0x0b    /* Read data bytes (high frequency) */
+#define OPCODE_PP               0x02    /* Page program (up to 256 bytes) */
+#define OPCODE_BE_4K            0x20    /* Erase 4KiB block */
+#define OPCODE_BE_32K           0x52    /* Erase 32KiB block */
+#define OPCODE_SE               0xd8    /* Sector erase (usually 64KiB) */
 #define OPCODE_RDID             0x9f    /* Read JEDEC ID */
 
 /* Status Register bits. */
 #define SR_WIP                  1       /* Write in progress */
 #define SR_WEL                  2       /* Write enable latch */
+/* meaning of other SR_* bits may differ between vendors */
 #define SR_BP0                  4       /* Block protect 0 */
 #define SR_BP1                  8       /* Block protect 1 */
 #define SR_BP2                  0x10    /* Block protect 2 */
@@ -65,9 +64,10 @@
 
 struct m25p {
         struct spi_device       *spi;
-        struct semaphore        lock;
+        struct mutex            lock;
         struct mtd_info         mtd;
-        unsigned                partitioned;
+        unsigned                partitioned:1;
+        u8                      erase_opcode;
         u8                      command[4];
 };
 
@@ -150,8 +150,9 @@ static int wait_till_ready(struct m25p *flash)
  */
 static int erase_sector(struct m25p *flash, u32 offset)
 {
-        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s at 0x%08x\n", flash->spi->dev.bus_id,
-                        __FUNCTION__, offset);
+        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB at 0x%08x\n",
+                        flash->spi->dev.bus_id, __FUNCTION__,
+                        flash->mtd.erasesize / 1024, offset);
 
         /* Wait until finished previous write command. */
         if (wait_till_ready(flash))
@@ -161,7 +162,7 @@ static int erase_sector(struct m25p *flash, u32 offset)
         write_enable(flash);
 
         /* Set up command buffer. */
-        flash->command[0] = OPCODE_SE;
+        flash->command[0] = flash->erase_opcode;
         flash->command[1] = offset >> 16;
         flash->command[2] = offset >> 8;
         flash->command[3] = offset;
@@ -201,13 +202,17 @@ static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
         addr = instr->addr;
         len = instr->len;
 
-        down(&flash->lock);
+        mutex_lock(&flash->lock);
+
+        /* REVISIT in some cases we could speed up erasing large regions
+         * by using OPCODE_SE instead of OPCODE_BE_4K
+         */
 
         /* now erase those sectors */
         while (len) {
                 if (erase_sector(flash, addr)) {
                         instr->state = MTD_ERASE_FAILED;
-                        up(&flash->lock);
+                        mutex_unlock(&flash->lock);
                         return -EIO;
                 }
 
@@ -215,7 +220,7 @@ static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
                 len -= mtd->erasesize;
         }
 
-        up(&flash->lock);
+        mutex_unlock(&flash->lock);
 
         instr->state = MTD_ERASE_DONE;
         mtd_erase_callback(instr);
@@ -260,16 +265,19 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
         if (retlen)
                 *retlen = 0;
 
-        down(&flash->lock);
+        mutex_lock(&flash->lock);
 
         /* Wait till previous write/erase is done. */
         if (wait_till_ready(flash)) {
                 /* REVISIT status return?? */
-                up(&flash->lock);
+                mutex_unlock(&flash->lock);
                 return 1;
         }
 
-        /* NOTE:  OPCODE_FAST_READ (if available) is faster... */
+        /* FIXME switch to OPCODE_FAST_READ.  It's required for higher
+         * clocks; and at this writing, every chip this driver handles
+         * supports that opcode.
+         */
 
         /* Set up the write data buffer. */
         flash->command[0] = OPCODE_READ;
@@ -281,7 +289,7 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
 
         *retlen = m.actual_length - sizeof(flash->command);
 
-        up(&flash->lock);
+        mutex_unlock(&flash->lock);
 
         return 0;
 }
@@ -323,7 +331,7 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
         t[1].tx_buf = buf;
         spi_message_add_tail(&t[1], &m);
 
-        down(&flash->lock);
+        mutex_lock(&flash->lock);
 
         /* Wait until finished previous write command. */
         if (wait_till_ready(flash))
@@ -381,10 +389,10 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
                         if (retlen)
                                 *retlen += m.actual_length
                                         - sizeof(flash->command);
-                }
-        }
+                }
+        }
 
-        up(&flash->lock);
+        mutex_unlock(&flash->lock);
 
         return 0;
 }
@@ -398,24 +406,118 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
 
 struct flash_info {
         char            *name;
-        u8              id;
-        u16             jedec_id;
+
+        /* JEDEC id zero means "no ID" (most older chips); otherwise it has
+         * a high byte of zero plus three data bytes: the manufacturer id,
+         * then a two byte device id.
+         */
+        u32             jedec_id;
+
+        /* The size listed here is what works with OPCODE_SE, which isn't
+         * necessarily called a "sector" by the vendor.
+         */
         unsigned        sector_size;
-        unsigned        n_sectors;
+        u16             n_sectors;
+
+        u16             flags;
+#define SECT_4K         0x01            /* OPCODE_BE_4K works uniformly */
 };
 
+
+/* NOTE: double check command sets and memory organization when you add
+ * more flash chips.  This current list focusses on newer chips, which
+ * have been converging on command sets which including JEDEC ID.
+ */
 static struct flash_info __devinitdata m25p_data [] = {
-        /* REVISIT: fill in JEDEC ids, for parts that have them */
-        { "m25p05", 0x05, 0x2010, 32 * 1024, 2 },
-        { "m25p10", 0x10, 0x2011, 32 * 1024, 4 },
-        { "m25p20", 0x11, 0x2012, 64 * 1024, 4 },
-        { "m25p40", 0x12, 0x2013, 64 * 1024, 8 },
-        { "m25p80", 0x13, 0x0000, 64 * 1024, 16 },
-        { "m25p16", 0x14, 0x2015, 64 * 1024, 32 },
-        { "m25p32", 0x15, 0x2016, 64 * 1024, 64 },
-        { "m25p64", 0x16, 0x2017, 64 * 1024, 128 },
+
+        /* Atmel -- some are (confusingly) marketed as "DataFlash" */
+        { "at25fs010",  0x1f6601, 32 * 1024, 4, SECT_4K, },
+        { "at25fs040",  0x1f6604, 64 * 1024, 8, SECT_4K, },
+
+        { "at25df041a", 0x1f4401, 64 * 1024, 8, SECT_4K, },
+
+        { "at26f004",   0x1f0400, 64 * 1024, 8, SECT_4K, },
+        { "at26df081a", 0x1f4501, 64 * 1024, 16, SECT_4K, },
+        { "at26df161a", 0x1f4601, 64 * 1024, 32, SECT_4K, },
+        { "at26df321",  0x1f4701, 64 * 1024, 64, SECT_4K, },
+
+        /* Spansion -- single (large) sector size only, at least
+         * for the chips listed here (without boot sectors).
+         */
+        { "s25sl004a", 0x010212, 64 * 1024, 8, },
+        { "s25sl008a", 0x010213, 64 * 1024, 16, },
+        { "s25sl016a", 0x010214, 64 * 1024, 32, },
+        { "s25sl032a", 0x010215, 64 * 1024, 64, },
+        { "s25sl064a", 0x010216, 64 * 1024, 128, },
+
+        /* SST -- large erase sizes are "overlays", "sectors" are 4K */
+        { "sst25vf040b", 0xbf258d, 64 * 1024, 8, SECT_4K, },
+        { "sst25vf080b", 0xbf258e, 64 * 1024, 16, SECT_4K, },
+        { "sst25vf016b", 0xbf2541, 64 * 1024, 32, SECT_4K, },
+        { "sst25vf032b", 0xbf254a, 64 * 1024, 64, SECT_4K, },
+
+        /* ST Microelectronics -- newer production may have feature updates */
+        { "m25p05",  0x202010,  32 * 1024, 2, },
+        { "m25p10",  0x202011,  32 * 1024, 4, },
+        { "m25p20",  0x202012,  64 * 1024, 4, },
+        { "m25p40",  0x202013,  64 * 1024, 8, },
+        { "m25p80",         0,  64 * 1024, 16, },
+        { "m25p16",  0x202015,  64 * 1024, 32, },
+        { "m25p32",  0x202016,  64 * 1024, 64, },
+        { "m25p64",  0x202017,  64 * 1024, 128, },
+        { "m25p128", 0x202018, 256 * 1024, 64, },
+
+        { "m45pe80", 0x204014,  64 * 1024, 16, },
+        { "m45pe16", 0x204015,  64 * 1024, 32, },
+
+        { "m25pe80", 0x208014,  64 * 1024, 16, },
+        { "m25pe16", 0x208015,  64 * 1024, 32, SECT_4K, },
+
+        /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
+        { "w25x10", 0xef3011, 64 * 1024, 2, SECT_4K, },
+        { "w25x20", 0xef3012, 64 * 1024, 4, SECT_4K, },
+        { "w25x40", 0xef3013, 64 * 1024, 8, SECT_4K, },
+        { "w25x80", 0xef3014, 64 * 1024, 16, SECT_4K, },
+        { "w25x16", 0xef3015, 64 * 1024, 32, SECT_4K, },
+        { "w25x32", 0xef3016, 64 * 1024, 64, SECT_4K, },
+        { "w25x64", 0xef3017, 64 * 1024, 128, SECT_4K, },
 };
 
+static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
+{
+        int                     tmp;
+        u8                      code = OPCODE_RDID;
+        u8                      id[3];
+        u32                     jedec;
+        struct flash_info       *info;
+
+        /* JEDEC also defines an optional "extended device information"
+         * string for after vendor-specific data, after the three bytes
+         * we use here.  Supporting some chips might require using it.
+         */
+        tmp = spi_write_then_read(spi, &code, 1, id, 3);
+        if (tmp < 0) {
+                DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
+                        spi->dev.bus_id, tmp);
+                return NULL;
+        }
+        jedec = id[0];
+        jedec = jedec << 8;
+        jedec |= id[1];
+        jedec = jedec << 8;
+        jedec |= id[2];
+
+        for (tmp = 0, info = m25p_data;
+                        tmp < ARRAY_SIZE(m25p_data);
+                        tmp++, info++) {
+                if (info->jedec_id == jedec)
+                        return info;
+        }
+        dev_err(&spi->dev, "unrecognized JEDEC id %06x\n", jedec);
+        return NULL;
+}
+
+
 /*
  * board specific setup should have ensured the SPI clock used here
  * matches what the READ command supports, at least until this driver
@@ -429,37 +531,51 @@ static int __devinit m25p_probe(struct spi_device *spi)
         unsigned                        i;
 
         /* Platform data helps sort out which chip type we have, as
-         * well as how this board partitions it.
+         * well as how this board partitions it.  If we don't have
+         * a chip ID, try the JEDEC id commands; they'll work for most
+         * newer chips, even if we don't recognize the particular chip.
          */
         data = spi->dev.platform_data;
-        if (!data || !data->type) {
-                /* FIXME some chips can identify themselves with RES
-                 * or JEDEC get-id commands.  Try them ...
-                 */
-                DEBUG(MTD_DEBUG_LEVEL1, "%s: no chip id\n",
-                                spi->dev.bus_id);
-                return -ENODEV;
-        }
+        if (data && data->type) {
+                for (i = 0, info = m25p_data;
+                                i < ARRAY_SIZE(m25p_data);
+                                i++, info++) {
+                        if (strcmp(data->type, info->name) == 0)
+                                break;
+                }
 
-        for (i = 0, info = m25p_data; i < ARRAY_SIZE(m25p_data); i++, info++) {
-                if (strcmp(data->type, info->name) == 0)
-                        break;
-        }
-        if (i == ARRAY_SIZE(m25p_data)) {
-                DEBUG(MTD_DEBUG_LEVEL1, "%s: unrecognized id %s\n",
-                                spi->dev.bus_id, data->type);
+                /* unrecognized chip? */
+                if (i == ARRAY_SIZE(m25p_data)) {
+                        DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
+                                        spi->dev.bus_id, data->type);
+                        info = NULL;
+
+                /* recognized; is that chip really what's there? */
+                } else if (info->jedec_id) {
+                        struct flash_info       *chip = jedec_probe(spi);
+
+                        if (!chip || chip != info) {
+                                dev_warn(&spi->dev, "found %s, expected %s\n",
+                                                chip ? chip->name : "UNKNOWN",
+                                                info->name);
+                                info = NULL;
+                        }
+                }
+        } else
+                info = jedec_probe(spi);
+
+        if (!info)
                 return -ENODEV;
-        }
 
         flash = kzalloc(sizeof *flash, GFP_KERNEL);
         if (!flash)
                 return -ENOMEM;
 
         flash->spi = spi;
-        init_MUTEX(&flash->lock);
+        mutex_init(&flash->lock);
         dev_set_drvdata(&spi->dev, flash);
 
-        if (data->name)
+        if (data && data->name)
                 flash->mtd.name = data->name;
         else
                 flash->mtd.name = spi->dev.bus_id;
@@ -468,17 +584,25 @@ static int __devinit m25p_probe(struct spi_device *spi)
         flash->mtd.writesize = 1;
         flash->mtd.flags = MTD_CAP_NORFLASH;
         flash->mtd.size = info->sector_size * info->n_sectors;
-        flash->mtd.erasesize = info->sector_size;
         flash->mtd.erase = m25p80_erase;
         flash->mtd.read = m25p80_read;
         flash->mtd.write = m25p80_write;
 
+        /* prefer "small sector" erase if possible */
+        if (info->flags & SECT_4K) {
+                flash->erase_opcode = OPCODE_BE_4K;
+                flash->mtd.erasesize = 4096;
+        } else {
+                flash->erase_opcode = OPCODE_SE;
+                flash->mtd.erasesize = info->sector_size;
+        }
+
         dev_info(&spi->dev, "%s (%d Kbytes)\n", info->name,
                         flash->mtd.size / 1024);
 
         DEBUG(MTD_DEBUG_LEVEL2,
-                "mtd .name = %s, .size = 0x%.8x (%uM) "
-                        ".erasesize = 0x%.8x (%uK) .numeraseregions = %d\n",
+                "mtd .name = %s, .size = 0x%.8x (%uMiB) "
+                        ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
                 flash->mtd.name,
                 flash->mtd.size, flash->mtd.size / (1024*1024),
                 flash->mtd.erasesize, flash->mtd.erasesize / 1024,
@@ -488,7 +612,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
                 for (i = 0; i < flash->mtd.numeraseregions; i++)
                         DEBUG(MTD_DEBUG_LEVEL2,
                                 "mtd.eraseregions[%d] = { .offset = 0x%.8x, "
-                                ".erasesize = 0x%.8x (%uK), "
+                                ".erasesize = 0x%.8x (%uKiB), "
                                 ".numblocks = %d }\n",
                                 i, flash->mtd.eraseregions[i].offset,
                                 flash->mtd.eraseregions[i].erasesize,
@@ -516,14 +640,14 @@ static int __devinit m25p_probe(struct spi_device *spi)
                 }
 
                 if (nr_parts > 0) {
-                        for (i = 0; i < data->nr_parts; i++) {
+                        for (i = 0; i < nr_parts; i++) {
                                 DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
                                         "{.name = %s, .offset = 0x%.8x, "
-                                                ".size = 0x%.8x (%uK) }\n",
-                                        i, data->parts[i].name,
-                                        data->parts[i].offset,
-                                        data->parts[i].size,
-                                        data->parts[i].size / 1024);
+                                                ".size = 0x%.8x (%uKiB) }\n",
+                                        i, parts[i].name,
+                                        parts[i].offset,
+                                        parts[i].size,
+                                        parts[i].size / 1024);
                         }
                         flash->partitioned = 1;
                         return add_mtd_partitions(&flash->mtd, parts, nr_parts);
@@ -560,6 +684,11 @@ static struct spi_driver m25p80_driver = {
         },
         .probe  = m25p_probe,
         .remove = __devexit_p(m25p_remove),
+
+        /* REVISIT: many of these chips have deep power-down modes, which
+         * should clearly be entered on suspend() to minimize power use.
+         * And also when they're otherwise idle...
+         */
 };
 
 
diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
index a987e917f4..a5ed6d232c 100644
--- a/drivers/mtd/devices/mtd_dataflash.c
+++ b/drivers/mtd/devices/mtd_dataflash.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/flash.h>
 
@@ -89,7 +90,7 @@ struct dataflash {
         unsigned short          page_offset;    /* offset in flash address */
         unsigned int            page_size;      /* of bytes per page */
 
-        struct semaphore        lock;
+        struct mutex            lock;
         struct spi_device       *spi;
 
         struct mtd_info         mtd;
@@ -167,7 +168,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
         x.len = 4;
         spi_message_add_tail(&x, &msg);
 
-        down(&priv->lock);
+        mutex_lock(&priv->lock);
         while (instr->len > 0) {
                 unsigned int    pageaddr;
                 int             status;
@@ -210,7 +211,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
                         instr->len -= priv->page_size;
                 }
         }
-        up(&priv->lock);
+        mutex_unlock(&priv->lock);
 
         /* Inform MTD subsystem that erase is complete */
         instr->state = MTD_ERASE_DONE;
@@ -266,7 +267,7 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
         x[1].len = len;
         spi_message_add_tail(&x[1], &msg);
 
-        down(&priv->lock);
+        mutex_lock(&priv->lock);
 
         /* Continuous read, max clock = f(car) which may be less than
          * the peak rate available.  Some chips support commands with
@@ -279,7 +280,7 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
         /* plus 4 "don't care" bytes */
 
         status = spi_sync(priv->spi, &msg);
-        up(&priv->lock);
+        mutex_unlock(&priv->lock);
 
         if (status >= 0) {
                 *retlen = msg.actual_length - 8;
@@ -336,7 +337,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
         else
                 writelen = len;
 
-        down(&priv->lock);
+        mutex_lock(&priv->lock);
         while (remaining > 0) {
                 DEBUG(MTD_DEBUG_LEVEL3, "write @ %i:%i len=%i\n",
                         pageaddr, offset, writelen);
@@ -441,7 +442,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                 else
                         writelen = remaining;
         }
-        up(&priv->lock);
+        mutex_unlock(&priv->lock);
 
         return status;
 }
@@ -463,7 +464,7 @@ add_dataflash(struct spi_device *spi, char *name,
         if (!priv)
                 return -ENOMEM;
 
-        init_MUTEX(&priv->lock);
+        mutex_init(&priv->lock);
         priv->spi = spi;
         priv->page_size = pagesize;
         priv->page_offset = pageoffset;
diff --git a/drivers/mtd/devices/pmc551.c b/drivers/mtd/devices/pmc551.c
index e8f686f7a3..7060a0895c 100644
--- a/drivers/mtd/devices/pmc551.c
+++ b/drivers/mtd/devices/pmc551.c
@@ -30,8 +30,8 @@
  *
  * Notes:
  *      Due to what I assume is more buggy SROM, the 64M PMC551 I
- *      have available claims that all 4 of it's DRAM banks have 64M
- *      of ram configured (making a grand total of 256M onboard).
+ *      have available claims that all 4 of its DRAM banks have 64MiB
+ *      of ram configured (making a grand total of 256MiB onboard).
  *      This is slightly annoying since the BAR0 size reflects the
  *      aperture size, not the dram size, and the V370PDC supplies no
  *      other method for memory size discovery.  This problem is
@@ -70,7 +70,7 @@
  *       made the memory unusable, added a fix to code to touch up
  *       the DRAM some.
  *
- * Bugs/FIXME's:
+ * Bugs/FIXMEs:
  *      * MUST fix the init function to not spin on a register
  *      waiting for it to set .. this does not safely handle busted
  *      devices that never reset the register correctly which will
@@ -562,10 +562,10 @@ static u32 fixup_pmc551(struct pci_dev *dev)
         /*
          * Some screen fun
          */
-        printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at "
+        printk(KERN_DEBUG "pmc551: %d%sB (0x%x) of %sprefetchable memory at "
                 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ?
                 size >> 10 : size >> 20,
-                (size < 1024) ? 'B' : (size < 1048576) ? 'K' : 'M', size,
+                (size < 1024) ? "" : (size < 1048576) ? "Ki" : "Mi", size,
                 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "",
                 (unsigned long long)pci_resource_start(dev, 0));
 
@@ -649,14 +649,10 @@ MODULE_DESCRIPTION(PMC551_VERSION);
  * Stuff these outside the ifdef so as to not bust compiled in driver support
  */
 static int msize = 0;
-#if defined(CONFIG_MTD_PMC551_APERTURE_SIZE)
-static int asize = CONFIG_MTD_PMC551_APERTURE_SIZE;
-#else
 static int asize = 0;
-#endif
 
 module_param(msize, int, 0);
-MODULE_PARM_DESC(msize, "memory size in Megabytes [1 - 1024]");
+MODULE_PARM_DESC(msize, "memory size in MiB [1 - 1024]");
 module_param(asize, int, 0);
 MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
 
@@ -799,8 +795,7 @@ static int __init init_pmc551(void)
                 mtd->owner = THIS_MODULE;
 
                 if (add_mtd_device(mtd)) {
-                        printk(KERN_NOTICE "pmc551: Failed to register new "
-                                "device\n");
+                        printk(KERN_NOTICE "pmc551: Failed to register new device\n");
                         pci_iounmap(PCI_Device, priv->start);
                         kfree(mtd->priv);
                         kfree(mtd);
@@ -811,13 +806,13 @@ static int __init init_pmc551(void)
                 pci_dev_get(PCI_Device);
 
                 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
-                printk(KERN_NOTICE "Mapped %dM of memory from 0x%p to 0x%p\n",
+                printk(KERN_NOTICE "Mapped %dMiB of memory from 0x%p to 0x%p\n",
                         priv->asize >> 20,
                         priv->start, priv->start + priv->asize);
-                printk(KERN_NOTICE "Total memory is %d%c\n",
+                printk(KERN_NOTICE "Total memory is %d%sB\n",
                         (length < 1024) ? length :
                         (length < 1048576) ? length >> 10 : length >> 20,
-                        (length < 1024) ? 'B' : (length < 1048576) ? 'K' : 'M');
+                        (length < 1024) ? "" : (length < 1048576) ? "Ki" : "Mi");
                 priv->nextpmc551 = pmc551list;
                 pmc551list = mtd;
                 found++;
@@ -850,7 +845,7 @@ static void __exit cleanup_pmc551(void)
                 pmc551list = priv->nextpmc551;
 
                 if (priv->start) {
-                        printk(KERN_DEBUG "pmc551: unmapping %dM starting at "
+                        printk(KERN_DEBUG "pmc551: unmapping %dMiB starting at "
                                 "0x%p\n", priv->asize >> 20, priv->start);
                         pci_iounmap(priv->dev, priv->start);
                 }
diff --git a/drivers/mtd/inftlmount.c b/drivers/mtd/inftlmount.c
index ecac0e438f..b8917beeb6 100644
--- a/drivers/mtd/inftlmount.c
+++ b/drivers/mtd/inftlmount.c
@@ -580,14 +580,13 @@ int INFTL_mount(struct INFTLrecord *s)
         logical_block = block = BLOCK_NIL;
 
         /* Temporary buffer to store ANAC numbers. */
-        ANACtable = kmalloc(s->nb_blocks * sizeof(u8), GFP_KERNEL);
+        ANACtable = kcalloc(s->nb_blocks, sizeof(u8), GFP_KERNEL);
         if (!ANACtable) {
                 printk(KERN_WARNING "INFTL: allocation of ANACtable "
                                 "failed (%zd bytes)\n",
                                 s->nb_blocks * sizeof(u8));
                 return -ENOMEM;
         }
-        memset(ANACtable, 0, s->nb_blocks);
 
         /*
          * First pass is to explore each physical unit, and construct the
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 6cd132c751..2a2a125b0c 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -163,20 +163,12 @@ config MTD_SBC_GXX
           More info at
           <http://www.arcomcontrols.com/products/icp/pc104/processors/SBC_GX1.htm>.
 
-config MTD_LUBBOCK
-        tristate "CFI Flash device mapped on Intel Lubbock XScale eval board"
-        depends on ARCH_LUBBOCK && MTD_CFI_INTELEXT && MTD_PARTITIONS
-        help
-          This provides a driver for the on-board flash of the Intel
-          'Lubbock' XScale evaluation board.
-
-config MTD_MAINSTONE
-        tristate "CFI Flash device mapped on Intel Mainstone XScale eval board"
-        depends on MACH_MAINSTONE && MTD_CFI_INTELEXT
+config MTD_PXA2XX
+        tristate "CFI Flash device mapped on Intel XScale PXA2xx based boards"
+        depends on (PXA25x || PXA27x) && MTD_CFI_INTELEXT
         select MTD_PARTITIONS
         help
-          This provides a driver for the on-board flash of the Intel
-          'Mainstone PXA27x evaluation board.
+          This provides a driver for the NOR flash attached to a PXA2xx chip.
 
 config MTD_OCTAGON
         tristate "JEDEC Flash device mapped on Octagon 5066 SBC"
@@ -354,7 +346,7 @@ config MTD_CFI_FLAGADM
 
 config MTD_WALNUT
         tristate "Flash device mapped on IBM 405GP Walnut"
-        depends on MTD_JEDECPROBE && WALNUT
+        depends on MTD_JEDECPROBE && WALNUT && !PPC_MERGE
         help
           This enables access routines for the flash chips on the IBM 405GP
           Walnut board. If you have one of these boards and would like to
@@ -370,7 +362,7 @@ config MTD_EBONY
 
 config MTD_OCOTEA
         tristate "Flash devices mapped on IBM 440GX Ocotea"
-        depends on MTD_CFI && OCOTEA
+        depends on MTD_CFI && OCOTEA && !PPC_MERGE
         help
           This enables access routines for the flash chips on the IBM 440GX
           Ocotea board. If you have one of these boards and would like to
@@ -384,22 +376,6 @@ config MTD_REDWOOD
           Redwood board. If you have one of these boards and would like to
           use the flash chips on it, say 'Y'.
 
-config MTD_TQM834x
-        tristate "Flash device mapped on TQ Components TQM834x Boards"
-        depends on MTD_CFI && TQM834x
-        help
-          This enables access routines for the flash chips on the
-          TQ Components TQM834x boards. If you have one of these boards
-          and would like to use the flash chips on it, say 'Y'.
-
-config MTD_OCELOT
-        tristate "Momenco Ocelot boot flash device"
-        depends on MOMENCO_OCELOT
-        help
-          This enables access routines for the boot flash device and for the
-          NVRAM on the Momenco Ocelot board. If you have one of these boards
-          and would like access to either of these, say 'Y'.
-
 config MTD_SOLUTIONENGINE
         tristate "CFI Flash device mapped on Hitachi SolutionEngine"
         depends on SUPERH && MTD_CFI && MTD_REDBOOT_PARTS
@@ -605,6 +581,13 @@ config MTD_SHARP_SL
         help
           This enables access to the flash chip on the Sharp SL Series of PDAs.
 
+config MTD_INTEL_VR_NOR
+        tristate "NOR flash on Intel Vermilion Range Expansion Bus CS0"
+        depends on PCI
+        help
+          Map driver for a NOR flash bank located on the Expansion Bus of the
+          Intel Vermilion Range chipset.
+
 config MTD_PLATRAM
         tristate "Map driver for platform device RAM (mtd-ram)"
         select MTD_RAM
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile
index 970b189271..316382a140 100644
--- a/drivers/mtd/maps/Makefile
+++ b/drivers/mtd/maps/Makefile
@@ -20,8 +20,7 @@ obj-$(CONFIG_MTD_ESB2ROM)	+= esb2rom.o
 obj-$(CONFIG_MTD_ICHXROM)       += ichxrom.o
 obj-$(CONFIG_MTD_CK804XROM)     += ck804xrom.o
 obj-$(CONFIG_MTD_TSUNAMI)       += tsunami_flash.o
-obj-$(CONFIG_MTD_LUBBOCK)       += lubbock-flash.o
-obj-$(CONFIG_MTD_MAINSTONE)     += mainstone-flash.o
+obj-$(CONFIG_MTD_PXA2XX)        += pxa2xx-flash.o
 obj-$(CONFIG_MTD_MBX860)        += mbx860.o
 obj-$(CONFIG_MTD_CEIVA)         += ceiva.o
 obj-$(CONFIG_MTD_OCTAGON)       += octagon-5066.o
@@ -43,7 +42,6 @@ obj-$(CONFIG_MTD_SUN_UFLASH)	+= sun_uflash.o
 obj-$(CONFIG_MTD_VMAX)          += vmax301.o
 obj-$(CONFIG_MTD_SCx200_DOCFLASH)+= scx200_docflash.o
 obj-$(CONFIG_MTD_DBOX2)         += dbox2-flash.o
-obj-$(CONFIG_MTD_OCELOT)        += ocelot.o
 obj-$(CONFIG_MTD_SOLUTIONENGINE)+= solutionengine.o
 obj-$(CONFIG_MTD_PCI)           += pci.o
 obj-$(CONFIG_MTD_ALCHEMY)       += alchemy-flash.o
@@ -70,4 +68,4 @@ obj-$(CONFIG_MTD_SHARP_SL)	+= sharpsl-flash.o
 obj-$(CONFIG_MTD_PLATRAM)       += plat-ram.o
 obj-$(CONFIG_MTD_OMAP_NOR)      += omap_nor.o
 obj-$(CONFIG_MTD_MTX1)          += mtx-1_flash.o
-obj-$(CONFIG_MTD_TQM834x)       += tqm834x.o
+obj-$(CONFIG_MTD_INTEL_VR_NOR)  += intel_vr_nor.o
diff --git a/drivers/mtd/maps/alchemy-flash.c b/drivers/mtd/maps/alchemy-flash.c
index 84fbe0e8c4..82811bcb04 100644
--- a/drivers/mtd/maps/alchemy-flash.c
+++ b/drivers/mtd/maps/alchemy-flash.c
@@ -75,13 +75,6 @@
 #define BOARD_FLASH_WIDTH 2 /* 16-bits */
 #endif
 
-#ifdef CONFIG_MIPS_HYDROGEN3
-#define BOARD_MAP_NAME "Hydrogen3 Flash"
-#define BOARD_FLASH_SIZE 0x02000000 /* 32MB */
-#define BOARD_FLASH_WIDTH 4 /* 32-bits */
-#define USE_LOCAL_ACCESSORS /* why? */
-#endif
-
 #ifdef CONFIG_MIPS_BOSPORUS
 #define BOARD_MAP_NAME "Bosporus Flash"
 #define BOARD_FLASH_SIZE 0x01000000 /* 16MB */
@@ -130,13 +123,6 @@ int __init alchemy_mtd_init(void)
 
         window_addr = 0x20000000 - BOARD_FLASH_SIZE;
         window_size = BOARD_FLASH_SIZE;
-#ifdef CONFIG_MIPS_MIRAGE_WHY
-        /* Boot ROM flash bank only; no user bank */
-        window_addr = 0x1C000000;
-        window_size = 0x04000000;
-        /* USERFS from 0x1C00 0000 to 0x1FC00000 */
-        alchemy_partitions[0].size = 0x03C00000;
-#endif
 
         /*
          * Static partition definition selection
diff --git a/drivers/mtd/maps/intel_vr_nor.c b/drivers/mtd/maps/intel_vr_nor.c
new file mode 100644
index 0000000000..1e7814ae21
--- /dev/null
+++ b/drivers/mtd/maps/intel_vr_nor.c
@@ -0,0 +1,298 @@
+/*
+ * drivers/mtd/maps/intel_vr_nor.c
+ *
+ * An MTD map driver for a NOR flash bank on the Expansion Bus of the Intel
+ * Vermilion Range chipset.
+ *
+ * The Vermilion Range Expansion Bus supports four chip selects, each of which
+ * has 64MiB of address space.  The 2nd BAR of the Expansion Bus PCI Device
+ * is a 256MiB memory region containing the address spaces for all four of the
+ * chip selects, with start addresses hardcoded on 64MiB boundaries.
+ *
+ * This map driver only supports NOR flash on chip select 0.  The buswidth
+ * (either 8 bits or 16 bits) is determined by reading the Expansion Bus Timing
+ * and Control Register for Chip Select 0 (EXP_TIMING_CS0).  This driver does
+ * not modify the value in the EXP_TIMING_CS0 register except to enable writing
+ * and disable boot acceleration.  The timing parameters in the register are
+ * assumed to have been properly initialized by the BIOS.  The reset default
+ * timing parameters are maximally conservative (slow), so access to the flash
+ * will be slower than it should be if the BIOS has not initialized the timing
+ * parameters.
+ *
+ * Author: Andy Lowe <alowe@mvista.com>
+ *
+ * 2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/cfi.h>
+#include <linux/mtd/flashchip.h>
+
+#define DRV_NAME "vr_nor"
+
+struct vr_nor_mtd {
+        void __iomem *csr_base;
+        struct map_info map;
+        struct mtd_info *info;
+        int nr_parts;
+        struct pci_dev *dev;
+};
+
+/* Expansion Bus Configuration and Status Registers are in BAR 0 */
+#define EXP_CSR_MBAR 0
+/* Expansion Bus Memory Window is BAR 1 */
+#define EXP_WIN_MBAR 1
+/* Maximum address space for Chip Select 0 is 64MiB */
+#define CS0_SIZE 0x04000000
+/* Chip Select 0 is at offset 0 in the Memory Window */
+#define CS0_START 0x0
+/* Chip Select 0 Timing Register is at offset 0 in CSR */
+#define EXP_TIMING_CS0 0x00
+#define TIMING_CS_EN            (1 << 31)       /* Chip Select Enable */
+#define TIMING_BOOT_ACCEL_DIS   (1 <<  8)       /* Boot Acceleration Disable */
+#define TIMING_WR_EN            (1 <<  1)       /* Write Enable */
+#define TIMING_BYTE_EN          (1 <<  0)       /* 8-bit vs 16-bit bus */
+#define TIMING_MASK             0x3FFF0000
+
+static void __devexit vr_nor_destroy_partitions(struct vr_nor_mtd *p)
+{
+        if (p->nr_parts > 0) {
+#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
+                del_mtd_partitions(p->info);
+#endif
+        } else
+                del_mtd_device(p->info);
+}
+
+static int __devinit vr_nor_init_partitions(struct vr_nor_mtd *p)
+{
+        int err = 0;
+#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
+        struct mtd_partition *parts;
+        static const char *part_probes[] = { "cmdlinepart", NULL };
+#endif
+
+        /* register the flash bank */
+#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
+        /* partition the flash bank */
+        p->nr_parts = parse_mtd_partitions(p->info, part_probes, &parts, 0);
+        if (p->nr_parts > 0)
+                err = add_mtd_partitions(p->info, parts, p->nr_parts);
+#endif
+        if (p->nr_parts <= 0)
+                err = add_mtd_device(p->info);
+
+        return err;
+}
+
+static void __devexit vr_nor_destroy_mtd_setup(struct vr_nor_mtd *p)
+{
+        map_destroy(p->info);
+}
+
+static int __devinit vr_nor_mtd_setup(struct vr_nor_mtd *p)
+{
+        static const char *probe_types[] =
+            { "cfi_probe", "jedec_probe", NULL };
+        const char **type;
+
+        for (type = probe_types; !p->info && *type; type++)
+                p->info = do_map_probe(*type, &p->map);
+        if (!p->info)
+                return -ENODEV;
+
+        p->info->owner = THIS_MODULE;
+
+        return 0;
+}
+
+static void __devexit vr_nor_destroy_maps(struct vr_nor_mtd *p)
+{
+        unsigned int exp_timing_cs0;
+
+        /* write-protect the flash bank */
+        exp_timing_cs0 = readl(p->csr_base + EXP_TIMING_CS0);
+        exp_timing_cs0 &= ~TIMING_WR_EN;
+        writel(exp_timing_cs0, p->csr_base + EXP_TIMING_CS0);
+
+        /* unmap the flash window */
+        iounmap(p->map.virt);
+
+        /* unmap the csr window */
+        iounmap(p->csr_base);
+}
+
+/*
+ * Initialize the map_info structure and map the flash.
+ * Returns 0 on success, nonzero otherwise.
+ */
+static int __devinit vr_nor_init_maps(struct vr_nor_mtd *p)
+{
+        unsigned long csr_phys, csr_len;
+        unsigned long win_phys, win_len;
+        unsigned int exp_timing_cs0;
+        int err;
+
+        csr_phys = pci_resource_start(p->dev, EXP_CSR_MBAR);
+        csr_len = pci_resource_len(p->dev, EXP_CSR_MBAR);
+        win_phys = pci_resource_start(p->dev, EXP_WIN_MBAR);
+        win_len = pci_resource_len(p->dev, EXP_WIN_MBAR);
+
+        if (!csr_phys || !csr_len || !win_phys || !win_len)
+                return -ENODEV;
+
+        if (win_len < (CS0_START + CS0_SIZE))
+                return -ENXIO;
+
+        p->csr_base = ioremap_nocache(csr_phys, csr_len);
+        if (!p->csr_base)
+                return -ENOMEM;
+
+        exp_timing_cs0 = readl(p->csr_base + EXP_TIMING_CS0);
+        if (!(exp_timing_cs0 & TIMING_CS_EN)) {
+                dev_warn(&p->dev->dev, "Expansion Bus Chip Select 0 "
+                       "is disabled.\n");
+                err = -ENODEV;
+                goto release;
+        }
+        if ((exp_timing_cs0 & TIMING_MASK) == TIMING_MASK) {
+                dev_warn(&p->dev->dev, "Expansion Bus Chip Select 0 "
+                       "is configured for maximally slow access times.\n");
+        }
+        p->map.name = DRV_NAME;
+        p->map.bankwidth = (exp_timing_cs0 & TIMING_BYTE_EN) ? 1 : 2;
+        p->map.phys = win_phys + CS0_START;
+        p->map.size = CS0_SIZE;
+        p->map.virt = ioremap_nocache(p->map.phys, p->map.size);
+        if (!p->map.virt) {
+                err = -ENOMEM;
+                goto release;
+        }
+        simple_map_init(&p->map);
+
+        /* Enable writes to flash bank */
+        exp_timing_cs0 |= TIMING_BOOT_ACCEL_DIS | TIMING_WR_EN;
+        writel(exp_timing_cs0, p->csr_base + EXP_TIMING_CS0);
+
+        return 0;
+
+      release:
+        iounmap(p->csr_base);
+        return err;
+}
+
+static struct pci_device_id vr_nor_pci_ids[] = {
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x500D)},
+        {0,}
+};
+
+static void __devexit vr_nor_pci_remove(struct pci_dev *dev)
+{
+        struct vr_nor_mtd *p = pci_get_drvdata(dev);
+
+        pci_set_drvdata(dev, NULL);
+        vr_nor_destroy_partitions(p);
+        vr_nor_destroy_mtd_setup(p);
+        vr_nor_destroy_maps(p);
+        kfree(p);
+        pci_release_regions(dev);
+        pci_disable_device(dev);
+}
+
+static int __devinit
+vr_nor_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+        struct vr_nor_mtd *p = NULL;
+        unsigned int exp_timing_cs0;
+        int err;
+
+        err = pci_enable_device(dev);
+        if (err)
+                goto out;
+
+        err = pci_request_regions(dev, DRV_NAME);
+        if (err)
+                goto disable_dev;
+
+        p = kzalloc(sizeof(*p), GFP_KERNEL);
+        err = -ENOMEM;
+        if (!p)
+                goto release;
+
+        p->dev = dev;
+
+        err = vr_nor_init_maps(p);
+        if (err)
+                goto release;
+
+        err = vr_nor_mtd_setup(p);
+        if (err)
+                goto destroy_maps;
+
+        err = vr_nor_init_partitions(p);
+        if (err)
+                goto destroy_mtd_setup;
+
+        pci_set_drvdata(dev, p);
+
+        return 0;
+
+      destroy_mtd_setup:
+        map_destroy(p->info);
+
+      destroy_maps:
+        /* write-protect the flash bank */
+        exp_timing_cs0 = readl(p->csr_base + EXP_TIMING_CS0);
+        exp_timing_cs0 &= ~TIMING_WR_EN;
+        writel(exp_timing_cs0, p->csr_base + EXP_TIMING_CS0);
+
+        /* unmap the flash window */
+        iounmap(p->map.virt);
+
+        /* unmap the csr window */
+        iounmap(p->csr_base);
+
+      release:
+        kfree(p);
+        pci_release_regions(dev);
+
+      disable_dev:
+        pci_disable_device(dev);
+
+      out:
+        return err;
+}
+
+static struct pci_driver vr_nor_pci_driver = {
+        .name = DRV_NAME,
+        .probe = vr_nor_pci_probe,
+        .remove = __devexit_p(vr_nor_pci_remove),
+        .id_table = vr_nor_pci_ids,
+};
+
+static int __init vr_nor_mtd_init(void)
+{
+        return pci_register_driver(&vr_nor_pci_driver);
+}
+
+static void __exit vr_nor_mtd_exit(void)
+{
+        pci_unregister_driver(&vr_nor_pci_driver);
+}
+
+module_init(vr_nor_mtd_init);
+module_exit(vr_nor_mtd_exit);
+
+MODULE_AUTHOR("Andy Lowe");
+MODULE_DESCRIPTION("MTD map driver for NOR flash on Intel Vermilion Range");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, vr_nor_pci_ids);
diff --git a/drivers/mtd/maps/lubbock-flash.c b/drivers/mtd/maps/lubbock-flash.c
deleted file mode 100644
index e8560683b9..0000000000
--- a/drivers/mtd/maps/lubbock-flash.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * $Id: lubbock-flash.c,v 1.21 2005/11/07 11:14:27 gleixner Exp $
- *
- * Map driver for the Lubbock developer platform.
- *
- * Author:      Nicolas Pitre
- * Copyright:   (C) 2001 MontaVista Software 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/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#include <asm/io.h>
-#include <asm/hardware.h>
-#include <asm/arch/pxa-regs.h>
-#include <asm/arch/lubbock.h>
-#include <asm/cacheflush.h>
-
-#define ROM_ADDR        0x00000000
-#define FLASH_ADDR      0x04000000
-
-#define WINDOW_SIZE     64*1024*1024
-
-static void lubbock_map_inval_cache(struct map_info *map, unsigned long from, ssize_t len)
-{
-        flush_ioremap_region(map->phys, map->cached, from, len);
-}
-
-static struct map_info lubbock_maps[2] = { {
-        .size =         WINDOW_SIZE,
-        .phys =         0x00000000,
-        .inval_cache =  lubbock_map_inval_cache,
-}, {
-        .size =         WINDOW_SIZE,
-        .phys =         0x04000000,
-        .inval_cache =  lubbock_map_inval_cache,
-} };
-
-static struct mtd_partition lubbock_partitions[] = {
-        {
-                .name =         "Bootloader",
-                .size =         0x00040000,
-                .offset =       0,
-                .mask_flags =   MTD_WRITEABLE  /* force read-only */
-        },{
-                .name =         "Kernel",
-                .size =         0x00100000,
-                .offset =       0x00040000,
-        },{
-                .name =         "Filesystem",
-                .size =         MTDPART_SIZ_FULL,
-                .offset =       0x00140000
-        }
-};
-
-static struct mtd_info *mymtds[2];
-static struct mtd_partition *parsed_parts[2];
-static int nr_parsed_parts[2];
-
-static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
-
-static int __init init_lubbock(void)
-{
-        int flashboot = (LUB_CONF_SWITCHES & 1);
-        int ret = 0, i;
-
-        lubbock_maps[0].bankwidth = lubbock_maps[1].bankwidth =
-                (BOOT_DEF & 1) ? 2 : 4;
-
-        /* Compensate for the nROMBT switch which swaps the flash banks */
-        printk(KERN_NOTICE "Lubbock configured to boot from %s (bank %d)\n",
-               flashboot?"Flash":"ROM", flashboot);
-
-        lubbock_maps[flashboot^1].name = "Lubbock Application Flash";
-        lubbock_maps[flashboot].name = "Lubbock Boot ROM";
-
-        for (i = 0; i < 2; i++) {
-                lubbock_maps[i].virt = ioremap(lubbock_maps[i].phys, WINDOW_SIZE);
-                if (!lubbock_maps[i].virt) {
-                        printk(KERN_WARNING "Failed to ioremap %s\n", lubbock_maps[i].name);
-                        if (!ret)
-                                ret = -ENOMEM;
-                        continue;
-                }
-                lubbock_maps[i].cached = ioremap_cached(lubbock_maps[i].phys, WINDOW_SIZE);
-                if (!lubbock_maps[i].cached)
-                        printk(KERN_WARNING "Failed to ioremap cached %s\n", lubbock_maps[i].name);
-                simple_map_init(&lubbock_maps[i]);
-
-                printk(KERN_NOTICE "Probing %s at physical address 0x%08lx (%d-bit bankwidth)\n",
-                       lubbock_maps[i].name, lubbock_maps[i].phys,
-                       lubbock_maps[i].bankwidth * 8);
-
-                mymtds[i] = do_map_probe("cfi_probe", &lubbock_maps[i]);
-
-                if (!mymtds[i]) {
-                        iounmap((void *)lubbock_maps[i].virt);
-                        if (lubbock_maps[i].cached)
-                                iounmap(lubbock_maps[i].cached);
-                        if (!ret)
-                                ret = -EIO;
-                        continue;
-                }
-                mymtds[i]->owner = THIS_MODULE;
-
-                ret = parse_mtd_partitions(mymtds[i], probes,
-                                           &parsed_parts[i], 0);
-
-                if (ret > 0)
-                        nr_parsed_parts[i] = ret;
-        }
-
-        if (!mymtds[0] && !mymtds[1])
-                return ret;
-
-        for (i = 0; i < 2; i++) {
-                if (!mymtds[i]) {
-                        printk(KERN_WARNING "%s is absent. Skipping\n", lubbock_maps[i].name);
-                } else if (nr_parsed_parts[i]) {
-                        add_mtd_partitions(mymtds[i], parsed_parts[i], nr_parsed_parts[i]);
-                } else if (!i) {
-                        printk("Using static partitions on %s\n", lubbock_maps[i].name);
-                        add_mtd_partitions(mymtds[i], lubbock_partitions, ARRAY_SIZE(lubbock_partitions));
-                } else {
-                        printk("Registering %s as whole device\n", lubbock_maps[i].name);
-                        add_mtd_device(mymtds[i]);
-                }
-        }
-        return 0;
-}
-
-static void __exit cleanup_lubbock(void)
-{
-        int i;
-        for (i = 0; i < 2; i++) {
-                if (!mymtds[i])
-                        continue;
-
-                if (nr_parsed_parts[i] || !i)
-                        del_mtd_partitions(mymtds[i]);
-                else
-                        del_mtd_device(mymtds[i]);
-
-                map_destroy(mymtds[i]);
-                iounmap((void *)lubbock_maps[i].virt);
-                if (lubbock_maps[i].cached)
-                        iounmap(lubbock_maps[i].cached);
-
-                kfree(parsed_parts[i]);
-        }
-}
-
-module_init(init_lubbock);
-module_exit(cleanup_lubbock);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>");
-MODULE_DESCRIPTION("MTD map driver for Intel Lubbock");
diff --git a/drivers/mtd/maps/mainstone-flash.c b/drivers/mtd/maps/mainstone-flash.c
deleted file mode 100644
index d76487d82d..0000000000
--- a/drivers/mtd/maps/mainstone-flash.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * $Id:  $
- *
- * Map driver for the Mainstone developer platform.
- *
- * Author:      Nicolas Pitre
- * Copyright:   (C) 2001 MontaVista Software 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/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#include <asm/io.h>
-#include <asm/hardware.h>
-#include <asm/arch/pxa-regs.h>
-#include <asm/arch/mainstone.h>
-#include <asm/cacheflush.h>
-
-
-#define ROM_ADDR        0x00000000
-#define FLASH_ADDR      0x04000000
-
-#define WINDOW_SIZE     0x04000000
-
-static void mainstone_map_inval_cache(struct map_info *map, unsigned long from,
-                                      ssize_t len)
-{
-        flush_ioremap_region(map->phys, map->cached, from, len);
-}
-
-static struct map_info mainstone_maps[2] = { {
-        .size =         WINDOW_SIZE,
-        .phys =         PXA_CS0_PHYS,
-        .inval_cache =  mainstone_map_inval_cache,
-}, {
-        .size =         WINDOW_SIZE,
-        .phys =         PXA_CS1_PHYS,
-        .inval_cache =  mainstone_map_inval_cache,
-} };
-
-static struct mtd_partition mainstone_partitions[] = {
-        {
-                .name =         "Bootloader",
-                .size =         0x00040000,
-                .offset =       0,
-                .mask_flags =   MTD_WRITEABLE  /* force read-only */
-        },{
-                .name =         "Kernel",
-                .size =         0x00400000,
-                .offset =       0x00040000,
-        },{
-                .name =         "Filesystem",
-                .size =         MTDPART_SIZ_FULL,
-                .offset =       0x00440000
-        }
-};
-
-static struct mtd_info *mymtds[2];
-static struct mtd_partition *parsed_parts[2];
-static int nr_parsed_parts[2];
-
-static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
-
-static int __init init_mainstone(void)
-{
-        int SW7 = 0;  /* FIXME: get from SCR (Mst doc section 3.2.1.1) */
-        int ret = 0, i;
-
-        mainstone_maps[0].bankwidth = (BOOT_DEF & 1) ? 2 : 4;
-        mainstone_maps[1].bankwidth = 4;
-
-        /* Compensate for SW7 which swaps the flash banks */
-        mainstone_maps[SW7].name = "processor flash";
-        mainstone_maps[SW7 ^ 1].name = "main board flash";
-
-        printk(KERN_NOTICE "Mainstone configured to boot from %s\n",
-               mainstone_maps[0].name);
-
-        for (i = 0; i < 2; i++) {
-                mainstone_maps[i].virt = ioremap(mainstone_maps[i].phys,
-                                                 WINDOW_SIZE);
-                if (!mainstone_maps[i].virt) {
-                        printk(KERN_WARNING "Failed to ioremap %s\n",
-                               mainstone_maps[i].name);
-                        if (!ret)
-                                ret = -ENOMEM;
-                        continue;
-                }
-                mainstone_maps[i].cached =
-                        ioremap_cached(mainstone_maps[i].phys, WINDOW_SIZE);
-                if (!mainstone_maps[i].cached)
-                        printk(KERN_WARNING "Failed to ioremap cached %s\n",
-                               mainstone_maps[i].name);
-                simple_map_init(&mainstone_maps[i]);
-
-                printk(KERN_NOTICE
-                       "Probing %s at physical address 0x%08lx"
-                       " (%d-bit bankwidth)\n",
-                       mainstone_maps[i].name, mainstone_maps[i].phys,
-                       mainstone_maps[i].bankwidth * 8);
-
-                mymtds[i] = do_map_probe("cfi_probe", &mainstone_maps[i]);
-
-                if (!mymtds[i]) {
-                        iounmap((void *)mainstone_maps[i].virt);
-                        if (mainstone_maps[i].cached)
-                                iounmap(mainstone_maps[i].cached);
-                        if (!ret)
-                                ret = -EIO;
-                        continue;
-                }
-                mymtds[i]->owner = THIS_MODULE;
-
-                ret = parse_mtd_partitions(mymtds[i], probes,
-                                           &parsed_parts[i], 0);
-
-                if (ret > 0)
-                        nr_parsed_parts[i] = ret;
-        }
-
-        if (!mymtds[0] && !mymtds[1])
-                return ret;
-
-        for (i = 0; i < 2; i++) {
-                if (!mymtds[i]) {
-                        printk(KERN_WARNING "%s is absent. Skipping\n",
-                               mainstone_maps[i].name);
-                } else if (nr_parsed_parts[i]) {
-                        add_mtd_partitions(mymtds[i], parsed_parts[i],
-                                           nr_parsed_parts[i]);
-                } else if (!i) {
-                        printk("Using static partitions on %s\n",
-                               mainstone_maps[i].name);
-                        add_mtd_partitions(mymtds[i], mainstone_partitions,
-                                           ARRAY_SIZE(mainstone_partitions));
-                } else {
-                        printk("Registering %s as whole device\n",
-                               mainstone_maps[i].name);
-                        add_mtd_device(mymtds[i]);
-                }
-        }
-        return 0;
-}
-
-static void __exit cleanup_mainstone(void)
-{
-        int i;
-        for (i = 0; i < 2; i++) {
-                if (!mymtds[i])
-                        continue;
-
-                if (nr_parsed_parts[i] || !i)
-                        del_mtd_partitions(mymtds[i]);
-                else
-                        del_mtd_device(mymtds[i]);
-
-                map_destroy(mymtds[i]);
-                iounmap((void *)mainstone_maps[i].virt);
-                if (mainstone_maps[i].cached)
-                        iounmap(mainstone_maps[i].cached);
-                kfree(parsed_parts[i]);
-        }
-}
-
-module_init(init_mainstone);
-module_exit(cleanup_mainstone);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>");
-MODULE_DESCRIPTION("MTD map driver for Intel Mainstone");
diff --git a/drivers/mtd/maps/nettel.c b/drivers/mtd/maps/nettel.c
index 7b96cd02f8..0c9b305a72 100644
--- a/drivers/mtd/maps/nettel.c
+++ b/drivers/mtd/maps/nettel.c
@@ -158,68 +158,11 @@ static struct notifier_block nettel_notifier_block = {
         nettel_reboot_notifier, NULL, 0
 };
 
-/*
- *      Erase the configuration file system.
- *      Used to support the software reset button.
- */
-static void nettel_erasecallback(struct erase_info *done)
-{
-        wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
-        wake_up(wait_q);
-}
-
-static struct erase_info nettel_erase;
-
-int nettel_eraseconfig(void)
-{
-        struct mtd_info *mtd;
-        DECLARE_WAITQUEUE(wait, current);
-        wait_queue_head_t wait_q;
-        int ret;
-
-        init_waitqueue_head(&wait_q);
-        mtd = get_mtd_device(NULL, 2);
-        if (!IS_ERR(mtd)) {
-                nettel_erase.mtd = mtd;
-                nettel_erase.callback = nettel_erasecallback;
-                nettel_erase.callback = NULL;
-                nettel_erase.addr = 0;
-                nettel_erase.len = mtd->size;
-                nettel_erase.priv = (u_long) &wait_q;
-                nettel_erase.priv = 0;
-
-                set_current_state(TASK_INTERRUPTIBLE);
-                add_wait_queue(&wait_q, &wait);
-
-                ret = mtd->erase(mtd, &nettel_erase);
-                if (ret) {
-                        set_current_state(TASK_RUNNING);
-                        remove_wait_queue(&wait_q, &wait);
-                        put_mtd_device(mtd);
-                        return(ret);
-                }
-
-                schedule();  /* Wait for erase to finish. */
-                remove_wait_queue(&wait_q, &wait);
-
-                put_mtd_device(mtd);
-        }
-
-        return(0);
-}
-
-#else
-
-int nettel_eraseconfig(void)
-{
-        return(0);
-}
-
 #endif
 
 /****************************************************************************/
 
-int __init nettel_init(void)
+static int __init nettel_init(void)
 {
         volatile unsigned long *amdpar;
         unsigned long amdaddr, maxsize;
@@ -421,10 +364,6 @@ int __init nettel_init(void)
 
         intel_mtd->owner = THIS_MODULE;
 
-#ifndef CONFIG_BLK_DEV_INITRD
-        ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, 1);
-#endif
-
         num_intel_partitions = sizeof(nettel_intel_partitions) /
                 sizeof(nettel_intel_partitions[0]);
 
@@ -477,7 +416,7 @@ out_unmap2:
 
 /****************************************************************************/
 
-void __exit nettel_cleanup(void)
+static void __exit nettel_cleanup(void)
 {
 #ifdef CONFIG_MTD_CFI_INTELEXT
         unregister_reboot_notifier(&nettel_notifier_block);
diff --git a/drivers/mtd/maps/ocelot.c b/drivers/mtd/maps/ocelot.c
deleted file mode 100644
index 6977963d78..0000000000
--- a/drivers/mtd/maps/ocelot.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * $Id: ocelot.c,v 1.17 2005/11/07 11:14:27 gleixner Exp $
- *
- * Flash on Momenco Ocelot
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <asm/io.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#define OCELOT_PLD 0x2c000000
-#define FLASH_WINDOW_ADDR 0x2fc00000
-#define FLASH_WINDOW_SIZE 0x00080000
-#define FLASH_BUSWIDTH 1
-#define NVRAM_WINDOW_ADDR 0x2c800000
-#define NVRAM_WINDOW_SIZE 0x00007FF0
-#define NVRAM_BUSWIDTH 1
-
-static unsigned int cacheflush = 0;
-
-static struct mtd_info *flash_mtd;
-static struct mtd_info *nvram_mtd;
-
-static void ocelot_ram_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
-{
-        struct map_info *map = mtd->priv;
-        size_t done = 0;
-
-        /* If we use memcpy, it does word-wide writes. Even though we told the
-           GT64120A that it's an 8-bit wide region, word-wide writes don't work.
-           We end up just writing the first byte of the four to all four bytes.
-           So we have this loop instead */
-        *retlen = len;
-        while(len) {
-                __raw_writeb(*(unsigned char *) from, map->virt + to);
-                from++;
-                to++;
-                len--;
-        }
-}
-
-static struct mtd_partition *parsed_parts;
-
-struct map_info ocelot_flash_map = {
-        .name = "Ocelot boot flash",
-        .size = FLASH_WINDOW_SIZE,
-        .bankwidth = FLASH_BUSWIDTH,
-        .phys = FLASH_WINDOW_ADDR,
-};
-
-struct map_info ocelot_nvram_map = {
-        .name = "Ocelot NVRAM",
-        .size = NVRAM_WINDOW_SIZE,
-        .bankwidth = NVRAM_BUSWIDTH,
-        .phys = NVRAM_WINDOW_ADDR,
-};
-
-static const char *probes[] = { "RedBoot", NULL };
-
-static int __init init_ocelot_maps(void)
-{
-        void *pld;
-        int nr_parts;
-        unsigned char brd_status;
-
-        printk(KERN_INFO "Momenco Ocelot MTD mappings: Flash 0x%x at 0x%x, NVRAM 0x%x at 0x%x\n",
-               FLASH_WINDOW_SIZE, FLASH_WINDOW_ADDR, NVRAM_WINDOW_SIZE, NVRAM_WINDOW_ADDR);
-
-        /* First check whether the flash jumper is present */
-        pld = ioremap(OCELOT_PLD, 0x10);
-        if (!pld) {
-                printk(KERN_NOTICE "Failed to ioremap Ocelot PLD\n");
-                return -EIO;
-        }
-        brd_status = readb(pld+4);
-        iounmap(pld);
-
-        /* Now ioremap the NVRAM space */
-        ocelot_nvram_map.virt = ioremap_nocache(NVRAM_WINDOW_ADDR, NVRAM_WINDOW_SIZE);
-        if (!ocelot_nvram_map.virt) {
-                printk(KERN_NOTICE "Failed to ioremap Ocelot NVRAM space\n");
-                return -EIO;
-        }
-
-        simple_map_init(&ocelot_nvram_map);
-
-        /* And do the RAM probe on it to get an MTD device */
-        nvram_mtd = do_map_probe("map_ram", &ocelot_nvram_map);
-        if (!nvram_mtd) {
-                printk("NVRAM probe failed\n");
-                goto fail_1;
-        }
-        nvram_mtd->owner = THIS_MODULE;
-        nvram_mtd->erasesize = 16;
-        /* Override the write() method */
-        nvram_mtd->write = ocelot_ram_write;
-
-        /* Now map the flash space */
-        ocelot_flash_map.virt = ioremap_nocache(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE);
-        if (!ocelot_flash_map.virt) {
-                printk(KERN_NOTICE "Failed to ioremap Ocelot flash space\n");
-                goto fail_2;
-        }
-        /* Now the cached version */
-        ocelot_flash_map.cached = (unsigned long)__ioremap(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE, 0);
-
-        simple_map_init(&ocelot_flash_map);
-
-        /* Only probe for flash if the write jumper is present */
-        if (brd_status & 0x40) {
-                flash_mtd = do_map_probe("jedec", &ocelot_flash_map);
-        } else {
-                printk(KERN_NOTICE "Ocelot flash write jumper not present. Treating as ROM\n");
-        }
-        /* If that failed or the jumper's absent, pretend it's ROM */
-        if (!flash_mtd) {
-                flash_mtd = do_map_probe("map_rom", &ocelot_flash_map);
-                /* If we're treating it as ROM, set the erase size */
-                if (flash_mtd)
-                        flash_mtd->erasesize = 0x10000;
-        }
-        if (!flash_mtd)
-                goto fail3;
-
-        add_mtd_device(nvram_mtd);
-
-        flash_mtd->owner = THIS_MODULE;
-        nr_parts = parse_mtd_partitions(flash_mtd, probes, &parsed_parts, 0);
-
-        if (nr_parts > 0)
-                add_mtd_partitions(flash_mtd, parsed_parts, nr_parts);
-        else
-                add_mtd_device(flash_mtd);
-
-        return 0;
-
- fail3:
-        iounmap((void *)ocelot_flash_map.virt);
-        if (ocelot_flash_map.cached)
-                        iounmap((void *)ocelot_flash_map.cached);
- fail_2:
-        map_destroy(nvram_mtd);
- fail_1:
-        iounmap((void *)ocelot_nvram_map.virt);
-
-        return -ENXIO;
-}
-
-static void __exit cleanup_ocelot_maps(void)
-{
-        del_mtd_device(nvram_mtd);
-        map_destroy(nvram_mtd);
-        iounmap((void *)ocelot_nvram_map.virt);
-
-        if (parsed_parts)
-                del_mtd_partitions(flash_mtd);
-        else
-                del_mtd_device(flash_mtd);
-        map_destroy(flash_mtd);
-        iounmap((void *)ocelot_flash_map.virt);
-        if (ocelot_flash_map.cached)
-                iounmap((void *)ocelot_flash_map.cached);
-}
-
-module_init(init_ocelot_maps);
-module_exit(cleanup_ocelot_maps);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Red Hat, Inc. - David Woodhouse <dwmw2@cambridge.redhat.com>");
-MODULE_DESCRIPTION("MTD map driver for Momenco Ocelot board");
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index cf75a56644..aeed9ea797 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -232,7 +232,6 @@ static int __devinit of_flash_probe(struct of_device *dev,
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info)
                 goto err_out;
-        memset(info, 0, sizeof(*info));
 
         dev_set_drvdata(&dev->dev, info);
 
diff --git a/drivers/mtd/maps/pmcmsp-flash.c b/drivers/mtd/maps/pmcmsp-flash.c
index 7e0377ec1c..02bde8c982 100644
--- a/drivers/mtd/maps/pmcmsp-flash.c
+++ b/drivers/mtd/maps/pmcmsp-flash.c
@@ -73,13 +73,16 @@ int __init init_msp_flash(void)
                 return -ENXIO;
 
         printk(KERN_NOTICE "Found %d PMC flash devices\n", fcnt);
-        msp_flash = (struct mtd_info **)kmalloc(
-                        fcnt * sizeof(struct map_info *), GFP_KERNEL);
-        msp_parts = (struct mtd_partition **)kmalloc(
-                        fcnt * sizeof(struct mtd_partition *), GFP_KERNEL);
-        msp_maps = (struct map_info *)kmalloc(
-                        fcnt * sizeof(struct mtd_info), GFP_KERNEL);
-        memset(msp_maps, 0, fcnt * sizeof(struct mtd_info));
+
+        msp_flash = kmalloc(fcnt * sizeof(struct map_info *), GFP_KERNEL);
+        msp_parts = kmalloc(fcnt * sizeof(struct mtd_partition *), GFP_KERNEL);
+        msp_maps = kcalloc(fcnt, sizeof(struct mtd_info), GFP_KERNEL);
+        if (!msp_flash || !msp_parts || !msp_maps) {
+                kfree(msp_maps);
+                kfree(msp_parts);
+                kfree(msp_flash);
+                return -ENOMEM;
+        }
 
         /* loop over the flash devices, initializing each */
         for (i = 0; i < fcnt; i++) {
@@ -95,9 +98,8 @@ int __init init_msp_flash(void)
                         continue;
                 }
 
-                msp_parts[i] = (struct mtd_partition *)kmalloc(
-                        pcnt * sizeof(struct mtd_partition), GFP_KERNEL);
-                memset(msp_parts[i], 0, pcnt * sizeof(struct mtd_partition));
+                msp_parts[i] = kcalloc(pcnt, sizeof(struct mtd_partition),
+                                       GFP_KERNEL);
 
                 /* now initialize the devices proper */
                 flash_name[5] = '0' + i;
diff --git a/drivers/mtd/maps/pmcmsp-ramroot.c b/drivers/mtd/maps/pmcmsp-ramroot.c
index 18049bceba..30de5c0c09 100644
--- a/drivers/mtd/maps/pmcmsp-ramroot.c
+++ b/drivers/mtd/maps/pmcmsp-ramroot.c
@@ -79,7 +79,6 @@ static int __init init_rrmap(void)
                 rr_mtd->owner = THIS_MODULE;
 
                 add_mtd_device(rr_mtd);
-                ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, rr_mtd->index);
 
                 return 0;
         }
diff --git a/drivers/mtd/maps/pq2fads.c b/drivers/mtd/maps/pq2fads.c
deleted file mode 100644
index fb78d87cc1..0000000000
--- a/drivers/mtd/maps/pq2fads.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * drivers/mtd/maps/pq2fads.c
- *
- * Mapping for the flash SIMM on 8272ADS and PQ2FADS board
- *
- * Author: Vitaly Bordug <vbordug@ru.mvista.com>
- *
- * 2005 (c) MontaVista Software, Inc. This file is licensed under
- * the terms of the GNU General Public License version 2. This program
- * is licensed "as is" without any warranty of any kind, whether express
- * or implied.
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <asm/io.h>
-#include <asm/ppcboot.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-#include <linux/mtd/physmap.h>
-
-/*
-  NOTE: bank width and interleave relative to the installed flash
-  should have been chosen within MTD_CFI_GEOMETRY options.
-  */
-#define PQ2FADS_BANK_WIDTH 4
-
-static struct mtd_partition pq2fads_partitions[] = {
-        {
-#ifdef CONFIG_ADS8272
-                .name           = "HRCW",
-                .size           = 0x40000,
-                .offset         = 0,
-                .mask_flags     = MTD_WRITEABLE,  /* force read-only */
-        }, {
-                .name           = "User FS",
-                .size           = 0x5c0000,
-                .offset         = 0x40000,
-#else
-                .name           = "User FS",
-                .size           = 0x600000,
-                .offset         = 0,
-#endif
-        }, {
-                .name           = "uImage",
-                .size           = 0x100000,
-                .offset         = 0x600000,
-                .mask_flags     = MTD_WRITEABLE,  /* force read-only */
-        }, {
-                .name           = "bootloader",
-                .size           = 0x40000,
-                .offset         = 0x700000,
-                .mask_flags     = MTD_WRITEABLE,  /* force read-only */
-        }, {
-                .name           = "bootloader env",
-                .size           = 0x40000,
-                .offset         = 0x740000,
-                .mask_flags     = MTD_WRITEABLE,  /* force read-only */
-        }
-};
-
-
-/* pointer to MPC885ADS board info data */
-extern unsigned char __res[];
-
-static int __init init_pq2fads_mtd(void)
-{
-        bd_t *bd = (bd_t *)__res;
-        physmap_configure(bd->bi_flashstart, bd->bi_flashsize, PQ2FADS_BANK_WIDTH, NULL);
-
-        physmap_set_partitions(pq2fads_partitions,
-                                sizeof (pq2fads_partitions) /
-                                sizeof (pq2fads_partitions[0]));
-        return 0;
-}
-
-static void __exit cleanup_pq2fads_mtd(void)
-{
-}
-
-module_init(init_pq2fads_mtd);
-module_exit(cleanup_pq2fads_mtd);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("MTD map and partitions for MPC8272ADS boards");
diff --git a/drivers/mtd/maps/pxa2xx-flash.c b/drivers/mtd/maps/pxa2xx-flash.c
new file mode 100644
index 0000000000..cb933ac475
--- /dev/null
+++ b/drivers/mtd/maps/pxa2xx-flash.c
@@ -0,0 +1,200 @@
+/*
+ * Map driver for Intel XScale PXA2xx platforms.
+ *
+ * Author:      Nicolas Pitre
+ * Copyright:   (C) 2001 MontaVista Software 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/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/partitions.h>
+
+#include <asm/io.h>
+#include <asm/hardware.h>
+
+#include <asm/mach/flash.h>
+
+static void pxa2xx_map_inval_cache(struct map_info *map, unsigned long from,
+                                      ssize_t len)
+{
+        consistent_sync((char *)map->cached + from, len, DMA_FROM_DEVICE);
+}
+
+struct pxa2xx_flash_info {
+        struct mtd_partition    *parts;
+        int                     nr_parts;
+        struct mtd_info         *mtd;
+        struct map_info         map;
+};
+
+
+static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
+
+
+static int __init pxa2xx_flash_probe(struct device *dev)
+{
+        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;
+        struct resource *res;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        info = kmalloc(sizeof(struct pxa2xx_flash_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        memset(info, 0, sizeof(struct pxa2xx_flash_info));
+        info->map.name = (char *) flash->name;
+        info->map.bankwidth = flash->width;
+        info->map.phys = res->start;
+        info->map.size = res->end - res->start + 1;
+        info->parts = flash->parts;
+        info->nr_parts = flash->nr_parts;
+
+        info->map.virt = ioremap(info->map.phys, info->map.size);
+        if (!info->map.virt) {
+                printk(KERN_WARNING "Failed to ioremap %s\n",
+                       info->map.name);
+                return -ENOMEM;
+        }
+        info->map.cached =
+                ioremap_cached(info->map.phys, info->map.size);
+        if (!info->map.cached)
+                printk(KERN_WARNING "Failed to ioremap cached %s\n",
+                       info->map.name);
+        info->map.inval_cache = pxa2xx_map_inval_cache;
+        simple_map_init(&info->map);
+
+        printk(KERN_NOTICE
+               "Probing %s at physical address 0x%08lx"
+               " (%d-bit bankwidth)\n",
+               info->map.name, (unsigned long)info->map.phys,
+               info->map.bankwidth * 8);
+
+        info->mtd = do_map_probe(flash->map_name, &info->map);
+
+        if (!info->mtd) {
+                iounmap((void *)info->map.virt);
+                if (info->map.cached)
+                        iounmap(info->map.cached);
+                return -EIO;
+        }
+        info->mtd->owner = THIS_MODULE;
+
+#ifdef CONFIG_MTD_PARTITIONS
+        ret = parse_mtd_partitions(info->mtd, probes, &parts, 0);
+
+        if (ret > 0) {
+                info->nr_parts = ret;
+                info->parts = parts;
+        }
+#endif
+
+        if (info->nr_parts) {
+                add_mtd_partitions(info->mtd, info->parts,
+                                   info->nr_parts);
+        } else {
+                printk("Registering %s as whole device\n",
+                       info->map.name);
+                add_mtd_device(info->mtd);
+        }
+
+        dev_set_drvdata(dev, info);
+        return 0;
+}
+
+static int __exit pxa2xx_flash_remove(struct device *dev)
+{
+        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+
+        dev_set_drvdata(dev, NULL);
+
+#ifdef CONFIG_MTD_PARTITIONS
+        if (info->nr_parts)
+                del_mtd_partitions(info->mtd);
+        else
+#endif
+                del_mtd_device(info->mtd);
+
+        map_destroy(info->mtd);
+        iounmap(info->map.virt);
+        if (info->map.cached)
+                iounmap(info->map.cached);
+        kfree(info->parts);
+        kfree(info);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pxa2xx_flash_suspend(struct device *dev, pm_message_t state)
+{
+        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        int ret = 0;
+
+        if (info->mtd && info->mtd->suspend)
+                ret = info->mtd->suspend(info->mtd);
+        return ret;
+}
+
+static int pxa2xx_flash_resume(struct device *dev)
+{
+        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+
+        if (info->mtd && info->mtd->resume)
+                info->mtd->resume(info->mtd);
+        return 0;
+}
+static void pxa2xx_flash_shutdown(struct device *dev)
+{
+        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+
+        if (info && info->mtd->suspend(info->mtd) == 0)
+                info->mtd->resume(info->mtd);
+}
+#else
+#define pxa2xx_flash_suspend NULL
+#define pxa2xx_flash_resume NULL
+#define pxa2xx_flash_shutdown NULL
+#endif
+
+static struct device_driver pxa2xx_flash_driver = {
+        .name           = "pxa2xx-flash",
+        .bus            = &platform_bus_type,
+        .probe          = pxa2xx_flash_probe,
+        .remove         = __exit_p(pxa2xx_flash_remove),
+        .suspend        = pxa2xx_flash_suspend,
+        .resume         = pxa2xx_flash_resume,
+        .shutdown       = pxa2xx_flash_shutdown,
+};
+
+static int __init init_pxa2xx_flash(void)
+{
+        return driver_register(&pxa2xx_flash_driver);
+}
+
+static void __exit cleanup_pxa2xx_flash(void)
+{
+        driver_unregister(&pxa2xx_flash_driver);
+}
+
+module_init(init_pxa2xx_flash);
+module_exit(cleanup_pxa2xx_flash);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>");
+MODULE_DESCRIPTION("MTD map driver for Intel XScale PXA2xx");
diff --git a/drivers/mtd/maps/tqm834x.c b/drivers/mtd/maps/tqm834x.c
deleted file mode 100644
index 9adc970e55..0000000000
--- a/drivers/mtd/maps/tqm834x.c
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * drivers/mtd/maps/tqm834x.c
- *
- * MTD mapping driver for TQM834x boards
- *
- * Copyright 2005 Wolfgang Denk, DENX Software Engineering, <wd@denx.de>.
- *
- * This file is licensed under the terms of the GNU General Public License
- * version 2.  This program is licensed "as is" without any warranty of any
- * kind, whether express or implied.
- *
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <asm/io.h>
-#include <asm/ppcboot.h>
-
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#define FLASH_BANK_MAX  2
-
-extern unsigned char __res[];
-
-/* trivial struct to describe partition information */
-struct mtd_part_def
-{
-        int nums;
-        unsigned char *type;
-        struct mtd_partition* mtd_part;
-};
-
-static struct mtd_info* mtd_banks[FLASH_BANK_MAX];
-static struct map_info* map_banks[FLASH_BANK_MAX];
-static struct mtd_part_def part_banks[FLASH_BANK_MAX];
-
-static unsigned long num_banks;
-static unsigned long start_scan_addr;
-
-#ifdef CONFIG_MTD_PARTITIONS
-/*
- * The following defines the partition layout of TQM834x boards.
- *
- * See include/linux/mtd/partitions.h for definition of the
- * mtd_partition structure.
- *
- * Assume minimal initial size of 4 MiB per bank, will be updated
- * later in init_tqm834x_mtd() routine.
- */
-
-/* Partition definition for the first flash bank which is always present. */
-static struct mtd_partition tqm834x_partitions_bank1[] = {
-        {
-                .name   = "u-boot",             /* u-boot firmware      */
-                .offset = 0x00000000,
-                .size   = 0x00040000,           /* 256 KiB              */
-                /*mask_flags: MTD_WRITEABLE,     * force read-only      */
-        },
-        {
-                .name   = "env",                /* u-boot environment   */
-                .offset = 0x00040000,
-                .size   = 0x00020000,           /* 128 KiB              */
-                /*mask_flags: MTD_WRITEABLE,     * force read-only      */
-        },
-        {
-                .name   = "kernel",             /* linux kernel image   */
-                .offset = 0x00060000,
-                .size   = 0x00100000,           /* 1 MiB                */
-                /*mask_flags: MTD_WRITEABLE,     * force read-only      */
-        },
-        {
-                .name   = "initrd",             /* ramdisk image        */
-                .offset = 0x00160000,
-                .size   = 0x00200000,           /* 2 MiB                */
-        },
-        {
-                .name   = "user",               /* user data            */
-                .offset = 0x00360000,
-                .size   = 0x000a0000,           /* remaining space      */
-                /* NOTE: this parttion size is re-calcated in           */
-                /* init_tqm834x_mtd() to cover actual remaining space.  */
-        },
-};
-
-/* Partition definition for the second flash bank which may be present on some
- * TQM834x boards.
- */
-static struct mtd_partition tqm834x_partitions_bank2[] = {
-        {
-                .name   = "jffs2",              /* jffs2 filesystem     */
-                .offset = 0x00000000,
-                .size   = 0x00400000,           /* whole device         */
-                /* NOTE: this parttion size is re-calcated in           */
-                /* init_tqm834x_mtd() to cover actual device size.      */
-        },
-};
-
-#endif  /* CONFIG_MTD_PARTITIONS */
-
-static int __init init_tqm834x_mtd(void)
-{
-        int idx = 0, ret = 0;
-        unsigned long flash_addr, flash_size, mtd_size = 0;
-
-        /* pointer to TQM834x board info data */
-        bd_t *bd = (bd_t *)__res;
-#ifdef CONFIG_MTD_CMDLINE_PARTS
-        int n;
-        char mtdid[4];
-        const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
-
-        flash_addr = bd->bi_flashstart;
-        flash_size = bd->bi_flashsize;
-
-        /* request maximum flash size address space */
-        start_scan_addr = (unsigned long)ioremap(flash_addr, flash_size);
-        if (!start_scan_addr) {
-                printk("%s: Failed to ioremap address: 0x%lx\n",
-                       __FUNCTION__, flash_addr);
-                return -EIO;
-        }
-
-        for(idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
-                if (mtd_size >= flash_size)
-                        break;
-
-                pr_debug("%s: chip probing count %d\n", __FUNCTION__, idx);
-
-                map_banks[idx] = kzalloc(sizeof(struct map_info), GFP_KERNEL);
-                if (map_banks[idx] == NULL) {
-                        ret = -ENOMEM;
-                        goto error_mem;
-                }
-                map_banks[idx]->name = kzalloc(16, GFP_KERNEL);
-                if (map_banks[idx]->name == NULL) {
-                        ret = -ENOMEM;
-                        goto error_mem;
-                }
-
-                sprintf(map_banks[idx]->name, "TQM834x-%d", idx);
-                map_banks[idx]->size = flash_size;
-                map_banks[idx]->bankwidth = 4;
-
-                simple_map_init(map_banks[idx]);
-
-                map_banks[idx]->virt = (void __iomem *)
-                        (start_scan_addr + ((idx > 0) ?
-                        (mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0));
-                map_banks[idx]->phys =
-                        flash_addr + ((idx > 0) ?
-                        (mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0);
-
-                /* start to probe flash chips */
-                mtd_banks[idx] = do_map_probe("cfi_probe", map_banks[idx]);
-                if (mtd_banks[idx]) {
-                        mtd_banks[idx]->owner = THIS_MODULE;
-                        mtd_size += mtd_banks[idx]->size;
-                        num_banks++;
-                        pr_debug("%s: bank %ld, name: %s, size: %d bytes \n",
-                                 __FUNCTION__, num_banks,
-                                 mtd_banks[idx]->name, mtd_banks[idx]->size);
-                }
-        }
-
-        /* no supported flash chips found */
-        if (!num_banks) {
-                printk("TQM834x: No supported flash chips found!\n");
-                ret = -ENXIO;
-                goto error_mem;
-        }
-
-#ifdef CONFIG_MTD_PARTITIONS
-        /*
-         * Select static partition definitions
-         */
-        n = ARRAY_SIZE(tqm834x_partitions_bank1);
-        part_banks[0].mtd_part  = tqm834x_partitions_bank1;
-        part_banks[0].type      = "static image bank1";
-        part_banks[0].nums      = n;
-
-        /* update last partition size to cover actual remaining space */
-        tqm834x_partitions_bank1[n - 1].size =
-                mtd_banks[0]->size -
-                tqm834x_partitions_bank1[n - 1].offset;
-
-        /* check if we have second bank? */
-        if (num_banks == 2) {
-                n = ARRAY_SIZE(tqm834x_partitions_bank2);
-                part_banks[1].mtd_part  = tqm834x_partitions_bank2;
-                part_banks[1].type      = "static image bank2";
-                part_banks[1].nums      = n;
-
-                /* update last partition size to cover actual remaining space */
-                tqm834x_partitions_bank2[n - 1].size =
-                        mtd_banks[1]->size -
-                        tqm834x_partitions_bank2[n - 1].offset;
-        }
-
-        for(idx = 0; idx < num_banks ; idx++) {
-#ifdef CONFIG_MTD_CMDLINE_PARTS
-                sprintf(mtdid, "%d", idx);
-                n = parse_mtd_partitions(mtd_banks[idx],
-                                         part_probes,
-                                         &part_banks[idx].mtd_part,
-                                         0);
-                pr_debug("%s: %d command line partitions on bank %s\n",
-                         __FUNCTION__, n, mtdid);
-                if (n > 0) {
-                        part_banks[idx].type = "command line";
-                        part_banks[idx].nums = n;
-                }
-#endif  /* CONFIG_MTD_CMDLINE_PARTS */
-                if (part_banks[idx].nums == 0) {
-                        printk(KERN_NOTICE
-                               "TQM834x flash bank %d: no partition info "
-                               "available, registering whole device\n", idx);
-                        add_mtd_device(mtd_banks[idx]);
-                } else {
-                        printk(KERN_NOTICE
-                               "TQM834x flash bank %d: Using %s partition "
-                               "definition\n", idx, part_banks[idx].type);
-                        add_mtd_partitions(mtd_banks[idx],
-                                           part_banks[idx].mtd_part,
-                                           part_banks[idx].nums);
-                }
-        }
-#else   /* ! CONFIG_MTD_PARTITIONS */
-        printk(KERN_NOTICE "TQM834x flash: registering %d flash banks "
-                        "at once\n", num_banks);
-
-        for(idx = 0 ; idx < num_banks ; idx++)
-                add_mtd_device(mtd_banks[idx]);
-
-#endif  /* CONFIG_MTD_PARTITIONS */
-
-        return 0;
-error_mem:
-        for (idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
-                if (map_banks[idx] != NULL) {
-                        if (map_banks[idx]->name != NULL) {
-                                kfree(map_banks[idx]->name);
-                                map_banks[idx]->name = NULL;
-                        }
-                        kfree(map_banks[idx]);
-                        map_banks[idx] = NULL;
-                }
-        }
-
-        iounmap((void *)start_scan_addr);
-
-        return ret;
-}
-
-static void __exit cleanup_tqm834x_mtd(void)
-{
-        unsigned int idx = 0;
-        for(idx = 0 ; idx < num_banks ; idx++) {
-                /* destroy mtd_info previously allocated */
-                if (mtd_banks[idx]) {
-                        del_mtd_partitions(mtd_banks[idx]);
-                        map_destroy(mtd_banks[idx]);
-                }
-
-                /* release map_info not used anymore */
-                kfree(map_banks[idx]->name);
-                kfree(map_banks[idx]);
-        }
-
-        if (start_scan_addr) {
-                iounmap((void *)start_scan_addr);
-                start_scan_addr = 0;
-        }
-}
-
-module_init(init_tqm834x_mtd);
-module_exit(cleanup_tqm834x_mtd);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Wolfgang Denk <wd@denx.de>");
-MODULE_DESCRIPTION("MTD map driver for TQM834x boards");
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index ef89780eb9..74d9d30eda 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -24,10 +24,9 @@
 #include <linux/kthread.h>
 #include <asm/uaccess.h>
 
-static LIST_HEAD(blktrans_majors);
+#include "mtdcore.h"
 
-extern struct mutex mtd_table_mutex;
-extern struct mtd_info *mtd_table[];
+static LIST_HEAD(blktrans_majors);
 
 struct mtd_blkcore_priv {
         struct task_struct *thread;
@@ -202,7 +201,7 @@ static int blktrans_ioctl(struct inode *inode, struct file *file,
         }
 }
 
-struct block_device_operations mtd_blktrans_ops = {
+static struct block_device_operations mtd_blktrans_ops = {
         .owner          = THIS_MODULE,
         .open           = blktrans_open,
         .release        = blktrans_release,
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index d091b2430b..22ed96c4b7 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -136,7 +136,8 @@ static int mtd_close(struct inode *inode, struct file *file)
 
         DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
 
-        if (mtd->sync)
+        /* Only sync if opened RW */
+        if ((file->f_mode & 2) && mtd->sync)
                 mtd->sync(mtd);
 
         put_mtd_device(mtd);
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index 41844ea024..96be7ef62f 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -178,7 +178,7 @@ concat_writev(struct mtd_info *mtd, const struct kvec *vecs,
 
         /* Check alignment */
         if (mtd->writesize > 1) {
-                loff_t __to = to;
+                uint64_t __to = to;
                 if (do_div(__to, mtd->writesize) || (total_len % mtd->writesize))
                         return -EINVAL;
         }
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index c153b64a83..6c2645e283 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -22,6 +22,8 @@
 
 #include <linux/mtd/mtd.h>
 
+#include "mtdcore.h"
+
 /* These are exported solely for the purpose of mtd_blkdevs.c. You
    should not use them for _anything_ else */
 DEFINE_MUTEX(mtd_table_mutex);
diff --git a/drivers/mtd/mtdcore.h b/drivers/mtd/mtdcore.h
new file mode 100644
index 0000000000..a33251f4b8
--- /dev/null
+++ b/drivers/mtd/mtdcore.h
@@ -0,0 +1,11 @@
+/* linux/drivers/mtd/mtdcore.h
+ *
+ * Header file for driver private mtdcore exports
+ *
+ */
+
+/* These are exported solely for the purpose of mtd_blkdevs.c. You
+   should not use them for _anything_ else */
+
+extern struct mutex mtd_table_mutex;
+extern struct mtd_info *mtd_table[MAX_MTD_DEVICES];
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
new file mode 100644
index 0000000000..f8af627f0b
--- /dev/null
+++ b/drivers/mtd/mtdoops.c
@@ -0,0 +1,376 @@
+/*
+ * MTD Oops/Panic logger
+ *
+ * Copyright (C) 2007 Nokia Corporation. All rights reserved.
+ *
+ * Author: Richard Purdie <rpurdie@openedhand.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 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/console.h>
+#include <linux/vmalloc.h>
+#include <linux/workqueue.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/mtd/mtd.h>
+
+#define OOPS_PAGE_SIZE 4096
+
+static struct mtdoops_context {
+        int mtd_index;
+        struct work_struct work;
+        struct mtd_info *mtd;
+        int oops_pages;
+        int nextpage;
+        int nextcount;
+
+        void *oops_buf;
+        int ready;
+        int writecount;
+} oops_cxt;
+
+static void mtdoops_erase_callback(struct erase_info *done)
+{
+        wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
+        wake_up(wait_q);
+}
+
+static int mtdoops_erase_block(struct mtd_info *mtd, int offset)
+{
+        struct erase_info erase;
+        DECLARE_WAITQUEUE(wait, current);
+        wait_queue_head_t wait_q;
+        int ret;
+
+        init_waitqueue_head(&wait_q);
+        erase.mtd = mtd;
+        erase.callback = mtdoops_erase_callback;
+        erase.addr = offset;
+        if (mtd->erasesize < OOPS_PAGE_SIZE)
+                erase.len = OOPS_PAGE_SIZE;
+        else
+                erase.len = mtd->erasesize;
+        erase.priv = (u_long)&wait_q;
+
+        set_current_state(TASK_INTERRUPTIBLE);
+        add_wait_queue(&wait_q, &wait);
+
+        ret = mtd->erase(mtd, &erase);
+        if (ret) {
+                set_current_state(TASK_RUNNING);
+                remove_wait_queue(&wait_q, &wait);
+                printk (KERN_WARNING "mtdoops: erase of region [0x%x, 0x%x] "
+                                     "on \"%s\" failed\n",
+                        erase.addr, erase.len, mtd->name);
+                return ret;
+        }
+
+        schedule();  /* Wait for erase to finish. */
+        remove_wait_queue(&wait_q, &wait);
+
+        return 0;
+}
+
+static int mtdoops_inc_counter(struct mtdoops_context *cxt)
+{
+        struct mtd_info *mtd = cxt->mtd;
+        size_t retlen;
+        u32 count;
+        int ret;
+
+        cxt->nextpage++;
+        if (cxt->nextpage > cxt->oops_pages)
+                cxt->nextpage = 0;
+        cxt->nextcount++;
+        if (cxt->nextcount == 0xffffffff)
+                cxt->nextcount = 0;
+
+        ret = mtd->read(mtd, cxt->nextpage * OOPS_PAGE_SIZE, 4,
+                        &retlen, (u_char *) &count);
+        if ((retlen != 4) || (ret < 0)) {
+                printk(KERN_ERR "mtdoops: Read failure at %d (%td of 4 read)"
+                                ", err %d.\n", cxt->nextpage * OOPS_PAGE_SIZE,
+                                retlen, ret);
+                return 1;
+        }
+
+        /* See if we need to erase the next block */
+        if (count != 0xffffffff)
+                return 1;
+
+        printk(KERN_DEBUG "mtdoops: Ready %d, %d (no erase)\n",
+                        cxt->nextpage, cxt->nextcount);
+        cxt->ready = 1;
+        return 0;
+}
+
+static void mtdoops_prepare(struct mtdoops_context *cxt)
+{
+        struct mtd_info *mtd = cxt->mtd;
+        int i = 0, j, ret, mod;
+
+        /* We were unregistered */
+        if (!mtd)
+                return;
+
+        mod = (cxt->nextpage * OOPS_PAGE_SIZE) % mtd->erasesize;
+        if (mod != 0) {
+                cxt->nextpage = cxt->nextpage + ((mtd->erasesize - mod) / OOPS_PAGE_SIZE);
+                if (cxt->nextpage > cxt->oops_pages)
+                        cxt->nextpage = 0;
+        }
+
+        while (mtd->block_isbad &&
+                        mtd->block_isbad(mtd, cxt->nextpage * OOPS_PAGE_SIZE)) {
+badblock:
+                printk(KERN_WARNING "mtdoops: Bad block at %08x\n",
+                                cxt->nextpage * OOPS_PAGE_SIZE);
+                i++;
+                cxt->nextpage = cxt->nextpage + (mtd->erasesize / OOPS_PAGE_SIZE);
+                if (cxt->nextpage > cxt->oops_pages)
+                        cxt->nextpage = 0;
+                if (i == (cxt->oops_pages / (mtd->erasesize / OOPS_PAGE_SIZE))) {
+                        printk(KERN_ERR "mtdoops: All blocks bad!\n");
+                        return;
+                }
+        }
+
+        for (j = 0, ret = -1; (j < 3) && (ret < 0); j++)
+                ret = mtdoops_erase_block(mtd, cxt->nextpage * OOPS_PAGE_SIZE);
+
+        if (ret < 0) {
+                if (mtd->block_markbad)
+                        mtd->block_markbad(mtd, cxt->nextpage * OOPS_PAGE_SIZE);
+                goto badblock;
+        }
+
+        printk(KERN_DEBUG "mtdoops: Ready %d, %d \n", cxt->nextpage, cxt->nextcount);
+
+        cxt->ready = 1;
+}
+
+static void mtdoops_workfunc(struct work_struct *work)
+{
+        struct mtdoops_context *cxt =
+                        container_of(work, struct mtdoops_context, work);
+
+        mtdoops_prepare(cxt);
+}
+
+static int find_next_position(struct mtdoops_context *cxt)
+{
+        struct mtd_info *mtd = cxt->mtd;
+        int page, maxpos = 0;
+        u32 count, maxcount = 0xffffffff;
+        size_t retlen;
+
+        for (page = 0; page < cxt->oops_pages; page++) {
+                mtd->read(mtd, page * OOPS_PAGE_SIZE, 4, &retlen, (u_char *) &count);
+                if (count == 0xffffffff)
+                        continue;
+                if (maxcount == 0xffffffff) {
+                        maxcount = count;
+                        maxpos = page;
+                } else if ((count < 0x40000000) && (maxcount > 0xc0000000)) {
+                        maxcount = count;
+                        maxpos = page;
+                } else if ((count > maxcount) && (count < 0xc0000000)) {
+                        maxcount = count;
+                        maxpos = page;
+                } else if ((count > maxcount) && (count > 0xc0000000)
+                                        && (maxcount > 0x80000000)) {
+                        maxcount = count;
+                        maxpos = page;
+                }
+        }
+        if (maxcount == 0xffffffff) {
+                cxt->nextpage = 0;
+                cxt->nextcount = 1;
+                cxt->ready = 1;
+                printk(KERN_DEBUG "mtdoops: Ready %d, %d (first init)\n",
+                                cxt->nextpage, cxt->nextcount);
+                return 0;
+        }
+
+        cxt->nextpage = maxpos;
+        cxt->nextcount = maxcount;
+
+        return mtdoops_inc_counter(cxt);
+}
+
+
+static void mtdoops_notify_add(struct mtd_info *mtd)
+{
+        struct mtdoops_context *cxt = &oops_cxt;
+        int ret;
+
+        if ((mtd->index != cxt->mtd_index) || cxt->mtd_index < 0)
+                return;
+
+        if (mtd->size < (mtd->erasesize * 2)) {
+                printk(KERN_ERR "MTD partition %d not big enough for mtdoops\n",
+                                mtd->index);
+                return;
+        }
+
+        cxt->mtd = mtd;
+        cxt->oops_pages = mtd->size / OOPS_PAGE_SIZE;
+
+        ret = find_next_position(cxt);
+        if (ret == 1)
+                mtdoops_prepare(cxt);
+
+        printk(KERN_DEBUG "mtdoops: Attached to MTD device %d\n", mtd->index);
+}
+
+static void mtdoops_notify_remove(struct mtd_info *mtd)
+{
+        struct mtdoops_context *cxt = &oops_cxt;
+
+        if ((mtd->index != cxt->mtd_index) || cxt->mtd_index < 0)
+                return;
+
+        cxt->mtd = NULL;
+        flush_scheduled_work();
+}
+
+static void mtdoops_console_sync(void)
+{
+        struct mtdoops_context *cxt = &oops_cxt;
+        struct mtd_info *mtd = cxt->mtd;
+        size_t retlen;
+        int ret;
+
+        if (!cxt->ready || !mtd)
+                return;
+
+        if (cxt->writecount == 0)
+                return;
+
+        if (cxt->writecount < OOPS_PAGE_SIZE)
+                memset(cxt->oops_buf + cxt->writecount, 0xff,
+                                        OOPS_PAGE_SIZE - cxt->writecount);
+
+        ret = mtd->write(mtd, cxt->nextpage * OOPS_PAGE_SIZE,
+                                        OOPS_PAGE_SIZE, &retlen, cxt->oops_buf);
+        cxt->ready = 0;
+        cxt->writecount = 0;
+
+        if ((retlen != OOPS_PAGE_SIZE) || (ret < 0))
+                printk(KERN_ERR "mtdoops: Write failure at %d (%td of %d written), err %d.\n",
+                        cxt->nextpage * OOPS_PAGE_SIZE, retlen, OOPS_PAGE_SIZE, ret);
+
+        ret = mtdoops_inc_counter(cxt);
+        if (ret == 1)
+                schedule_work(&cxt->work);
+}
+
+static void
+mtdoops_console_write(struct console *co, const char *s, unsigned int count)
+{
+        struct mtdoops_context *cxt = co->data;
+        struct mtd_info *mtd = cxt->mtd;
+        int i;
+
+        if (!oops_in_progress) {
+                mtdoops_console_sync();
+                return;
+        }
+
+        if (!cxt->ready || !mtd)
+                return;
+
+        if (cxt->writecount == 0) {
+                u32 *stamp = cxt->oops_buf;
+                *stamp = cxt->nextcount;
+                cxt->writecount = 4;
+        }
+
+        if ((count + cxt->writecount) > OOPS_PAGE_SIZE)
+                count = OOPS_PAGE_SIZE - cxt->writecount;
+
+        for (i = 0; i < count; i++, s++)
+                *((char *)(cxt->oops_buf) + cxt->writecount + i) = *s;
+
+        cxt->writecount = cxt->writecount + count;
+}
+
+static int __init mtdoops_console_setup(struct console *co, char *options)
+{
+        struct mtdoops_context *cxt = co->data;
+
+        if (cxt->mtd_index != -1)
+                return -EBUSY;
+        if (co->index == -1)
+                return -EINVAL;
+
+        cxt->mtd_index = co->index;
+        return 0;
+}
+
+static struct mtd_notifier mtdoops_notifier = {
+        .add    = mtdoops_notify_add,
+        .remove = mtdoops_notify_remove,
+};
+
+static struct console mtdoops_console = {
+        .name           = "ttyMTD",
+        .write          = mtdoops_console_write,
+        .setup          = mtdoops_console_setup,
+        .unblank        = mtdoops_console_sync,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+        .data           = &oops_cxt,
+};
+
+static int __init mtdoops_console_init(void)
+{
+        struct mtdoops_context *cxt = &oops_cxt;
+
+        cxt->mtd_index = -1;
+        cxt->oops_buf = vmalloc(OOPS_PAGE_SIZE);
+
+        if (!cxt->oops_buf) {
+                printk(KERN_ERR "Failed to allocate oops buffer workspace\n");
+                return -ENOMEM;
+        }
+
+        INIT_WORK(&cxt->work, mtdoops_workfunc);
+
+        register_console(&mtdoops_console);
+        register_mtd_user(&mtdoops_notifier);
+        return 0;
+}
+
+static void __exit mtdoops_console_exit(void)
+{
+        struct mtdoops_context *cxt = &oops_cxt;
+
+        unregister_mtd_user(&mtdoops_notifier);
+        unregister_console(&mtdoops_console);
+        vfree(cxt->oops_buf);
+}
+
+
+subsys_initcall(mtdoops_console_init);
+module_exit(mtdoops_console_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
+MODULE_DESCRIPTION("MTD Oops/Panic console logger/driver");
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index f1d60b6f04..8f9c3baeb3 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -91,6 +91,25 @@ config MTD_NAND_AU1550
           This enables the driver for the NAND flash controller on the
           AMD/Alchemy 1550 SOC.
 
+config MTD_NAND_BF5XX
+        tristate "Blackfin on-chip NAND Flash Controller driver"
+        depends on BF54x && MTD_NAND
+        help
+          This enables the Blackfin on-chip NAND flash controller
+
+          No board specific support is done by this driver, each board
+          must advertise a platform_device for the driver to attach.
+
+          This driver can also be built as a module. If so, the module
+          will be called bf5xx-nand.
+
+config MTD_NAND_BF5XX_HWECC
+        bool "BF5XX NAND Hardware ECC"
+        depends on MTD_NAND_BF5XX
+        help
+          Enable the use of the BF5XX's internal ECC generator when
+          using NAND.
+
 config MTD_NAND_RTC_FROM4
         tristate "Renesas Flash ROM 4-slot interface board (FROM_BOARD4)"
         depends on SH_SOLUTION_ENGINE
@@ -134,10 +153,10 @@ config MTD_NAND_S3C2410_HWECC
 
 config MTD_NAND_NDFC
         tristate "NDFC NanD Flash Controller"
-        depends on 44x
+        depends on 4xx && !PPC_MERGE
         select MTD_NAND_ECC_SMC
         help
-         NDFC Nand Flash Controllers are integrated in EP44x SoCs
+         NDFC Nand Flash Controllers are integrated in IBM/AMCC's 4xx SoCs
 
 config MTD_NAND_S3C2410_CLKSTOP
         bool "S3C2410 NAND IDLE clock stop"
@@ -237,7 +256,7 @@ config MTD_NAND_CAFE
         select REED_SOLOMON
         select REED_SOLOMON_DEC16
         help
-          Use NAND flash attached to the CAFÉ chip designed for the $100
+          Use NAND flash attached to the CAFÉ chip designed for the OLPC
           laptop.
 
 config MTD_NAND_CS553X
@@ -280,5 +299,11 @@ config MTD_NAND_PLATFORM
           devices. You will need to provide platform-specific functions
           via platform_data.
 
+config MTD_ALAUDA
+        tristate "MTD driver for Olympus MAUSB-10 and Fijufilm DPC-R1"
+        depends on MTD_NAND && USB
+        help
+          These two (and possibly other) Alauda-based cardreaders for
+          SmartMedia and xD allow raw flash access.
 
 endif # MTD_NAND
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index edba1db14b..3ad6c0165d 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_MTD_NAND_TOTO)		+= toto.o
 obj-$(CONFIG_MTD_NAND_AUTCPU12)         += autcpu12.o
 obj-$(CONFIG_MTD_NAND_EDB7312)          += edb7312.o
 obj-$(CONFIG_MTD_NAND_AU1550)           += au1550nd.o
+obj-$(CONFIG_MTD_NAND_BF5XX)            += bf5xx_nand.o
 obj-$(CONFIG_MTD_NAND_PPCHAMELEONEVB)   += ppchameleonevb.o
 obj-$(CONFIG_MTD_NAND_S3C2410)          += s3c2410.o
 obj-$(CONFIG_MTD_NAND_DISKONCHIP)       += diskonchip.o
@@ -27,5 +28,6 @@ obj-$(CONFIG_MTD_NAND_AT91)		+= at91_nand.o
 obj-$(CONFIG_MTD_NAND_CM_X270)          += cmx270_nand.o
 obj-$(CONFIG_MTD_NAND_BASLER_EXCITE)    += excite_nandflash.o
 obj-$(CONFIG_MTD_NAND_PLATFORM)         += plat_nand.o
+obj-$(CONFIG_MTD_ALAUDA)                += alauda.o
 
 nand-objs := nand_base.o nand_bbt.o
diff --git a/drivers/mtd/nand/alauda.c b/drivers/mtd/nand/alauda.c
new file mode 100644
index 0000000000..257937cd99
--- /dev/null
+++ b/drivers/mtd/nand/alauda.c
@@ -0,0 +1,742 @@
+/*
+ * MTD driver for Alauda chips
+ *
+ * Copyright (C) 2007 Joern Engel <joern@logfs.org>
+ *
+ * Based on drivers/usb/usb-skeleton.c which is:
+ * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
+ * and on drivers/usb/storage/alauda.c, which is:
+ *   (c) 2005 Daniel Drake <dsd@gentoo.org>
+ *
+ * Idea and initial work by Arnd Bergmann <arnd@arndb.de>
+ */
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/usb.h>
+#include <linux/mutex.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand_ecc.h>
+
+/* Control commands */
+#define ALAUDA_GET_XD_MEDIA_STATUS      0x08
+#define ALAUDA_ACK_XD_MEDIA_CHANGE      0x0a
+#define ALAUDA_GET_XD_MEDIA_SIG         0x86
+
+/* Common prefix */
+#define ALAUDA_BULK_CMD                 0x40
+
+/* The two ports */
+#define ALAUDA_PORT_XD                  0x00
+#define ALAUDA_PORT_SM                  0x01
+
+/* Bulk commands */
+#define ALAUDA_BULK_READ_PAGE           0x84
+#define ALAUDA_BULK_READ_OOB            0x85 /* don't use, there's a chip bug */
+#define ALAUDA_BULK_READ_BLOCK          0x94
+#define ALAUDA_BULK_ERASE_BLOCK         0xa3
+#define ALAUDA_BULK_WRITE_PAGE          0xa4
+#define ALAUDA_BULK_WRITE_BLOCK         0xb4
+#define ALAUDA_BULK_RESET_MEDIA         0xe0
+
+/* Address shifting */
+#define PBA_LO(pba) ((pba & 0xF) << 5)
+#define PBA_HI(pba) (pba >> 3)
+#define PBA_ZONE(pba) (pba >> 11)
+
+#define TIMEOUT HZ
+
+static struct usb_device_id alauda_table [] = {
+        { USB_DEVICE(0x0584, 0x0008) }, /* Fujifilm DPC-R1 */
+        { USB_DEVICE(0x07b4, 0x010a) }, /* Olympus MAUSB-10 */
+        { }
+};
+MODULE_DEVICE_TABLE(usb, alauda_table);
+
+struct alauda_card {
+        u8      id;             /* id byte */
+        u8      chipshift;      /* 1<<chipshift total size */
+        u8      pageshift;      /* 1<<pageshift page size */
+        u8      blockshift;     /* 1<<blockshift block size */
+};
+
+struct alauda {
+        struct usb_device       *dev;
+        struct usb_interface    *interface;
+        struct mtd_info         *mtd;
+        struct alauda_card      *card;
+        struct mutex            card_mutex;
+        u32                     pagemask;
+        u32                     bytemask;
+        u32                     blockmask;
+        unsigned int            write_out;
+        unsigned int            bulk_in;
+        unsigned int            bulk_out;
+        u8                      port;
+        struct kref             kref;
+};
+
+static struct alauda_card alauda_card_ids[] = {
+        /* NAND flash */
+        { 0x6e, 20, 8, 12},     /* 1 MB */
+        { 0xe8, 20, 8, 12},     /* 1 MB */
+        { 0xec, 20, 8, 12},     /* 1 MB */
+        { 0x64, 21, 8, 12},     /* 2 MB */
+        { 0xea, 21, 8, 12},     /* 2 MB */
+        { 0x6b, 22, 9, 13},     /* 4 MB */
+        { 0xe3, 22, 9, 13},     /* 4 MB */
+        { 0xe5, 22, 9, 13},     /* 4 MB */
+        { 0xe6, 23, 9, 13},     /* 8 MB */
+        { 0x73, 24, 9, 14},     /* 16 MB */
+        { 0x75, 25, 9, 14},     /* 32 MB */
+        { 0x76, 26, 9, 14},     /* 64 MB */
+        { 0x79, 27, 9, 14},     /* 128 MB */
+        { 0x71, 28, 9, 14},     /* 256 MB */
+
+        /* MASK ROM */
+        { 0x5d, 21, 9, 13},     /* 2 MB */
+        { 0xd5, 22, 9, 13},     /* 4 MB */
+        { 0xd6, 23, 9, 13},     /* 8 MB */
+        { 0x57, 24, 9, 13},     /* 16 MB */
+        { 0x58, 25, 9, 13},     /* 32 MB */
+        { }
+};
+
+static struct alauda_card *get_card(u8 id)
+{
+        struct alauda_card *card;
+
+        for (card = alauda_card_ids; card->id; card++)
+                if (card->id == id)
+                        return card;
+        return NULL;
+}
+
+static void alauda_delete(struct kref *kref)
+{
+        struct alauda *al = container_of(kref, struct alauda, kref);
+
+        if (al->mtd) {
+                del_mtd_device(al->mtd);
+                kfree(al->mtd);
+        }
+        usb_put_dev(al->dev);
+        kfree(al);
+}
+
+static int alauda_get_media_status(struct alauda *al, void *buf)
+{
+        int ret;
+
+        mutex_lock(&al->card_mutex);
+        ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
+                        ALAUDA_GET_XD_MEDIA_STATUS, 0xc0, 0, 1, buf, 2, HZ);
+        mutex_unlock(&al->card_mutex);
+        return ret;
+}
+
+static int alauda_ack_media(struct alauda *al)
+{
+        int ret;
+
+        mutex_lock(&al->card_mutex);
+        ret = usb_control_msg(al->dev, usb_sndctrlpipe(al->dev, 0),
+                        ALAUDA_ACK_XD_MEDIA_CHANGE, 0x40, 0, 1, NULL, 0, HZ);
+        mutex_unlock(&al->card_mutex);
+        return ret;
+}
+
+static int alauda_get_media_signatures(struct alauda *al, void *buf)
+{
+        int ret;
+
+        mutex_lock(&al->card_mutex);
+        ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
+                        ALAUDA_GET_XD_MEDIA_SIG, 0xc0, 0, 0, buf, 4, HZ);
+        mutex_unlock(&al->card_mutex);
+        return ret;
+}
+
+static void alauda_reset(struct alauda *al)
+{
+        u8 command[] = {
+                ALAUDA_BULK_CMD, ALAUDA_BULK_RESET_MEDIA, 0, 0,
+                0, 0, 0, 0, al->port
+        };
+        mutex_lock(&al->card_mutex);
+        usb_bulk_msg(al->dev, al->bulk_out, command, 9, NULL, HZ);
+        mutex_unlock(&al->card_mutex);
+}
+
+static void correct_data(void *buf, void *read_ecc,
+                int *corrected, int *uncorrected)
+{
+        u8 calc_ecc[3];
+        int err;
+
+        nand_calculate_ecc(NULL, buf, calc_ecc);
+        err = nand_correct_data(NULL, buf, read_ecc, calc_ecc);
+        if (err) {
+                if (err > 0)
+                        (*corrected)++;
+                else
+                        (*uncorrected)++;
+        }
+}
+
+struct alauda_sg_request {
+        struct urb *urb[3];
+        struct completion comp;
+};
+
+static void alauda_complete(struct urb *urb)
+{
+        struct completion *comp = urb->context;
+
+        if (comp)
+                complete(comp);
+}
+
+static int __alauda_read_page(struct mtd_info *mtd, loff_t from, void *buf,
+                void *oob)
+{
+        struct alauda_sg_request sg;
+        struct alauda *al = mtd->priv;
+        u32 pba = from >> al->card->blockshift;
+        u32 page = (from >> al->card->pageshift) & al->pagemask;
+        u8 command[] = {
+                ALAUDA_BULK_CMD, ALAUDA_BULK_READ_PAGE, PBA_HI(pba),
+                PBA_ZONE(pba), 0, PBA_LO(pba) + page, 1, 0, al->port
+        };
+        int i, err;
+
+        for (i=0; i<3; i++)
+                sg.urb[i] = NULL;
+
+        err = -ENOMEM;
+        for (i=0; i<3; i++) {
+                sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
+                if (!sg.urb[i])
+                        goto out;
+        }
+        init_completion(&sg.comp);
+        usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
+                        alauda_complete, NULL);
+        usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, mtd->writesize,
+                        alauda_complete, NULL);
+        usb_fill_bulk_urb(sg.urb[2], al->dev, al->bulk_in, oob, 16,
+                        alauda_complete, &sg.comp);
+
+        mutex_lock(&al->card_mutex);
+        for (i=0; i<3; i++) {
+                err = usb_submit_urb(sg.urb[i], GFP_NOIO);
+                if (err)
+                        goto cancel;
+        }
+        if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
+                err = -ETIMEDOUT;
+cancel:
+                for (i=0; i<3; i++) {
+                        usb_kill_urb(sg.urb[i]);
+                }
+        }
+        mutex_unlock(&al->card_mutex);
+
+out:
+        usb_free_urb(sg.urb[0]);
+        usb_free_urb(sg.urb[1]);
+        usb_free_urb(sg.urb[2]);
+        return err;
+}
+
+static int alauda_read_page(struct mtd_info *mtd, loff_t from,
+                void *buf, u8 *oob, int *corrected, int *uncorrected)
+{
+        int err;
+
+        err = __alauda_read_page(mtd, from, buf, oob);
+        if (err)
+                return err;
+        correct_data(buf, oob+13, corrected, uncorrected);
+        correct_data(buf+256, oob+8, corrected, uncorrected);
+        return 0;
+}
+
+static int alauda_write_page(struct mtd_info *mtd, loff_t to, void *buf,
+                void *oob)
+{
+        struct alauda_sg_request sg;
+        struct alauda *al = mtd->priv;
+        u32 pba = to >> al->card->blockshift;
+        u32 page = (to >> al->card->pageshift) & al->pagemask;
+        u8 command[] = {
+                ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_PAGE, PBA_HI(pba),
+                PBA_ZONE(pba), 0, PBA_LO(pba) + page, 32, 0, al->port
+        };
+        int i, err;
+
+        for (i=0; i<3; i++)
+                sg.urb[i] = NULL;
+
+        err = -ENOMEM;
+        for (i=0; i<3; i++) {
+                sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
+                if (!sg.urb[i])
+                        goto out;
+        }
+        init_completion(&sg.comp);
+        usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
+                        alauda_complete, NULL);
+        usb_fill_bulk_urb(sg.urb[1], al->dev, al->write_out, buf,mtd->writesize,
+                        alauda_complete, NULL);
+        usb_fill_bulk_urb(sg.urb[2], al->dev, al->write_out, oob, 16,
+                        alauda_complete, &sg.comp);
+
+        mutex_lock(&al->card_mutex);
+        for (i=0; i<3; i++) {
+                err = usb_submit_urb(sg.urb[i], GFP_NOIO);
+                if (err)
+                        goto cancel;
+        }
+        if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
+                err = -ETIMEDOUT;
+cancel:
+                for (i=0; i<3; i++) {
+                        usb_kill_urb(sg.urb[i]);
+                }
+        }
+        mutex_unlock(&al->card_mutex);
+
+out:
+        usb_free_urb(sg.urb[0]);
+        usb_free_urb(sg.urb[1]);
+        usb_free_urb(sg.urb[2]);
+        return err;
+}
+
+static int alauda_erase_block(struct mtd_info *mtd, loff_t ofs)
+{
+        struct alauda_sg_request sg;
+        struct alauda *al = mtd->priv;
+        u32 pba = ofs >> al->card->blockshift;
+        u8 command[] = {
+                ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba),
+                PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, al->port
+        };
+        u8 buf[2];
+        int i, err;
+
+        for (i=0; i<2; i++)
+                sg.urb[i] = NULL;
+
+        err = -ENOMEM;
+        for (i=0; i<2; i++) {
+                sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
+                if (!sg.urb[i])
+                        goto out;
+        }
+        init_completion(&sg.comp);
+        usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
+                        alauda_complete, NULL);
+        usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, 2,
+                        alauda_complete, &sg.comp);
+
+        mutex_lock(&al->card_mutex);
+        for (i=0; i<2; i++) {
+                err = usb_submit_urb(sg.urb[i], GFP_NOIO);
+                if (err)
+                        goto cancel;
+        }
+        if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
+                err = -ETIMEDOUT;
+cancel:
+                for (i=0; i<2; i++) {
+                        usb_kill_urb(sg.urb[i]);
+                }
+        }
+        mutex_unlock(&al->card_mutex);
+
+out:
+        usb_free_urb(sg.urb[0]);
+        usb_free_urb(sg.urb[1]);
+        return err;
+}
+
+static int alauda_read_oob(struct mtd_info *mtd, loff_t from, void *oob)
+{
+        static u8 ignore_buf[512]; /* write only */
+
+        return __alauda_read_page(mtd, from, ignore_buf, oob);
+}
+
+static int popcount8(u8 c)
+{
+        int ret = 0;
+
+        for ( ; c; c>>=1)
+                ret += c & 1;
+        return ret;
+}
+
+static int alauda_isbad(struct mtd_info *mtd, loff_t ofs)
+{
+        u8 oob[16];
+        int err;
+
+        err = alauda_read_oob(mtd, ofs, oob);
+        if (err)
+                return err;
+
+        /* A block is marked bad if two or more bits are zero */
+        return popcount8(oob[5]) >= 7 ? 0 : 1;
+}
+
+static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char *buf)
+{
+        struct alauda *al = mtd->priv;
+        void *bounce_buf;
+        int err, corrected=0, uncorrected=0;
+
+        bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL);
+        if (!bounce_buf)
+                return -ENOMEM;
+
+        *retlen = len;
+        while (len) {
+                u8 oob[16];
+                size_t byte = from & al->bytemask;
+                size_t cplen = min(len, mtd->writesize - byte);
+
+                err = alauda_read_page(mtd, from, bounce_buf, oob,
+                                &corrected, &uncorrected);
+                if (err)
+                        goto out;
+
+                memcpy(buf, bounce_buf + byte, cplen);
+                buf += cplen;
+                from += cplen;
+                len -= cplen;
+        }
+        err = 0;
+        if (corrected)
+                err = -EUCLEAN;
+        if (uncorrected)
+                err = -EBADMSG;
+out:
+        kfree(bounce_buf);
+        return err;
+}
+
+static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char *buf)
+{
+        struct alauda *al = mtd->priv;
+        int err, corrected=0, uncorrected=0;
+
+        if ((from & al->bytemask) || (len & al->bytemask))
+                return alauda_bounce_read(mtd, from, len, retlen, buf);
+
+        *retlen = len;
+        while (len) {
+                u8 oob[16];
+
+                err = alauda_read_page(mtd, from, buf, oob,
+                                &corrected, &uncorrected);
+                if (err)
+                        return err;
+
+                buf += mtd->writesize;
+                from += mtd->writesize;
+                len -= mtd->writesize;
+        }
+        err = 0;
+        if (corrected)
+                err = -EUCLEAN;
+        if (uncorrected)
+                err = -EBADMSG;
+        return err;
+}
+
+static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len,
+                size_t *retlen, const u_char *buf)
+{
+        struct alauda *al = mtd->priv;
+        int err;
+
+        if ((to & al->bytemask) || (len & al->bytemask))
+                return -EINVAL;
+
+        *retlen = len;
+        while (len) {
+                u32 page = (to >> al->card->pageshift) & al->pagemask;
+                u8 oob[16] = {  'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff,
+                                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+                /* don't write to bad blocks */
+                if (page == 0) {
+                        err = alauda_isbad(mtd, to);
+                        if (err) {
+                                return -EIO;
+                        }
+                }
+                nand_calculate_ecc(mtd, buf, &oob[13]);
+                nand_calculate_ecc(mtd, buf+256, &oob[8]);
+
+                err = alauda_write_page(mtd, to, (void*)buf, oob);
+                if (err)
+                        return err;
+
+                buf += mtd->writesize;
+                to += mtd->writesize;
+                len -= mtd->writesize;
+        }
+        return 0;
+}
+
+static int __alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
+{
+        struct alauda *al = mtd->priv;
+        u32 ofs = instr->addr;
+        u32 len = instr->len;
+        int err;
+
+        if ((ofs & al->blockmask) || (len & al->blockmask))
+                return -EINVAL;
+
+        while (len) {
+                /* don't erase bad blocks */
+                err = alauda_isbad(mtd, ofs);
+                if (err > 0)
+                        err = -EIO;
+                if (err < 0)
+                        return err;
+
+                err = alauda_erase_block(mtd, ofs);
+                if (err < 0)
+                        return err;
+
+                ofs += mtd->erasesize;
+                len -= mtd->erasesize;
+        }
+        return 0;
+}
+
+static int alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
+{
+        int err;
+
+        err = __alauda_erase(mtd, instr);
+        instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
+        mtd_erase_callback(instr);
+        return err;
+}
+
+static int alauda_init_media(struct alauda *al)
+{
+        u8 buf[4], *b0=buf, *b1=buf+1;
+        struct alauda_card *card;
+        struct mtd_info *mtd;
+        int err;
+
+        mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
+        if (!mtd)
+                return -ENOMEM;
+
+        for (;;) {
+                err = alauda_get_media_status(al, buf);
+                if (err < 0)
+                        goto error;
+                if (*b0 & 0x10)
+                        break;
+                msleep(20);
+        }
+
+        err = alauda_ack_media(al);
+        if (err)
+                goto error;
+
+        msleep(10);
+
+        err = alauda_get_media_status(al, buf);
+        if (err < 0)
+                goto error;
+
+        if (*b0 != 0x14) {
+                /* media not ready */
+                err = -EIO;
+                goto error;
+        }
+        err = alauda_get_media_signatures(al, buf);
+        if (err < 0)
+                goto error;
+
+        card = get_card(*b1);
+        if (!card) {
+                printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1);
+                err = -EIO;
+                goto error;
+        }
+        printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n",
+                        1<<card->pageshift, 1<<card->blockshift,
+                        1<<(card->chipshift-20));
+        al->card = card;
+        al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1;
+        al->bytemask = (1 << card->pageshift) - 1;
+        al->blockmask = (1 << card->blockshift) - 1;
+
+        mtd->name = "alauda";
+        mtd->size = 1<<card->chipshift;
+        mtd->erasesize = 1<<card->blockshift;
+        mtd->writesize = 1<<card->pageshift;
+        mtd->type = MTD_NANDFLASH;
+        mtd->flags = MTD_CAP_NANDFLASH;
+        mtd->read = alauda_read;
+        mtd->write = alauda_write;
+        mtd->erase = alauda_erase;
+        mtd->block_isbad = alauda_isbad;
+        mtd->priv = al;
+        mtd->owner = THIS_MODULE;
+
+        err = add_mtd_device(mtd);
+        if (err) {
+                err = -ENFILE;
+                goto error;
+        }
+
+        al->mtd = mtd;
+        alauda_reset(al); /* no clue whether this is necessary */
+        return 0;
+error:
+        kfree(mtd);
+        return err;
+}
+
+static int alauda_check_media(struct alauda *al)
+{
+        u8 buf[2], *b0 = buf, *b1 = buf+1;
+        int err;
+
+        err = alauda_get_media_status(al, buf);
+        if (err < 0)
+                return err;
+
+        if ((*b1 & 0x01) == 0) {
+                /* door open */
+                return -EIO;
+        }
+        if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) {
+                /* no media ? */
+                return -EIO;
+        }
+        if (*b0 & 0x08) {
+                /* media change ? */
+                return alauda_init_media(al);
+        }
+        return 0;
+}
+
+static int alauda_probe(struct usb_interface *interface,
+                const struct usb_device_id *id)
+{
+        struct alauda *al;
+        struct usb_host_interface *iface;
+        struct usb_endpoint_descriptor *ep,
+                        *ep_in=NULL, *ep_out=NULL, *ep_wr=NULL;
+        int i, err = -ENOMEM;
+
+        al = kzalloc(2*sizeof(*al), GFP_KERNEL);
+        if (!al)
+                goto error;
+
+        kref_init(&al->kref);
+        usb_set_intfdata(interface, al);
+
+        al->dev = usb_get_dev(interface_to_usbdev(interface));
+        al->interface = interface;
+
+        iface = interface->cur_altsetting;
+        for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
+                ep = &iface->endpoint[i].desc;
+
+                if (usb_endpoint_is_bulk_in(ep)) {
+                        ep_in = ep;
+                } else if (usb_endpoint_is_bulk_out(ep)) {
+                        if (i==0)
+                                ep_wr = ep;
+                        else
+                                ep_out = ep;
+                }
+        }
+        err = -EIO;
+        if (!ep_wr || !ep_in || !ep_out)
+                goto error;
+
+        al->write_out = usb_sndbulkpipe(al->dev,
+                        ep_wr->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+        al->bulk_in = usb_rcvbulkpipe(al->dev,
+                        ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+        al->bulk_out = usb_sndbulkpipe(al->dev,
+                        ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+
+        /* second device is identical up to now */
+        memcpy(al+1, al, sizeof(*al));
+
+        mutex_init(&al[0].card_mutex);
+        mutex_init(&al[1].card_mutex);
+
+        al[0].port = ALAUDA_PORT_XD;
+        al[1].port = ALAUDA_PORT_SM;
+
+        info("alauda probed");
+        alauda_check_media(al);
+        alauda_check_media(al+1);
+
+        return 0;
+
+error:
+        if (al)
+                kref_put(&al->kref, alauda_delete);
+        return err;
+}
+
+static void alauda_disconnect(struct usb_interface *interface)
+{
+        struct alauda *al;
+
+        al = usb_get_intfdata(interface);
+        usb_set_intfdata(interface, NULL);
+
+        /* FIXME: prevent more I/O from starting */
+
+        /* decrement our usage count */
+        if (al)
+                kref_put(&al->kref, alauda_delete);
+
+        info("alauda gone");
+}
+
+static struct usb_driver alauda_driver = {
+        .name =         "alauda",
+        .probe =        alauda_probe,
+        .disconnect =   alauda_disconnect,
+        .id_table =     alauda_table,
+};
+
+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);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/bf5xx_nand.c b/drivers/mtd/nand/bf5xx_nand.c
new file mode 100644
index 0000000000..1657ecd748
--- /dev/null
+++ b/drivers/mtd/nand/bf5xx_nand.c
@@ -0,0 +1,788 @@
+/* linux/drivers/mtd/nand/bf5xx_nand.c
+ *
+ * Copyright 2006-2007 Analog Devices Inc.
+ *      http://blackfin.uclinux.org/
+ *      Bryan Wu <bryan.wu@analog.com>
+ *
+ * Blackfin BF5xx on-chip NAND flash controler driver
+ *
+ * Derived from drivers/mtd/nand/s3c2410.c
+ * Copyright (c) 2007 Ben Dooks <ben@simtec.co.uk>
+ *
+ * Derived from drivers/mtd/nand/cafe.c
+ * Copyright © 2006 Red Hat, Inc.
+ * Copyright © 2006 David Woodhouse <dwmw2@infradead.org>
+ *
+ * Changelog:
+ *      12-Jun-2007  Bryan Wu:  Initial version
+ *      18-Jul-2007  Bryan Wu:
+ *              - ECC_HW and ECC_SW supported
+ *              - DMA supported in ECC_HW
+ *              - YAFFS tested as rootfs in both ECC_HW and ECC_SW
+ *
+ * TODO:
+ *      Enable JFFS2 over NAND as rootfs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/bitops.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/nand_ecc.h>
+#include <linux/mtd/partitions.h>
+
+#include <asm/blackfin.h>
+#include <asm/dma.h>
+#include <asm/cacheflush.h>
+#include <asm/nand.h>
+#include <asm/portmux.h>
+
+#define DRV_NAME        "bf5xx-nand"
+#define DRV_VERSION     "1.2"
+#define DRV_AUTHOR      "Bryan Wu <bryan.wu@analog.com>"
+#define DRV_DESC        "BF5xx on-chip NAND FLash Controller Driver"
+
+#ifdef CONFIG_MTD_NAND_BF5XX_HWECC
+static int hardware_ecc = 1;
+#else
+static int hardware_ecc;
+#endif
+
+static unsigned short bfin_nfc_pin_req[] = {P_NAND_CE, P_NAND_RB, 0};
+
+/*
+ * Data structures for bf5xx nand flash controller driver
+ */
+
+/* bf5xx nand info */
+struct bf5xx_nand_info {
+        /* mtd info */
+        struct nand_hw_control          controller;
+        struct mtd_info                 mtd;
+        struct nand_chip                chip;
+
+        /* platform info */
+        struct bf5xx_nand_platform      *platform;
+
+        /* device info */
+        struct device                   *device;
+
+        /* DMA stuff */
+        struct completion               dma_completion;
+};
+
+/*
+ * Conversion functions
+ */
+static struct bf5xx_nand_info *mtd_to_nand_info(struct mtd_info *mtd)
+{
+        return container_of(mtd, struct bf5xx_nand_info, mtd);
+}
+
+static struct bf5xx_nand_info *to_nand_info(struct platform_device *pdev)
+{
+        return platform_get_drvdata(pdev);
+}
+
+static struct bf5xx_nand_platform *to_nand_plat(struct platform_device *pdev)
+{
+        return pdev->dev.platform_data;
+}
+
+/*
+ * struct nand_chip interface function pointers
+ */
+
+/*
+ * bf5xx_nand_hwcontrol
+ *
+ * Issue command and address cycles to the chip
+ */
+static void bf5xx_nand_hwcontrol(struct mtd_info *mtd, int cmd,
+                                   unsigned int ctrl)
+{
+        if (cmd == NAND_CMD_NONE)
+                return;
+
+        while (bfin_read_NFC_STAT() & WB_FULL)
+                cpu_relax();
+
+        if (ctrl & NAND_CLE)
+                bfin_write_NFC_CMD(cmd);
+        else
+                bfin_write_NFC_ADDR(cmd);
+        SSYNC();
+}
+
+/*
+ * bf5xx_nand_devready()
+ *
+ * returns 0 if the nand is busy, 1 if it is ready
+ */
+static int bf5xx_nand_devready(struct mtd_info *mtd)
+{
+        unsigned short val = bfin_read_NFC_IRQSTAT();
+
+        if ((val & NBUSYIRQ) == NBUSYIRQ)
+                return 1;
+        else
+                return 0;
+}
+
+/*
+ * ECC functions
+ * These allow the bf5xx to use the controller's ECC
+ * generator block to ECC the data as it passes through
+ */
+
+/*
+ * ECC error correction function
+ */
+static int bf5xx_nand_correct_data_256(struct mtd_info *mtd, u_char *dat,
+                                        u_char *read_ecc, u_char *calc_ecc)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        u32 syndrome[5];
+        u32 calced, stored;
+        int i;
+        unsigned short failing_bit, failing_byte;
+        u_char data;
+
+        calced = calc_ecc[0] | (calc_ecc[1] << 8) | (calc_ecc[2] << 16);
+        stored = read_ecc[0] | (read_ecc[1] << 8) | (read_ecc[2] << 16);
+
+        syndrome[0] = (calced ^ stored);
+
+        /*
+         * syndrome 0: all zero
+         * No error in data
+         * No action
+         */
+        if (!syndrome[0] || !calced || !stored)
+                return 0;
+
+        /*
+         * sysdrome 0: only one bit is one
+         * ECC data was incorrect
+         * No action
+         */
+        if (hweight32(syndrome[0]) == 1) {
+                dev_err(info->device, "ECC data was incorrect!\n");
+                return 1;
+        }
+
+        syndrome[1] = (calced & 0x7FF) ^ (stored & 0x7FF);
+        syndrome[2] = (calced & 0x7FF) ^ ((calced >> 11) & 0x7FF);
+        syndrome[3] = (stored & 0x7FF) ^ ((stored >> 11) & 0x7FF);
+        syndrome[4] = syndrome[2] ^ syndrome[3];
+
+        for (i = 0; i < 5; i++)
+                dev_info(info->device, "syndrome[%d] 0x%08x\n", i, syndrome[i]);
+
+        dev_info(info->device,
+                "calced[0x%08x], stored[0x%08x]\n",
+                calced, stored);
+
+        /*
+         * sysdrome 0: exactly 11 bits are one, each parity
+         * and parity' pair is 1 & 0 or 0 & 1.
+         * 1-bit correctable error
+         * Correct the error
+         */
+        if (hweight32(syndrome[0]) == 11 && syndrome[4] == 0x7FF) {
+                dev_info(info->device,
+                        "1-bit correctable error, correct it.\n");
+                dev_info(info->device,
+                        "syndrome[1] 0x%08x\n", syndrome[1]);
+
+                failing_bit = syndrome[1] & 0x7;
+                failing_byte = syndrome[1] >> 0x3;
+                data = *(dat + failing_byte);
+                data = data ^ (0x1 << failing_bit);
+                *(dat + failing_byte) = data;
+
+                return 0;
+        }
+
+        /*
+         * sysdrome 0: random data
+         * More than 1-bit error, non-correctable error
+         * Discard data, mark bad block
+         */
+        dev_err(info->device,
+                "More than 1-bit error, non-correctable error.\n");
+        dev_err(info->device,
+                "Please discard data, mark bad block\n");
+
+        return 1;
+}
+
+static int bf5xx_nand_correct_data(struct mtd_info *mtd, u_char *dat,
+                                        u_char *read_ecc, u_char *calc_ecc)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        struct bf5xx_nand_platform *plat = info->platform;
+        unsigned short page_size = (plat->page_size ? 512 : 256);
+        int ret;
+
+        ret = bf5xx_nand_correct_data_256(mtd, dat, read_ecc, calc_ecc);
+
+        /* If page size is 512, correct second 256 bytes */
+        if (page_size == 512) {
+                dat += 256;
+                read_ecc += 8;
+                calc_ecc += 8;
+                ret = bf5xx_nand_correct_data_256(mtd, dat, read_ecc, calc_ecc);
+        }
+
+        return ret;
+}
+
+static void bf5xx_nand_enable_hwecc(struct mtd_info *mtd, int mode)
+{
+        return;
+}
+
+static int bf5xx_nand_calculate_ecc(struct mtd_info *mtd,
+                const u_char *dat, u_char *ecc_code)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        struct bf5xx_nand_platform *plat = info->platform;
+        u16 page_size = (plat->page_size ? 512 : 256);
+        u16 ecc0, ecc1;
+        u32 code[2];
+        u8 *p;
+        int bytes = 3, i;
+
+        /* first 4 bytes ECC code for 256 page size */
+        ecc0 = bfin_read_NFC_ECC0();
+        ecc1 = bfin_read_NFC_ECC1();
+
+        code[0] = (ecc0 & 0x3FF) | ((ecc1 & 0x3FF) << 11);
+
+        dev_dbg(info->device, "returning ecc 0x%08x\n", code[0]);
+
+        /* second 4 bytes ECC code for 512 page size */
+        if (page_size == 512) {
+                ecc0 = bfin_read_NFC_ECC2();
+                ecc1 = bfin_read_NFC_ECC3();
+                code[1] = (ecc0 & 0x3FF) | ((ecc1 & 0x3FF) << 11);
+                bytes = 6;
+                dev_dbg(info->device, "returning ecc 0x%08x\n", code[1]);
+        }
+
+        p = (u8 *)code;
+        for (i = 0; i < bytes; i++)
+                ecc_code[i] = p[i];
+
+        return 0;
+}
+
+/*
+ * PIO mode for buffer writing and reading
+ */
+static void bf5xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        int i;
+        unsigned short val;
+
+        /*
+         * Data reads are requested by first writing to NFC_DATA_RD
+         * and then reading back from NFC_READ.
+         */
+        for (i = 0; i < len; i++) {
+                while (bfin_read_NFC_STAT() & WB_FULL)
+                        cpu_relax();
+
+                /* Contents do not matter */
+                bfin_write_NFC_DATA_RD(0x0000);
+                SSYNC();
+
+                while ((bfin_read_NFC_IRQSTAT() & RD_RDY) != RD_RDY)
+                        cpu_relax();
+
+                buf[i] = bfin_read_NFC_READ();
+
+                val = bfin_read_NFC_IRQSTAT();
+                val |= RD_RDY;
+                bfin_write_NFC_IRQSTAT(val);
+                SSYNC();
+        }
+}
+
+static uint8_t bf5xx_nand_read_byte(struct mtd_info *mtd)
+{
+        uint8_t val;
+
+        bf5xx_nand_read_buf(mtd, &val, 1);
+
+        return val;
+}
+
+static void bf5xx_nand_write_buf(struct mtd_info *mtd,
+                                const uint8_t *buf, int len)
+{
+        int i;
+
+        for (i = 0; i < len; i++) {
+                while (bfin_read_NFC_STAT() & WB_FULL)
+                        cpu_relax();
+
+                bfin_write_NFC_DATA_WR(buf[i]);
+                SSYNC();
+        }
+}
+
+static void bf5xx_nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        int i;
+        u16 *p = (u16 *) buf;
+        len >>= 1;
+
+        /*
+         * Data reads are requested by first writing to NFC_DATA_RD
+         * and then reading back from NFC_READ.
+         */
+        bfin_write_NFC_DATA_RD(0x5555);
+
+        SSYNC();
+
+        for (i = 0; i < len; i++)
+                p[i] = bfin_read_NFC_READ();
+}
+
+static void bf5xx_nand_write_buf16(struct mtd_info *mtd,
+                                const uint8_t *buf, int len)
+{
+        int i;
+        u16 *p = (u16 *) buf;
+        len >>= 1;
+
+        for (i = 0; i < len; i++)
+                bfin_write_NFC_DATA_WR(p[i]);
+
+        SSYNC();
+}
+
+/*
+ * DMA functions for buffer writing and reading
+ */
+static irqreturn_t bf5xx_nand_dma_irq(int irq, void *dev_id)
+{
+        struct bf5xx_nand_info *info = dev_id;
+
+        clear_dma_irqstat(CH_NFC);
+        disable_dma(CH_NFC);
+        complete(&info->dma_completion);
+
+        return IRQ_HANDLED;
+}
+
+static int bf5xx_nand_dma_rw(struct mtd_info *mtd,
+                                uint8_t *buf, int is_read)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        struct bf5xx_nand_platform *plat = info->platform;
+        unsigned short page_size = (plat->page_size ? 512 : 256);
+        unsigned short val;
+
+        dev_dbg(info->device, " mtd->%p, buf->%p, is_read %d\n",
+                        mtd, buf, is_read);
+
+        /*
+         * Before starting a dma transfer, be sure to invalidate/flush
+         * the cache over the address range of your DMA buffer to
+         * prevent cache coherency problems. Otherwise very subtle bugs
+         * can be introduced to your driver.
+         */
+        if (is_read)
+                invalidate_dcache_range((unsigned int)buf,
+                                (unsigned int)(buf + page_size));
+        else
+                flush_dcache_range((unsigned int)buf,
+                                (unsigned int)(buf + page_size));
+
+        /*
+         * This register must be written before each page is
+         * transferred to generate the correct ECC register
+         * values.
+         */
+        bfin_write_NFC_RST(0x1);
+        SSYNC();
+
+        disable_dma(CH_NFC);
+        clear_dma_irqstat(CH_NFC);
+
+        /* setup DMA register with Blackfin DMA API */
+        set_dma_config(CH_NFC, 0x0);
+        set_dma_start_addr(CH_NFC, (unsigned long) buf);
+        set_dma_x_count(CH_NFC, (page_size >> 2));
+        set_dma_x_modify(CH_NFC, 4);
+
+        /* setup write or read operation */
+        val = DI_EN | WDSIZE_32;
+        if (is_read)
+                val |= WNR;
+        set_dma_config(CH_NFC, val);
+        enable_dma(CH_NFC);
+
+        /* Start PAGE read/write operation */
+        if (is_read)
+                bfin_write_NFC_PGCTL(0x1);
+        else
+                bfin_write_NFC_PGCTL(0x2);
+        wait_for_completion(&info->dma_completion);
+
+        return 0;
+}
+
+static void bf5xx_nand_dma_read_buf(struct mtd_info *mtd,
+                                        uint8_t *buf, int len)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        struct bf5xx_nand_platform *plat = info->platform;
+        unsigned short page_size = (plat->page_size ? 512 : 256);
+
+        dev_dbg(info->device, "mtd->%p, buf->%p, int %d\n", mtd, buf, len);
+
+        if (len == page_size)
+                bf5xx_nand_dma_rw(mtd, buf, 1);
+        else
+                bf5xx_nand_read_buf(mtd, buf, len);
+}
+
+static void bf5xx_nand_dma_write_buf(struct mtd_info *mtd,
+                                const uint8_t *buf, int len)
+{
+        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
+        struct bf5xx_nand_platform *plat = info->platform;
+        unsigned short page_size = (plat->page_size ? 512 : 256);
+
+        dev_dbg(info->device, "mtd->%p, buf->%p, len %d\n", mtd, buf, len);
+
+        if (len == page_size)
+                bf5xx_nand_dma_rw(mtd, (uint8_t *)buf, 0);
+        else
+                bf5xx_nand_write_buf(mtd, buf, len);
+}
+
+/*
+ * System initialization functions
+ */
+
+static int bf5xx_nand_dma_init(struct bf5xx_nand_info *info)
+{
+        int ret;
+        unsigned short val;
+
+        /* Do not use dma */
+        if (!hardware_ecc)
+                return 0;
+
+        init_completion(&info->dma_completion);
+
+        /* Setup DMAC1 channel mux for NFC which shared with SDH */
+        val = bfin_read_DMAC1_PERIMUX();
+        val &= 0xFFFE;
+        bfin_write_DMAC1_PERIMUX(val);
+        SSYNC();
+
+        /* Request NFC DMA channel */
+        ret = request_dma(CH_NFC, "BF5XX NFC driver");
+        if (ret < 0) {
+                dev_err(info->device, " unable to get DMA channel\n");
+                return ret;
+        }
+
+        set_dma_callback(CH_NFC, (void *) bf5xx_nand_dma_irq, (void *) info);
+
+        /* Turn off the DMA channel first */
+        disable_dma(CH_NFC);
+        return 0;
+}
+
+/*
+ * BF5XX NFC hardware initialization
+ *  - pin mux setup
+ *  - clear interrupt status
+ */
+static int bf5xx_nand_hw_init(struct bf5xx_nand_info *info)
+{
+        int err = 0;
+        unsigned short val;
+        struct bf5xx_nand_platform *plat = info->platform;
+
+        /* setup NFC_CTL register */
+        dev_info(info->device,
+                "page_size=%d, data_width=%d, wr_dly=%d, rd_dly=%d\n",
+                (plat->page_size ? 512 : 256),
+                (plat->data_width ? 16 : 8),
+                plat->wr_dly, plat->rd_dly);
+
+        val = (plat->page_size << NFC_PG_SIZE_OFFSET) |
+                (plat->data_width << NFC_NWIDTH_OFFSET) |
+                (plat->rd_dly << NFC_RDDLY_OFFSET) |
+                (plat->rd_dly << NFC_WRDLY_OFFSET);
+        dev_dbg(info->device, "NFC_CTL is 0x%04x\n", val);
+
+        bfin_write_NFC_CTL(val);
+        SSYNC();
+
+        /* clear interrupt status */
+        bfin_write_NFC_IRQMASK(0x0);
+        SSYNC();
+        val = bfin_read_NFC_IRQSTAT();
+        bfin_write_NFC_IRQSTAT(val);
+        SSYNC();
+
+        if (peripheral_request_list(bfin_nfc_pin_req, DRV_NAME)) {
+                printk(KERN_ERR DRV_NAME
+                ": Requesting Peripherals failed\n");
+                return -EFAULT;
+        }
+
+        /* DMA initialization  */
+        if (bf5xx_nand_dma_init(info))
+                err = -ENXIO;
+
+        return err;
+}
+
+/*
+ * Device management interface
+ */
+static int bf5xx_nand_add_partition(struct bf5xx_nand_info *info)
+{
+        struct mtd_info *mtd = &info->mtd;
+
+#ifdef CONFIG_MTD_PARTITIONS
+        struct mtd_partition *parts = info->platform->partitions;
+        int nr = info->platform->nr_partitions;
+
+        return add_mtd_partitions(mtd, parts, nr);
+#else
+        return add_mtd_device(mtd);
+#endif
+}
+
+static int bf5xx_nand_remove(struct platform_device *pdev)
+{
+        struct bf5xx_nand_info *info = to_nand_info(pdev);
+        struct mtd_info *mtd = NULL;
+
+        platform_set_drvdata(pdev, NULL);
+
+        /* first thing we need to do is release all our mtds
+         * and their partitions, then go through freeing the
+         * resources used
+         */
+        mtd = &info->mtd;
+        if (mtd) {
+                nand_release(mtd);
+                kfree(mtd);
+        }
+
+        peripheral_free_list(bfin_nfc_pin_req);
+
+        /* free the common resources */
+        kfree(info);
+
+        return 0;
+}
+
+/*
+ * bf5xx_nand_probe
+ *
+ * called by device layer when it finds a device matching
+ * one our driver can handled. This code checks to see if
+ * it can allocate all necessary resources then calls the
+ * nand layer to look for devices
+ */
+static int bf5xx_nand_probe(struct platform_device *pdev)
+{
+        struct bf5xx_nand_platform *plat = to_nand_plat(pdev);
+        struct bf5xx_nand_info *info = NULL;
+        struct nand_chip *chip = NULL;
+        struct mtd_info *mtd = NULL;
+        int err = 0;
+
+        dev_dbg(&pdev->dev, "(%p)\n", pdev);
+
+        if (!plat) {
+                dev_err(&pdev->dev, "no platform specific information\n");
+                goto exit_error;
+        }
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (info == NULL) {
+                dev_err(&pdev->dev, "no memory for flash info\n");
+                err = -ENOMEM;
+                goto exit_error;
+        }
+
+        platform_set_drvdata(pdev, info);
+
+        spin_lock_init(&info->controller.lock);
+        init_waitqueue_head(&info->controller.wq);
+
+        info->device     = &pdev->dev;
+        info->platform   = plat;
+
+        /* initialise chip data struct */
+        chip = &info->chip;
+
+        if (plat->data_width)
+                chip->options |= NAND_BUSWIDTH_16;
+
+        chip->options |= NAND_CACHEPRG | NAND_SKIP_BBTSCAN;
+
+        chip->read_buf = (plat->data_width) ?
+                bf5xx_nand_read_buf16 : bf5xx_nand_read_buf;
+        chip->write_buf = (plat->data_width) ?
+                bf5xx_nand_write_buf16 : bf5xx_nand_write_buf;
+
+        chip->read_byte    = bf5xx_nand_read_byte;
+
+        chip->cmd_ctrl     = bf5xx_nand_hwcontrol;
+        chip->dev_ready    = bf5xx_nand_devready;
+
+        chip->priv         = &info->mtd;
+        chip->controller   = &info->controller;
+
+        chip->IO_ADDR_R    = (void __iomem *) NFC_READ;
+        chip->IO_ADDR_W    = (void __iomem *) NFC_DATA_WR;
+
+        chip->chip_delay   = 0;
+
+        /* initialise mtd info data struct */
+        mtd             = &info->mtd;
+        mtd->priv       = chip;
+        mtd->owner      = THIS_MODULE;
+
+        /* initialise the hardware */
+        err = bf5xx_nand_hw_init(info);
+        if (err != 0)
+                goto exit_error;
+
+        /* setup hardware ECC data struct */
+        if (hardware_ecc) {
+                if (plat->page_size == NFC_PG_SIZE_256) {
+                        chip->ecc.bytes = 3;
+                        chip->ecc.size = 256;
+                } else if (plat->page_size == NFC_PG_SIZE_512) {
+                        chip->ecc.bytes = 6;
+                        chip->ecc.size = 512;
+                }
+
+                chip->read_buf      = bf5xx_nand_dma_read_buf;
+                chip->write_buf     = bf5xx_nand_dma_write_buf;
+                chip->ecc.calculate = bf5xx_nand_calculate_ecc;
+                chip->ecc.correct   = bf5xx_nand_correct_data;
+                chip->ecc.mode      = NAND_ECC_HW;
+                chip->ecc.hwctl     = bf5xx_nand_enable_hwecc;
+        } else {
+                chip->ecc.mode      = NAND_ECC_SOFT;
+        }
+
+        /* scan hardware nand chip and setup mtd info data struct */
+        if (nand_scan(mtd, 1)) {
+                err = -ENXIO;
+                goto exit_error;
+        }
+
+        /* add NAND partition */
+        bf5xx_nand_add_partition(info);
+
+        dev_dbg(&pdev->dev, "initialised ok\n");
+        return 0;
+
+exit_error:
+        bf5xx_nand_remove(pdev);
+
+        if (err == 0)
+                err = -EINVAL;
+        return err;
+}
+
+/* PM Support */
+#ifdef CONFIG_PM
+
+static int bf5xx_nand_suspend(struct platform_device *dev, pm_message_t pm)
+{
+        struct bf5xx_nand_info *info = platform_get_drvdata(dev);
+
+        return 0;
+}
+
+static int bf5xx_nand_resume(struct platform_device *dev)
+{
+        struct bf5xx_nand_info *info = platform_get_drvdata(dev);
+
+        if (info)
+                bf5xx_nand_hw_init(info);
+
+        return 0;
+}
+
+#else
+#define bf5xx_nand_suspend NULL
+#define bf5xx_nand_resume NULL
+#endif
+
+/* driver device registration */
+static struct platform_driver bf5xx_nand_driver = {
+        .probe          = bf5xx_nand_probe,
+        .remove         = bf5xx_nand_remove,
+        .suspend        = bf5xx_nand_suspend,
+        .resume         = bf5xx_nand_resume,
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init bf5xx_nand_init(void)
+{
+        printk(KERN_INFO "%s, Version %s (c) 2007 Analog Devices, Inc.\n",
+                DRV_DESC, DRV_VERSION);
+
+        return platform_driver_register(&bf5xx_nand_driver);
+}
+
+static void __exit bf5xx_nand_exit(void)
+{
+        platform_driver_unregister(&bf5xx_nand_driver);
+}
+
+module_init(bf5xx_nand_init);
+module_exit(bf5xx_nand_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR(DRV_AUTHOR);
+MODULE_DESCRIPTION(DRV_DESC);
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index 6f32a35eb1..e2832d0b98 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -623,6 +623,11 @@ static int __devinit cafe_nand_probe(struct pci_dev *pdev,
         uint32_t ctrl;
         int err = 0;
 
+        /* Very old versions shared the same PCI ident for all three
+           functions on the chip. Verify the class too... */
+        if ((pdev->class >> 8) != PCI_CLASS_MEMORY_FLASH)
+                return -ENODEV;
+
         err = pci_enable_device(pdev);
         if (err)
                 return err;
@@ -816,21 +821,57 @@ static void __devexit cafe_nand_remove(struct pci_dev *pdev)
 }
 
 static struct pci_device_id cafe_nand_tbl[] = {
-        { 0x11ab, 0x4100, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MEMORY_FLASH << 8, 0xFFFF0 },
-        { 0, }
+        { 0x11ab, 0x4100, PCI_ANY_ID, PCI_ANY_ID },
+        { }
 };
 
 MODULE_DEVICE_TABLE(pci, cafe_nand_tbl);
 
+static int cafe_nand_resume(struct pci_dev *pdev)
+{
+        uint32_t ctrl;
+        struct mtd_info *mtd = pci_get_drvdata(pdev);
+        struct cafe_priv *cafe = mtd->priv;
+
+       /* Start off by resetting the NAND controller completely */
+        cafe_writel(cafe, 1, NAND_RESET);
+        cafe_writel(cafe, 0, NAND_RESET);
+        cafe_writel(cafe, 0xffffffff, NAND_IRQ_MASK);
+
+        /* Restore timing configuration */
+        cafe_writel(cafe, timing[0], NAND_TIMING1);
+        cafe_writel(cafe, timing[1], NAND_TIMING2);
+        cafe_writel(cafe, timing[2], NAND_TIMING3);
+
+        /* Disable master reset, enable NAND clock */
+        ctrl = cafe_readl(cafe, GLOBAL_CTRL);
+        ctrl &= 0xffffeff0;
+        ctrl |= 0x00007000;
+        cafe_writel(cafe, ctrl | 0x05, GLOBAL_CTRL);
+        cafe_writel(cafe, ctrl | 0x0a, GLOBAL_CTRL);
+        cafe_writel(cafe, 0, NAND_DMA_CTRL);
+        cafe_writel(cafe, 0x7006, GLOBAL_CTRL);
+        cafe_writel(cafe, 0x700a, GLOBAL_CTRL);
+
+        /* Set up DMA address */
+        cafe_writel(cafe, cafe->dmaaddr & 0xffffffff, NAND_DMA_ADDR0);
+        if (sizeof(cafe->dmaaddr) > 4)
+        /* Shift in two parts to shut the compiler up */
+                cafe_writel(cafe, (cafe->dmaaddr >> 16) >> 16, NAND_DMA_ADDR1);
+        else
+                cafe_writel(cafe, 0, NAND_DMA_ADDR1);
+
+        /* Enable NAND IRQ in global IRQ mask register */
+        cafe_writel(cafe, 0x80000007, GLOBAL_IRQ_MASK);
+        return 0;
+}
+
 static struct pci_driver cafe_nand_pci_driver = {
         .name = "CAFÉ NAND",
         .id_table = cafe_nand_tbl,
         .probe = cafe_nand_probe,
         .remove = __devexit_p(cafe_nand_remove),
-#ifdef CONFIG_PMx
-        .suspend = cafe_nand_suspend,
         .resume = cafe_nand_resume,
-#endif
 };
 
 static int cafe_nand_init(void)
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index e96259f22c..ab9f5c5db3 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -56,8 +56,6 @@ static unsigned long __initdata doc_locations[] = {
 #endif /*  CONFIG_MTD_DOCPROBE_HIGH */
 #elif defined(__PPC__)
         0xe4000000,
-#elif defined(CONFIG_MOMENCO_OCELOT_G)
-        0xff000000,
 #else
 #warning Unknown architecture for DiskOnChip. No default probe locations defined
 #endif
diff --git a/drivers/mtd/nand/excite_nandflash.c b/drivers/mtd/nand/excite_nandflash.c
index 7e9afc4c77..bed87290de 100644
--- a/drivers/mtd/nand/excite_nandflash.c
+++ b/drivers/mtd/nand/excite_nandflash.c
@@ -27,7 +27,6 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/err.h>
-#include <linux/kernel.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 24ac6778b1..b4e0e77238 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -7,7 +7,7 @@
  *   Basic support for AG-AND chips is provided.
  *
  *      Additional technical information is available on
- *      http://www.linux-mtd.infradead.org/tech/nand.html
+ *      http://www.linux-mtd.infradead.org/doc/nand.html
  *
  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  *                2002-2006 Thomas Gleixner (tglx@linutronix.de)
@@ -2069,13 +2069,14 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
  erase_exit:
 
         ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
-        /* Do call back function */
-        if (!ret)
-                mtd_erase_callback(instr);
 
         /* Deselect and wake up anyone waiting on the device */
         nand_release_device(mtd);
 
+        /* Do call back function */
+        if (!ret)
+                mtd_erase_callback(instr);
+
         /*
          * If BBT requires refresh and erase was successful, rewrite any
          * selected bad block tables
diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c
index 2fc674a190..a3e3ab0185 100644
--- a/drivers/mtd/nand/nand_ids.c
+++ b/drivers/mtd/nand/nand_ids.c
@@ -141,6 +141,7 @@ struct nand_manufacturers nand_manuf_ids[] = {
         {NAND_MFR_STMICRO, "ST Micro"},
         {NAND_MFR_HYNIX, "Hynix"},
         {NAND_MFR_MICRON, "Micron"},
+        {NAND_MFR_AMD, "AMD"},
         {0x0, "Unknown"}
 };
 
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 205df0f771..a7574807dc 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -1272,7 +1272,13 @@ static int prog_page(struct nandsim *ns, int num)
         mypage = NS_GET_PAGE(ns);
         if (mypage->byte == NULL) {
                 NS_DBG("prog_page: allocating page %d\n", ns->regs.row);
-                mypage->byte = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
+                /*
+                 * We allocate memory with GFP_NOFS because a flash FS may
+                 * utilize this. If it is holding an FS lock, then gets here,
+                 * then kmalloc runs writeback which goes to the FS again
+                 * and deadlocks. This was seen in practice.
+                 */
+                mypage->byte = kmalloc(ns->geom.pgszoob, GFP_NOFS);
                 if (mypage->byte == NULL) {
                         NS_ERR("prog_page: error allocating memory for page %d\n", ns->regs.row);
                         return -1;
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index fd7a8d5ba2..1c0e89f00e 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -24,7 +24,11 @@
 #include <linux/platform_device.h>
 
 #include <asm/io.h>
+#ifdef CONFIG_40x
+#include <asm/ibm405.h>
+#else
 #include <asm/ibm44x.h>
+#endif
 
 struct ndfc_nand_mtd {
         struct mtd_info                 mtd;
@@ -230,7 +234,11 @@ static int ndfc_nand_probe(struct platform_device *pdev)
         struct ndfc_controller *ndfc = &ndfc_ctrl;
         unsigned long long phys = settings->ndfc_erpn | res->start;
 
+#ifndef CONFIG_PHYS_64BIT
+        ndfc->ndfcbase = ioremap((phys_addr_t)phys, res->end - res->start + 1);
+#else
         ndfc->ndfcbase = ioremap64(phys, res->end - res->start + 1);
+#endif
         if (!ndfc->ndfcbase) {
                 printk(KERN_ERR "NDFC: ioremap failed\n");
                 return -EIO;
diff --git a/drivers/mtd/nand/s3c2410.c b/drivers/mtd/nand/s3c2410.c
index 5fac4c421a..b79a9cf2d1 100644
--- a/drivers/mtd/nand/s3c2410.c
+++ b/drivers/mtd/nand/s3c2410.c
@@ -60,8 +60,8 @@
 
 #include <asm/io.h>
 
-#include <asm/arch/regs-nand.h>
-#include <asm/arch/nand.h>
+#include <asm/plat-s3c/regs-nand.h>
+#include <asm/plat-s3c/nand.h>
 
 #ifdef CONFIG_MTD_NAND_S3C2410_HWECC
 static int hardware_ecc = 1;
diff --git a/drivers/mtd/onenand/Kconfig b/drivers/mtd/onenand/Kconfig
index c257d397d0..cb41cbca64 100644
--- a/drivers/mtd/onenand/Kconfig
+++ b/drivers/mtd/onenand/Kconfig
@@ -40,4 +40,27 @@ config MTD_ONENAND_OTP
 
           OTP block is fully-guaranteed to be a valid block.
 
+config MTD_ONENAND_2X_PROGRAM
+        bool "OneNAND 2X program support"
+        help
+          The 2X Program is an extension of Program Operation.
+          Since the device is equipped with two DataRAMs, and two-plane NAND
+          Flash memory array, these two component enables simultaneous program
+          of 4KiB. Plane1 has only even blocks such as block0, block2, block4
+          while Plane2 has only odd blocks such as block1, block3, block5.
+          So MTD regards it as 4KiB page size and 256KiB block size
+
+          Now the following chips support it. (KFXXX16Q2M)
+            Demux: KFG2G16Q2M, KFH4G16Q2M, KFW8G16Q2M,
+            Mux:   KFM2G16Q2M, KFN4G16Q2M,
+
+          And more recent chips
+
+config MTD_ONENAND_SIM
+        tristate "OneNAND simulator support"
+        depends on MTD_PARTITIONS
+        help
+          The simulator may simulate various OneNAND flash chips for the
+          OneNAND MTD layer.
+
 endif # MTD_ONENAND
diff --git a/drivers/mtd/onenand/Makefile b/drivers/mtd/onenand/Makefile
index 269cfe4673..4d2eacfd7e 100644
--- a/drivers/mtd/onenand/Makefile
+++ b/drivers/mtd/onenand/Makefile
@@ -8,4 +8,7 @@ obj-$(CONFIG_MTD_ONENAND)		+= onenand.o
 # Board specific.
 obj-$(CONFIG_MTD_ONENAND_GENERIC)       += generic.o
 
+# Simulator
+obj-$(CONFIG_MTD_ONENAND_SIM)           += onenand_sim.o
+
 onenand-objs = onenand_base.o onenand_bbt.o
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 0537fac8de..b2c40f67db 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -206,6 +206,15 @@ static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t le
         default:
                 block = (int) (addr >> this->erase_shift);
                 page = (int) (addr >> this->page_shift);
+
+                if (ONENAND_IS_2PLANE(this)) {
+                        /* Make the even block number */
+                        block &= ~1;
+                        /* Is it the odd plane? */
+                        if (addr & this->writesize)
+                                block++;
+                        page >>= 1;
+                }
                 page &= this->page_mask;
                 break;
         }
@@ -216,8 +225,12 @@ static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t le
                 value = onenand_bufferram_address(this, block);
                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
 
-                /* Switch to the next data buffer */
-                ONENAND_SET_NEXT_BUFFERRAM(this);
+                if (ONENAND_IS_2PLANE(this))
+                        /* It is always BufferRAM0 */
+                        ONENAND_SET_BUFFERRAM0(this);
+                else
+                        /* Switch to the next data buffer */
+                        ONENAND_SET_NEXT_BUFFERRAM(this);
 
                 return 0;
         }
@@ -247,6 +260,8 @@ static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t le
                         break;
 
                 default:
+                        if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
+                                cmd = ONENAND_CMD_2X_PROG;
                         dataram = ONENAND_CURRENT_BUFFERRAM(this);
                         break;
                 }
@@ -318,12 +333,14 @@ static int onenand_wait(struct mtd_info *mtd, int state)
         if (interrupt & ONENAND_INT_READ) {
                 int ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS);
                 if (ecc) {
-                        printk(KERN_ERR "onenand_wait: ECC error = 0x%04x\n", ecc);
                         if (ecc & ONENAND_ECC_2BIT_ALL) {
+                                printk(KERN_ERR "onenand_wait: ECC error = 0x%04x\n", ecc);
                                 mtd->ecc_stats.failed++;
                                 return ecc;
-                        } else if (ecc & ONENAND_ECC_1BIT_ALL)
+                        } else if (ecc & ONENAND_ECC_1BIT_ALL) {
+                                printk(KERN_INFO "onenand_wait: correctable ECC error = 0x%04x\n", ecc);
                                 mtd->ecc_stats.corrected++;
+                        }
                 }
         } else if (state == FL_READING) {
                 printk(KERN_ERR "onenand_wait: read timeout! ctrl=0x%04x intr=0x%04x\n", ctrl, interrupt);
@@ -445,8 +462,9 @@ static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area)
         struct onenand_chip *this = mtd->priv;
 
         if (ONENAND_CURRENT_BUFFERRAM(this)) {
+                /* Note: the 'this->writesize' is a real page size */
                 if (area == ONENAND_DATARAM)
-                        return mtd->writesize;
+                        return this->writesize;
                 if (area == ONENAND_SPARERAM)
                         return mtd->oobsize;
         }
@@ -572,6 +590,30 @@ static int onenand_write_bufferram(struct mtd_info *mtd, int area,
 }
 
 /**
+ * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode
+ * @param mtd           MTD data structure
+ * @param addr          address to check
+ * @return              blockpage address
+ *
+ * Get blockpage address at 2x program mode
+ */
+static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
+{
+        struct onenand_chip *this = mtd->priv;
+        int blockpage, block, page;
+
+        /* Calculate the even block number */
+        block = (int) (addr >> this->erase_shift) & ~1;
+        /* Is it the odd plane? */
+        if (addr & this->writesize)
+                block++;
+        page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
+        blockpage = (block << 7) | page;
+
+        return blockpage;
+}
+
+/**
  * onenand_check_bufferram - [GENERIC] Check BufferRAM information
  * @param mtd           MTD data structure
  * @param addr          address to check
@@ -585,7 +627,10 @@ static int onenand_check_bufferram(struct mtd_info *mtd, loff_t addr)
         int blockpage, found = 0;
         unsigned int i;
 
-        blockpage = (int) (addr >> this->page_shift);
+        if (ONENAND_IS_2PLANE(this))
+                blockpage = onenand_get_2x_blockpage(mtd, addr);
+        else
+                blockpage = (int) (addr >> this->page_shift);
 
         /* Is there valid data? */
         i = ONENAND_CURRENT_BUFFERRAM(this);
@@ -625,7 +670,10 @@ static void onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
         int blockpage;
         unsigned int i;
 
-        blockpage = (int) (addr >> this->page_shift);
+        if (ONENAND_IS_2PLANE(this))
+                blockpage = onenand_get_2x_blockpage(mtd, addr);
+        else
+                blockpage = (int) (addr >> this->page_shift);
 
         /* Invalidate another BufferRAM */
         i = ONENAND_NEXT_BUFFERRAM(this);
@@ -717,36 +765,86 @@ static void onenand_release_device(struct mtd_info *mtd)
 }
 
 /**
- * onenand_read - [MTD Interface] Read data from flash
+ * onenand_transfer_auto_oob - [Internal] oob auto-placement transfer
+ * @param mtd           MTD device structure
+ * @param buf           destination address
+ * @param column        oob offset to read from
+ * @param thislen       oob length to read
+ */
+static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, int column,
+                                int thislen)
+{
+        struct onenand_chip *this = mtd->priv;
+        struct nand_oobfree *free;
+        int readcol = column;
+        int readend = column + thislen;
+        int lastgap = 0;
+        unsigned int i;
+        uint8_t *oob_buf = this->oob_buf;
+
+        free = this->ecclayout->oobfree;
+        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
+                if (readcol >= lastgap)
+                        readcol += free->offset - lastgap;
+                if (readend >= lastgap)
+                        readend += free->offset - lastgap;
+                lastgap = free->offset + free->length;
+        }
+        this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
+        free = this->ecclayout->oobfree;
+        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
+                int free_end = free->offset + free->length;
+                if (free->offset < readend && free_end > readcol) {
+                        int st = max_t(int,free->offset,readcol);
+                        int ed = min_t(int,free_end,readend);
+                        int n = ed - st;
+                        memcpy(buf, oob_buf + st, n);
+                        buf += n;
+                } else if (column == 0)
+                        break;
+        }
+        return 0;
+}
+
+/**
+ * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band
  * @param mtd           MTD device structure
  * @param from          offset to read from
- * @param len           number of bytes to read
- * @param retlen        pointer to variable to store the number of read bytes
- * @param buf           the databuffer to put data
+ * @param ops:          oob operation description structure
  *
- * Read with ecc
-*/
-static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
-        size_t *retlen, u_char *buf)
+ * OneNAND read main and/or out-of-band data
+ */
+static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from,
+                                struct mtd_oob_ops *ops)
 {
         struct onenand_chip *this = mtd->priv;
         struct mtd_ecc_stats stats;
-        int read = 0, column;
-        int thislen;
+        size_t len = ops->len;
+        size_t ooblen = ops->ooblen;
+        u_char *buf = ops->datbuf;
+        u_char *oobbuf = ops->oobbuf;
+        int read = 0, column, thislen;
+        int oobread = 0, oobcolumn, thisooblen, oobsize;
         int ret = 0, boundary = 0;
+        int writesize = this->writesize;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read_ops_nolock: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
+
+        if (ops->mode == MTD_OOB_AUTO)
+                oobsize = this->ecclayout->oobavail;
+        else
+                oobsize = mtd->oobsize;
+
+        oobcolumn = from & (mtd->oobsize - 1);
 
         /* Do not allow reads past end of device */
         if ((from + len) > mtd->size) {
-                printk(KERN_ERR "onenand_read: Attempt read beyond end of device\n");
-                *retlen = 0;
+                printk(KERN_ERR "onenand_read_ops_nolock: Attempt read beyond end of device\n");
+                ops->retlen = 0;
+                ops->oobretlen = 0;
                 return -EINVAL;
         }
 
-        /* Grab the lock and see if the device is available */
-        onenand_get_device(mtd, FL_READING);
-
         stats = mtd->ecc_stats;
 
         /* Read-while-load method */
@@ -754,22 +852,22 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
         /* Do first load to bufferRAM */
         if (read < len) {
                 if (!onenand_check_bufferram(mtd, from)) {
-                        this->command(mtd, ONENAND_CMD_READ, from, mtd->writesize);
+                        this->command(mtd, ONENAND_CMD_READ, from, writesize);
                         ret = this->wait(mtd, FL_READING);
                         onenand_update_bufferram(mtd, from, !ret);
                 }
         }
 
-        thislen = min_t(int, mtd->writesize, len - read);
-        column = from & (mtd->writesize - 1);
-        if (column + thislen > mtd->writesize)
-                thislen = mtd->writesize - column;
+        thislen = min_t(int, writesize, len - read);
+        column = from & (writesize - 1);
+        if (column + thislen > writesize)
+                thislen = writesize - column;
 
         while (!ret) {
                 /* If there is more to load then start next load */
                 from += thislen;
                 if (read + thislen < len) {
-                        this->command(mtd, ONENAND_CMD_READ, from, mtd->writesize);
+                        this->command(mtd, ONENAND_CMD_READ, from, writesize);
                         /*
                          * Chip boundary handling in DDP
                          * Now we issued chip 1 read and pointed chip 1
@@ -785,6 +883,21 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
                 }
                 /* While load is going, read from last bufferRAM */
                 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
+
+                /* Read oob area if needed */
+                if (oobbuf) {
+                        thisooblen = oobsize - oobcolumn;
+                        thisooblen = min_t(int, thisooblen, ooblen - oobread);
+
+                        if (ops->mode == MTD_OOB_AUTO)
+                                onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
+                        else
+                                this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
+                        oobread += thisooblen;
+                        oobbuf += thisooblen;
+                        oobcolumn = 0;
+                }
+
                 /* See if we are done */
                 read += thislen;
                 if (read == len)
@@ -794,7 +907,7 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
                         this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
                 ONENAND_SET_NEXT_BUFFERRAM(this);
                 buf += thislen;
-                thislen = min_t(int, mtd->writesize, len - read);
+                thislen = min_t(int, writesize, len - read);
                 column = 0;
                 cond_resched();
                 /* Now wait for load */
@@ -802,15 +915,13 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
                 onenand_update_bufferram(mtd, from, !ret);
         }
 
-        /* Deselect and wake up anyone waiting on the device */
-        onenand_release_device(mtd);
-
         /*
          * Return success, if no ECC failures, else -EBADMSG
          * fs driver will take care of that, because
          * retlen == desired len and result == -EBADMSG
          */
-        *retlen = read;
+        ops->retlen = read;
+        ops->oobretlen = oobread;
 
         if (mtd->ecc_stats.failed - stats.failed)
                 return -EBADMSG;
@@ -822,69 +933,29 @@ static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
 }
 
 /**
- * onenand_transfer_auto_oob - [Internal] oob auto-placement transfer
- * @param mtd           MTD device structure
- * @param buf           destination address
- * @param column        oob offset to read from
- * @param thislen       oob length to read
- */
-static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, int column,
-                                int thislen)
-{
-        struct onenand_chip *this = mtd->priv;
-        struct nand_oobfree *free;
-        int readcol = column;
-        int readend = column + thislen;
-        int lastgap = 0;
-        unsigned int i;
-        uint8_t *oob_buf = this->oob_buf;
-
-        free = this->ecclayout->oobfree;
-        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
-                if (readcol >= lastgap)
-                        readcol += free->offset - lastgap;
-                if (readend >= lastgap)
-                        readend += free->offset - lastgap;
-                lastgap = free->offset + free->length;
-        }
-        this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
-        free = this->ecclayout->oobfree;
-        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
-                int free_end = free->offset + free->length;
-                if (free->offset < readend && free_end > readcol) {
-                        int st = max_t(int,free->offset,readcol);
-                        int ed = min_t(int,free_end,readend);
-                        int n = ed - st;
-                        memcpy(buf, oob_buf + st, n);
-                        buf += n;
-                } else if (column == 0)
-                        break;
-        }
-        return 0;
-}
-
-/**
- * onenand_do_read_oob - [MTD Interface] OneNAND read out-of-band
+ * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band
  * @param mtd           MTD device structure
  * @param from          offset to read from
- * @param len           number of bytes to read
- * @param retlen        pointer to variable to store the number of read bytes
- * @param buf           the databuffer to put data
- * @param mode          operation mode
+ * @param ops:          oob operation description structure
  *
  * OneNAND read out-of-band data from the spare area
  */
-static int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
-                        size_t *retlen, u_char *buf, mtd_oob_mode_t mode)
+static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from,
+                        struct mtd_oob_ops *ops)
 {
         struct onenand_chip *this = mtd->priv;
         int read = 0, thislen, column, oobsize;
+        size_t len = ops->ooblen;
+        mtd_oob_mode_t mode = ops->mode;
+        u_char *buf = ops->oobbuf;
         int ret = 0;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
+        from += ops->ooboffs;
+
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_read_oob_nolock: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
 
         /* Initialize return length value */
-        *retlen = 0;
+        ops->oobretlen = 0;
 
         if (mode == MTD_OOB_AUTO)
                 oobsize = this->ecclayout->oobavail;
@@ -894,7 +965,7 @@ static int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
         column = from & (mtd->oobsize - 1);
 
         if (unlikely(column >= oobsize)) {
-                printk(KERN_ERR "onenand_read_oob: Attempted to start read outside oob\n");
+                printk(KERN_ERR "onenand_read_oob_nolock: Attempted to start read outside oob\n");
                 return -EINVAL;
         }
 
@@ -902,13 +973,10 @@ static int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
         if (unlikely(from >= mtd->size ||
                      column + len > ((mtd->size >> this->page_shift) -
                                      (from >> this->page_shift)) * oobsize)) {
-                printk(KERN_ERR "onenand_read_oob: Attempted to read beyond end of device\n");
+                printk(KERN_ERR "onenand_read_oob_nolock: Attempted to read beyond end of device\n");
                 return -EINVAL;
         }
 
-        /* Grab the lock and see if the device is available */
-        onenand_get_device(mtd, FL_READING);
-
         while (read < len) {
                 cond_resched();
 
@@ -928,7 +996,7 @@ static int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
                         this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
 
                 if (ret) {
-                        printk(KERN_ERR "onenand_read_oob: read failed = 0x%x\n", ret);
+                        printk(KERN_ERR "onenand_read_oob_nolock: read failed = 0x%x\n", ret);
                         break;
                 }
 
@@ -947,22 +1015,52 @@ static int onenand_do_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
                 }
         }
 
-        /* Deselect and wake up anyone waiting on the device */
+        ops->oobretlen = read;
+        return ret;
+}
+
+/**
+ * onenand_read - [MTD Interface] Read data from flash
+ * @param mtd           MTD device structure
+ * @param from          offset to read from
+ * @param len           number of bytes to read
+ * @param retlen        pointer to variable to store the number of read bytes
+ * @param buf           the databuffer to put data
+ *
+ * Read with ecc
+*/
+static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
+        size_t *retlen, u_char *buf)
+{
+        struct mtd_oob_ops ops = {
+                .len    = len,
+                .ooblen = 0,
+                .datbuf = buf,
+                .oobbuf = NULL,
+        };
+        int ret;
+
+        onenand_get_device(mtd, FL_READING);
+        ret = onenand_read_ops_nolock(mtd, from, &ops);
         onenand_release_device(mtd);
 
-        *retlen = read;
+        *retlen = ops.retlen;
         return ret;
 }
 
 /**
- * onenand_read_oob - [MTD Interface] NAND write data and/or out-of-band
+ * onenand_read_oob - [MTD Interface] Read main and/or out-of-band
  * @param mtd:          MTD device structure
  * @param from:         offset to read from
  * @param ops:          oob operation description structure
+
+ * Read main and/or out-of-band
  */
 static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
                             struct mtd_oob_ops *ops)
 {
+        int ret;
+
         switch (ops->mode) {
         case MTD_OOB_PLACE:
         case MTD_OOB_AUTO:
@@ -972,8 +1070,15 @@ static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
         default:
                 return -EINVAL;
         }
-        return onenand_do_read_oob(mtd, from + ops->ooboffs, ops->ooblen,
-                                   &ops->oobretlen, ops->oobbuf, ops->mode);
+
+        onenand_get_device(mtd, FL_READING);
+        if (ops->datbuf)
+                ret = onenand_read_ops_nolock(mtd, from, ops);
+        else
+                ret = onenand_read_oob_nolock(mtd, from, ops);
+        onenand_release_device(mtd);
+
+        return ret;
 }
 
 /**
@@ -1079,7 +1184,7 @@ int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
                 /* Read more? */
                 if (read < len) {
                         /* Update Page size */
-                        from += mtd->writesize;
+                        from += this->writesize;
                         column = 0;
                 }
         }
@@ -1097,7 +1202,6 @@ int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
  * @param mtd           MTD device structure
  * @param buf           the databuffer to verify
  * @param to            offset to read from
- *
  */
 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to)
 {
@@ -1125,7 +1229,6 @@ static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to
  * @param buf          the databuffer to verify
  * @param addr         offset to read from
  * @param len          number of bytes to read and compare
- *
  */
 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
 {
@@ -1135,12 +1238,12 @@ static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr,
         int thislen, column;
 
         while (len != 0) {
-                thislen = min_t(int, mtd->writesize, len);
-                column = addr & (mtd->writesize - 1);
-                if (column + thislen > mtd->writesize)
-                        thislen = mtd->writesize - column;
+                thislen = min_t(int, this->writesize, len);
+                column = addr & (this->writesize - 1);
+                if (column + thislen > this->writesize)
+                        thislen = this->writesize - column;
 
-                this->command(mtd, ONENAND_CMD_READ, addr, mtd->writesize);
+                this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
 
                 onenand_update_bufferram(mtd, addr, 0);
 
@@ -1171,50 +1274,101 @@ static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr,
 #define NOTALIGNED(x)   ((x & (this->subpagesize - 1)) != 0)
 
 /**
- * onenand_write - [MTD Interface] write buffer to FLASH
+ * onenand_fill_auto_oob - [Internal] oob auto-placement transfer
+ * @param mtd           MTD device structure
+ * @param oob_buf       oob buffer
+ * @param buf           source address
+ * @param column        oob offset to write to
+ * @param thislen       oob length to write
+ */
+static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
+                                  const u_char *buf, int column, int thislen)
+{
+        struct onenand_chip *this = mtd->priv;
+        struct nand_oobfree *free;
+        int writecol = column;
+        int writeend = column + thislen;
+        int lastgap = 0;
+        unsigned int i;
+
+        free = this->ecclayout->oobfree;
+        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
+                if (writecol >= lastgap)
+                        writecol += free->offset - lastgap;
+                if (writeend >= lastgap)
+                        writeend += free->offset - lastgap;
+                lastgap = free->offset + free->length;
+        }
+        free = this->ecclayout->oobfree;
+        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
+                int free_end = free->offset + free->length;
+                if (free->offset < writeend && free_end > writecol) {
+                        int st = max_t(int,free->offset,writecol);
+                        int ed = min_t(int,free_end,writeend);
+                        int n = ed - st;
+                        memcpy(oob_buf + st, buf, n);
+                        buf += n;
+                } else if (column == 0)
+                        break;
+        }
+        return 0;
+}
+
+/**
+ * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band
  * @param mtd           MTD device structure
  * @param to            offset to write to
- * @param len           number of bytes to write
- * @param retlen        pointer to variable to store the number of written bytes
- * @param buf           the data to write
+ * @param ops           oob operation description structure
  *
- * Write with ECC
+ * Write main and/or oob with ECC
  */
-static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
-        size_t *retlen, const u_char *buf)
+static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
+                                struct mtd_oob_ops *ops)
 {
         struct onenand_chip *this = mtd->priv;
-        int written = 0;
+        int written = 0, column, thislen, subpage;
+        int oobwritten = 0, oobcolumn, thisooblen, oobsize;
+        size_t len = ops->len;
+        size_t ooblen = ops->ooblen;
+        const u_char *buf = ops->datbuf;
+        const u_char *oob = ops->oobbuf;
+        u_char *oobbuf;
         int ret = 0;
-        int column, subpage;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write_ops_nolock: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
 
         /* Initialize retlen, in case of early exit */
-        *retlen = 0;
+        ops->retlen = 0;
+        ops->oobretlen = 0;
 
         /* Do not allow writes past end of device */
         if (unlikely((to + len) > mtd->size)) {
-                printk(KERN_ERR "onenand_write: Attempt write to past end of device\n");
+                printk(KERN_ERR "onenand_write_ops_nolock: Attempt write to past end of device\n");
                 return -EINVAL;
         }
 
         /* Reject writes, which are not page aligned */
         if (unlikely(NOTALIGNED(to)) || unlikely(NOTALIGNED(len))) {
-                printk(KERN_ERR "onenand_write: Attempt to write not page aligned data\n");
+                printk(KERN_ERR "onenand_write_ops_nolock: Attempt to write not page aligned data\n");
                 return -EINVAL;
         }
 
-        column = to & (mtd->writesize - 1);
+        if (ops->mode == MTD_OOB_AUTO)
+                oobsize = this->ecclayout->oobavail;
+        else
+                oobsize = mtd->oobsize;
 
-        /* Grab the lock and see if the device is available */
-        onenand_get_device(mtd, FL_WRITING);
+        oobcolumn = to & (mtd->oobsize - 1);
+
+        column = to & (mtd->writesize - 1);
 
         /* Loop until all data write */
         while (written < len) {
-                int thislen = min_t(int, mtd->writesize - column, len - written);
                 u_char *wbuf = (u_char *) buf;
 
+                thislen = min_t(int, mtd->writesize - column, len - written);
+                thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
+
                 cond_resched();
 
                 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
@@ -1228,7 +1382,25 @@ static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
                 }
 
                 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
-                this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
+
+                if (oob) {
+                        oobbuf = this->oob_buf;
+
+                        /* We send data to spare ram with oobsize
+                         * to prevent byte access */
+                        memset(oobbuf, 0xff, mtd->oobsize);
+                        if (ops->mode == MTD_OOB_AUTO)
+                                onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
+                        else
+                                memcpy(oobbuf + oobcolumn, oob, thisooblen);
+
+                        oobwritten += thisooblen;
+                        oob += thisooblen;
+                        oobcolumn = 0;
+                } else
+                        oobbuf = (u_char *) ffchars;
+
+                this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
 
                 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
 
@@ -1236,16 +1408,20 @@ static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
 
                 /* In partial page write we don't update bufferram */
                 onenand_update_bufferram(mtd, to, !ret && !subpage);
+                if (ONENAND_IS_2PLANE(this)) {
+                        ONENAND_SET_BUFFERRAM1(this);
+                        onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
+                }
 
                 if (ret) {
-                        printk(KERN_ERR "onenand_write: write filaed %d\n", ret);
+                        printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
                         break;
                 }
 
                 /* Only check verify write turn on */
                 ret = onenand_verify(mtd, (u_char *) wbuf, to, thislen);
                 if (ret) {
-                        printk(KERN_ERR "onenand_write: verify failed %d\n", ret);
+                        printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
                         break;
                 }
 
@@ -1262,54 +1438,14 @@ static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
         /* Deselect and wake up anyone waiting on the device */
         onenand_release_device(mtd);
 
-        *retlen = written;
+        ops->retlen = written;
 
         return ret;
 }
 
-/**
- * onenand_fill_auto_oob - [Internal] oob auto-placement transfer
- * @param mtd           MTD device structure
- * @param oob_buf       oob buffer
- * @param buf           source address
- * @param column        oob offset to write to
- * @param thislen       oob length to write
- */
-static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
-                                  const u_char *buf, int column, int thislen)
-{
-        struct onenand_chip *this = mtd->priv;
-        struct nand_oobfree *free;
-        int writecol = column;
-        int writeend = column + thislen;
-        int lastgap = 0;
-        unsigned int i;
-
-        free = this->ecclayout->oobfree;
-        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
-                if (writecol >= lastgap)
-                        writecol += free->offset - lastgap;
-                if (writeend >= lastgap)
-                        writeend += free->offset - lastgap;
-                lastgap = free->offset + free->length;
-        }
-        free = this->ecclayout->oobfree;
-        for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
-                int free_end = free->offset + free->length;
-                if (free->offset < writeend && free_end > writecol) {
-                        int st = max_t(int,free->offset,writecol);
-                        int ed = min_t(int,free_end,writeend);
-                        int n = ed - st;
-                        memcpy(oob_buf + st, buf, n);
-                        buf += n;
-                } else if (column == 0)
-                        break;
-        }
-        return 0;
-}
 
 /**
- * onenand_do_write_oob - [Internal] OneNAND write out-of-band
+ * onenand_write_oob_nolock - [Internal] OneNAND write out-of-band
  * @param mtd           MTD device structure
  * @param to            offset to write to
  * @param len           number of bytes to write
@@ -1319,18 +1455,23 @@ static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
  *
  * OneNAND write out-of-band
  */
-static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
-                                size_t *retlen, const u_char *buf, mtd_oob_mode_t mode)
+static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to,
+                                    struct mtd_oob_ops *ops)
 {
         struct onenand_chip *this = mtd->priv;
         int column, ret = 0, oobsize;
         int written = 0;
         u_char *oobbuf;
+        size_t len = ops->ooblen;
+        const u_char *buf = ops->oobbuf;
+        mtd_oob_mode_t mode = ops->mode;
 
-        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
+        to += ops->ooboffs;
+
+        DEBUG(MTD_DEBUG_LEVEL3, "onenand_write_oob_nolock: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
 
         /* Initialize retlen, in case of early exit */
-        *retlen = 0;
+        ops->oobretlen = 0;
 
         if (mode == MTD_OOB_AUTO)
                 oobsize = this->ecclayout->oobavail;
@@ -1340,13 +1481,13 @@ static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
         column = to & (mtd->oobsize - 1);
 
         if (unlikely(column >= oobsize)) {
-                printk(KERN_ERR "onenand_write_oob: Attempted to start write outside oob\n");
+                printk(KERN_ERR "onenand_write_oob_nolock: Attempted to start write outside oob\n");
                 return -EINVAL;
         }
 
         /* For compatibility with NAND: Do not allow write past end of page */
         if (unlikely(column + len > oobsize)) {
-                printk(KERN_ERR "onenand_write_oob: "
+                printk(KERN_ERR "onenand_write_oob_nolock: "
                       "Attempt to write past end of page\n");
                 return -EINVAL;
         }
@@ -1355,13 +1496,10 @@ static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
         if (unlikely(to >= mtd->size ||
                      column + len > ((mtd->size >> this->page_shift) -
                                      (to >> this->page_shift)) * oobsize)) {
-                printk(KERN_ERR "onenand_write_oob: Attempted to write past end of device\n");
+                printk(KERN_ERR "onenand_write_oob_nolock: Attempted to write past end of device\n");
                 return -EINVAL;
         }
 
-        /* Grab the lock and see if the device is available */
-        onenand_get_device(mtd, FL_WRITING);
-
         oobbuf = this->oob_buf;
 
         /* Loop until all data write */
@@ -1384,16 +1522,20 @@ static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
                 this->command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
 
                 onenand_update_bufferram(mtd, to, 0);
+                if (ONENAND_IS_2PLANE(this)) {
+                        ONENAND_SET_BUFFERRAM1(this);
+                        onenand_update_bufferram(mtd, to + this->writesize, 0);
+                }
 
                 ret = this->wait(mtd, FL_WRITING);
                 if (ret) {
-                        printk(KERN_ERR "onenand_write_oob: write failed %d\n", ret);
+                        printk(KERN_ERR "onenand_write_oob_nolock: write failed %d\n", ret);
                         break;
                 }
 
                 ret = onenand_verify_oob(mtd, oobbuf, to);
                 if (ret) {
-                        printk(KERN_ERR "onenand_write_oob: verify failed %d\n", ret);
+                        printk(KERN_ERR "onenand_write_oob_nolock: verify failed %d\n", ret);
                         break;
                 }
 
@@ -1406,11 +1548,37 @@ static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
                 column = 0;
         }
 
-        /* Deselect and wake up anyone waiting on the device */
-        onenand_release_device(mtd);
+        ops->oobretlen = written;
+
+        return ret;
+}
+
+/**
+ * onenand_write - [MTD Interface] write buffer to FLASH
+ * @param mtd           MTD device structure
+ * @param to            offset to write to
+ * @param len           number of bytes to write
+ * @param retlen        pointer to variable to store the number of written bytes
+ * @param buf           the data to write
+ *
+ * Write with ECC
+ */
+static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
+        size_t *retlen, const u_char *buf)
+{
+        struct mtd_oob_ops ops = {
+                .len    = len,
+                .ooblen = 0,
+                .datbuf = (u_char *) buf,
+                .oobbuf = NULL,
+        };
+        int ret;
 
-        *retlen = written;
+        onenand_get_device(mtd, FL_WRITING);
+        ret = onenand_write_ops_nolock(mtd, to, &ops);
+        onenand_release_device(mtd);
 
+        *retlen = ops.retlen;
         return ret;
 }
 
@@ -1423,6 +1591,8 @@ static int onenand_do_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
 static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
                              struct mtd_oob_ops *ops)
 {
+        int ret;
+
         switch (ops->mode) {
         case MTD_OOB_PLACE:
         case MTD_OOB_AUTO:
@@ -1432,21 +1602,27 @@ static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
         default:
                 return -EINVAL;
         }
-        return onenand_do_write_oob(mtd, to + ops->ooboffs, ops->ooblen,
-                                    &ops->oobretlen, ops->oobbuf, ops->mode);
+
+        onenand_get_device(mtd, FL_WRITING);
+        if (ops->datbuf)
+                ret = onenand_write_ops_nolock(mtd, to, ops);
+        else
+                ret = onenand_write_oob_nolock(mtd, to, ops);
+        onenand_release_device(mtd);
+
+        return ret;
 }
 
 /**
- * onenand_block_checkbad - [GENERIC] Check if a block is marked bad
+ * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad
  * @param mtd           MTD device structure
  * @param ofs           offset from device start
- * @param getchip       0, if the chip is already selected
  * @param allowbbt      1, if its allowed to access the bbt area
  *
  * Check, if the block is bad. Either by reading the bad block table or
  * calling of the scan function.
  */
-static int onenand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
+static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
 {
         struct onenand_chip *this = mtd->priv;
         struct bbm_info *bbm = this->bbm;
@@ -1507,7 +1683,7 @@ static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
                 cond_resched();
 
                 /* Check if we have a bad block, we do not erase bad blocks */
-                if (onenand_block_checkbad(mtd, addr, 0, 0)) {
+                if (onenand_block_isbad_nolock(mtd, addr, 0)) {
                         printk (KERN_WARNING "onenand_erase: attempt to erase a bad block at addr 0x%08x\n", (unsigned int) addr);
                         instr->state = MTD_ERASE_FAILED;
                         goto erase_exit;
@@ -1571,11 +1747,16 @@ static void onenand_sync(struct mtd_info *mtd)
  */
 static int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
 {
+        int ret;
+
         /* Check for invalid offset */
         if (ofs > mtd->size)
                 return -EINVAL;
 
-        return onenand_block_checkbad(mtd, ofs, 1, 0);
+        onenand_get_device(mtd, FL_READING);
+        ret = onenand_block_isbad_nolock(mtd, ofs, 0);
+        onenand_release_device(mtd);
+        return ret;
 }
 
 /**
@@ -1591,7 +1772,12 @@ static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
         struct onenand_chip *this = mtd->priv;
         struct bbm_info *bbm = this->bbm;
         u_char buf[2] = {0, 0};
-        size_t retlen;
+        struct mtd_oob_ops ops = {
+                .mode = MTD_OOB_PLACE,
+                .ooblen = 2,
+                .oobbuf = buf,
+                .ooboffs = 0,
+        };
         int block;
 
         /* Get block number */
@@ -1601,7 +1787,7 @@ static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
 
         /* We write two bytes, so we dont have to mess with 16 bit access */
         ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
-        return onenand_do_write_oob(mtd, ofs , 2, &retlen, buf, MTD_OOB_PLACE);
+        return onenand_write_oob_nolock(mtd, ofs, &ops);
 }
 
 /**
@@ -1624,7 +1810,10 @@ static int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
                 return ret;
         }
 
-        return this->block_markbad(mtd, ofs);
+        onenand_get_device(mtd, FL_WRITING);
+        ret = this->block_markbad(mtd, ofs);
+        onenand_release_device(mtd);
+        return ret;
 }
 
 /**
@@ -1823,13 +2012,19 @@ static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
                 size_t *retlen, u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
+        struct mtd_oob_ops ops = {
+                .len    = len,
+                .ooblen = 0,
+                .datbuf = buf,
+                .oobbuf = NULL,
+        };
         int ret;
 
         /* Enter OTP access mode */
         this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
         this->wait(mtd, FL_OTPING);
 
-        ret = mtd->read(mtd, from, len, retlen, buf);
+        ret = onenand_read_ops_nolock(mtd, from, &ops);
 
         /* Exit OTP access mode */
         this->command(mtd, ONENAND_CMD_RESET, 0, 0);
@@ -1841,19 +2036,20 @@ static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
 /**
  * do_otp_write - [DEFAULT] Write OTP block area
  * @param mtd           MTD device structure
- * @param from          The offset to write
+ * @param to            The offset to write
  * @param len           number of bytes to write
  * @param retlen        pointer to variable to store the number of write bytes
  * @param buf           the databuffer to put/get data
  *
  * Write OTP block area.
  */
-static int do_otp_write(struct mtd_info *mtd, loff_t from, size_t len,
+static int do_otp_write(struct mtd_info *mtd, loff_t to, size_t len,
                 size_t *retlen, u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
         unsigned char *pbuf = buf;
         int ret;
+        struct mtd_oob_ops ops;
 
         /* Force buffer page aligned */
         if (len < mtd->writesize) {
@@ -1867,7 +2063,12 @@ static int do_otp_write(struct mtd_info *mtd, loff_t from, size_t len,
         this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
         this->wait(mtd, FL_OTPING);
 
-        ret = mtd->write(mtd, from, len, retlen, pbuf);
+        ops.len = len;
+        ops.ooblen = 0;
+        ops.datbuf = pbuf;
+        ops.oobbuf = NULL;
+        ret = onenand_write_ops_nolock(mtd, to, &ops);
+        *retlen = ops.retlen;
 
         /* Exit OTP access mode */
         this->command(mtd, ONENAND_CMD_RESET, 0, 0);
@@ -1890,13 +2091,21 @@ static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
                 size_t *retlen, u_char *buf)
 {
         struct onenand_chip *this = mtd->priv;
+        struct mtd_oob_ops ops = {
+                .mode = MTD_OOB_PLACE,
+                .ooblen = len,
+                .oobbuf = buf,
+                .ooboffs = 0,
+        };
         int ret;
 
         /* Enter OTP access mode */
         this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
         this->wait(mtd, FL_OTPING);
 
-        ret = onenand_do_write_oob(mtd, from, len, retlen, buf, MTD_OOB_PLACE);
+        ret = onenand_write_oob_nolock(mtd, from, &ops);
+
+        *retlen = ops.oobretlen;
 
         /* Exit OTP access mode */
         this->command(mtd, ONENAND_CMD_RESET, 0, 0);
@@ -1943,13 +2152,16 @@ static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
         if (((mtd->writesize * otp_pages) - (from + len)) < 0)
                 return 0;
 
+        onenand_get_device(mtd, FL_OTPING);
         while (len > 0 && otp_pages > 0) {
                 if (!action) {  /* OTP Info functions */
                         struct otp_info *otpinfo;
 
                         len -= sizeof(struct otp_info);
-                        if (len <= 0)
-                                return -ENOSPC;
+                        if (len <= 0) {
+                                ret = -ENOSPC;
+                                break;
+                        }
 
                         otpinfo = (struct otp_info *) buf;
                         otpinfo->start = from;
@@ -1969,13 +2181,14 @@ static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
                         len -= size;
                         *retlen += size;
 
-                        if (ret < 0)
-                                return ret;
+                        if (ret)
+                                break;
                 }
                 otp_pages--;
         }
+        onenand_release_device(mtd);
 
-        return 0;
+        return ret;
 }
 
 /**
@@ -2107,6 +2320,7 @@ static int onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
  *
  * Check and set OneNAND features
  * - lock scheme
+ * - two plane
  */
 static void onenand_check_features(struct mtd_info *mtd)
 {
@@ -2118,19 +2332,35 @@ static void onenand_check_features(struct mtd_info *mtd)
         process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
 
         /* Lock scheme */
-        if (density >= ONENAND_DEVICE_DENSITY_1Gb) {
+        switch (density) {
+        case ONENAND_DEVICE_DENSITY_4Gb:
+                this->options |= ONENAND_HAS_2PLANE;
+
+        case ONENAND_DEVICE_DENSITY_2Gb:
+                /* 2Gb DDP don't have 2 plane */
+                if (!ONENAND_IS_DDP(this))
+                        this->options |= ONENAND_HAS_2PLANE;
+                this->options |= ONENAND_HAS_UNLOCK_ALL;
+
+        case ONENAND_DEVICE_DENSITY_1Gb:
                 /* A-Die has all block unlock */
-                if (process) {
-                        printk(KERN_DEBUG "Chip support all block unlock\n");
+                if (process)
                         this->options |= ONENAND_HAS_UNLOCK_ALL;
-                }
-        } else {
-                /* Some OneNAND has continues lock scheme */
-                if (!process) {
-                        printk(KERN_DEBUG "Lock scheme is Continues Lock\n");
+                break;
+
+        default:
+                /* Some OneNAND has continuous lock scheme */
+                if (!process)
                         this->options |= ONENAND_HAS_CONT_LOCK;
-                }
+                break;
         }
+
+        if (this->options & ONENAND_HAS_CONT_LOCK)
+                printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
+        if (this->options & ONENAND_HAS_UNLOCK_ALL)
+                printk(KERN_DEBUG "Chip support all block unlock\n");
+        if (this->options & ONENAND_HAS_2PLANE)
+                printk(KERN_DEBUG "Chip has 2 plane\n");
 }
 
 /**
@@ -2154,7 +2384,7 @@ static void onenand_print_device_info(int device, int version)
                 (16 << density),
                 vcc ? "2.65/3.3" : "1.8",
                 device);
-        printk(KERN_DEBUG "OneNAND version = 0x%04x\n", version);
+        printk(KERN_INFO "OneNAND version = 0x%04x\n", version);
 }
 
 static const struct onenand_manufacturers onenand_manuf_ids[] = {
@@ -2257,6 +2487,8 @@ static int onenand_probe(struct mtd_info *mtd)
         this->erase_shift = ffs(mtd->erasesize) - 1;
         this->page_shift = ffs(mtd->writesize) - 1;
         this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1;
+        /* It's real page size */
+        this->writesize = mtd->writesize;
 
         /* REVIST: Multichip handling */
 
@@ -2265,6 +2497,17 @@ static int onenand_probe(struct mtd_info *mtd)
         /* Check OneNAND features */
         onenand_check_features(mtd);
 
+        /*
+         * We emulate the 4KiB page and 256KiB erase block size
+         * But oobsize is still 64 bytes.
+         * It is only valid if you turn on 2X program support,
+         * Otherwise it will be ignored by compiler.
+         */
+        if (ONENAND_IS_2PLANE(this)) {
+                mtd->writesize <<= 1;
+                mtd->erasesize <<= 1;
+        }
+
         return 0;
 }
 
diff --git a/drivers/mtd/onenand/onenand_sim.c b/drivers/mtd/onenand/onenand_sim.c
new file mode 100644
index 0000000000..0d89ad5776
--- /dev/null
+++ b/drivers/mtd/onenand/onenand_sim.c
@@ -0,0 +1,495 @@
+/*
+ *  linux/drivers/mtd/onenand/onenand_sim.c
+ *
+ *  The OneNAND simulator
+ *
+ *  Copyright © 2005-2007 Samsung Electronics
+ *  Kyungmin Park <kyungmin.park@samsung.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
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/vmalloc.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/onenand.h>
+
+#include <linux/io.h>
+
+#ifndef CONFIG_ONENAND_SIM_MANUFACTURER
+#define CONFIG_ONENAND_SIM_MANUFACTURER         0xec
+#endif
+#ifndef CONFIG_ONENAND_SIM_DEVICE_ID
+#define CONFIG_ONENAND_SIM_DEVICE_ID            0x04
+#endif
+#ifndef CONFIG_ONENAND_SIM_VERSION_ID
+#define CONFIG_ONENAND_SIM_VERSION_ID           0x1e
+#endif
+
+static int manuf_id     = CONFIG_ONENAND_SIM_MANUFACTURER;
+static int device_id    = CONFIG_ONENAND_SIM_DEVICE_ID;
+static int version_id   = CONFIG_ONENAND_SIM_VERSION_ID;
+
+struct onenand_flash {
+        void __iomem *base;
+        void __iomem *data;
+};
+
+#define ONENAND_CORE(flash)             (flash->data)
+#define ONENAND_CORE_SPARE(flash, this, offset)                         \
+        ((flash->data) + (this->chipsize) + (offset >> 5))
+
+#define ONENAND_MAIN_AREA(this, offset)                                 \
+        (this->base + ONENAND_DATARAM + offset)
+
+#define ONENAND_SPARE_AREA(this, offset)                                \
+        (this->base + ONENAND_SPARERAM + offset)
+
+#define ONENAND_GET_WP_STATUS(this)                                     \
+        (readw(this->base + ONENAND_REG_WP_STATUS))
+
+#define ONENAND_SET_WP_STATUS(v, this)                                  \
+        (writew(v, this->base + ONENAND_REG_WP_STATUS))
+
+/* It has all 0xff chars */
+#define MAX_ONENAND_PAGESIZE            (2048 + 64)
+static unsigned char *ffchars;
+
+static struct mtd_partition os_partitions[] = {
+        {
+                .name           = "OneNAND simulator partition",
+                .offset         = 0,
+                .size           = MTDPART_SIZ_FULL,
+        },
+};
+
+/*
+ * OneNAND simulator mtd
+ */
+struct onenand_info {
+        struct mtd_info         mtd;
+        struct mtd_partition    *parts;
+        struct onenand_chip     onenand;
+        struct onenand_flash    flash;
+};
+
+static struct onenand_info *info;
+
+#define DPRINTK(format, args...)                                        \
+do {                                                                    \
+        printk(KERN_DEBUG "%s[%d]: " format "\n", __func__,             \
+                           __LINE__, ##args);                           \
+} while (0)
+
+/**
+ * onenand_lock_handle - Handle Lock scheme
+ * @param this          OneNAND device structure
+ * @param cmd           The command to be sent
+ *
+ * Send lock command to OneNAND device.
+ * The lock scheme is depends on chip type.
+ */
+static void onenand_lock_handle(struct onenand_chip *this, int cmd)
+{
+        int block_lock_scheme;
+        int status;
+
+        status = ONENAND_GET_WP_STATUS(this);
+        block_lock_scheme = !(this->options & ONENAND_HAS_CONT_LOCK);
+
+        switch (cmd) {
+        case ONENAND_CMD_UNLOCK:
+                if (block_lock_scheme)
+                        ONENAND_SET_WP_STATUS(ONENAND_WP_US, this);
+                else
+                        ONENAND_SET_WP_STATUS(status | ONENAND_WP_US, this);
+                break;
+
+        case ONENAND_CMD_LOCK:
+                if (block_lock_scheme)
+                        ONENAND_SET_WP_STATUS(ONENAND_WP_LS, this);
+                else
+                        ONENAND_SET_WP_STATUS(status | ONENAND_WP_LS, this);
+                break;
+
+        case ONENAND_CMD_LOCK_TIGHT:
+                if (block_lock_scheme)
+                        ONENAND_SET_WP_STATUS(ONENAND_WP_LTS, this);
+                else
+                        ONENAND_SET_WP_STATUS(status | ONENAND_WP_LTS, this);
+                break;
+
+        default:
+                break;
+        }
+}
+
+/**
+ * onenand_bootram_handle - Handle BootRAM area
+ * @param this          OneNAND device structure
+ * @param cmd           The command to be sent
+ *
+ * Emulate BootRAM area. It is possible to do basic operation using BootRAM.
+ */
+static void onenand_bootram_handle(struct onenand_chip *this, int cmd)
+{
+        switch (cmd) {
+        case ONENAND_CMD_READID:
+                writew(manuf_id, this->base);
+                writew(device_id, this->base + 2);
+                writew(version_id, this->base + 4);
+                break;
+
+        default:
+                /* REVIST: Handle other commands */
+                break;
+        }
+}
+
+/**
+ * onenand_update_interrupt - Set interrupt register
+ * @param this         OneNAND device structure
+ * @param cmd          The command to be sent
+ *
+ * Update interrupt register. The status is depends on command.
+ */
+static void onenand_update_interrupt(struct onenand_chip *this, int cmd)
+{
+        int interrupt = ONENAND_INT_MASTER;
+
+        switch (cmd) {
+        case ONENAND_CMD_READ:
+        case ONENAND_CMD_READOOB:
+                interrupt |= ONENAND_INT_READ;
+                break;
+
+        case ONENAND_CMD_PROG:
+        case ONENAND_CMD_PROGOOB:
+                interrupt |= ONENAND_INT_WRITE;
+                break;
+
+        case ONENAND_CMD_ERASE:
+                interrupt |= ONENAND_INT_ERASE;
+                break;
+
+        case ONENAND_CMD_RESET:
+                interrupt |= ONENAND_INT_RESET;
+                break;
+
+        default:
+                break;
+        }
+
+        writew(interrupt, this->base + ONENAND_REG_INTERRUPT);
+}
+
+/**
+ * onenand_check_overwrite - Check over-write if happend
+ * @param dest          The destination pointer
+ * @param src           The source pointer
+ * @param count         The length to be check
+ * @return              0 on same, otherwise 1
+ *
+ * Compare the source with destination
+ */
+static int onenand_check_overwrite(void *dest, void *src, size_t count)
+{
+        unsigned int *s = (unsigned int *) src;
+        unsigned int *d = (unsigned int *) dest;
+        int i;
+
+        count >>= 2;
+        for (i = 0; i < count; i++)
+                if ((*s++ ^ *d++) != 0)
+                        return 1;
+
+        return 0;
+}
+
+/**
+ * onenand_data_handle - Handle OneNAND Core and DataRAM
+ * @param this          OneNAND device structure
+ * @param cmd           The command to be sent
+ * @param dataram       Which dataram used
+ * @param offset        The offset to OneNAND Core
+ *
+ * Copy data from OneNAND Core to DataRAM (read)
+ * Copy data from DataRAM to OneNAND Core (write)
+ * Erase the OneNAND Core (erase)
+ */
+static void onenand_data_handle(struct onenand_chip *this, int cmd,
+                                int dataram, unsigned int offset)
+{
+        struct mtd_info *mtd = &info->mtd;
+        struct onenand_flash *flash = this->priv;
+        int main_offset, spare_offset;
+        void __iomem *src;
+        void __iomem *dest;
+        unsigned int i;
+
+        if (dataram) {
+                main_offset = mtd->writesize;
+                spare_offset = mtd->oobsize;
+        } else {
+                main_offset = 0;
+                spare_offset = 0;
+        }
+
+        switch (cmd) {
+        case ONENAND_CMD_READ:
+                src = ONENAND_CORE(flash) + offset;
+                dest = ONENAND_MAIN_AREA(this, main_offset);
+                memcpy(dest, src, mtd->writesize);
+                /* Fall through */
+
+        case ONENAND_CMD_READOOB:
+                src = ONENAND_CORE_SPARE(flash, this, offset);
+                dest = ONENAND_SPARE_AREA(this, spare_offset);
+                memcpy(dest, src, mtd->oobsize);
+                break;
+
+        case ONENAND_CMD_PROG:
+                src = ONENAND_MAIN_AREA(this, main_offset);
+                dest = ONENAND_CORE(flash) + offset;
+                /* To handle partial write */
+                for (i = 0; i < (1 << mtd->subpage_sft); i++) {
+                        int off = i * this->subpagesize;
+                        if (!memcmp(src + off, ffchars, this->subpagesize))
+                                continue;
+                        if (memcmp(dest + off, ffchars, this->subpagesize) &&
+                            onenand_check_overwrite(dest + off, src + off, this->subpagesize))
+                                printk(KERN_ERR "over-write happend at 0x%08x\n", offset);
+                        memcpy(dest + off, src + off, this->subpagesize);
+                }
+                /* Fall through */
+
+        case ONENAND_CMD_PROGOOB:
+                src = ONENAND_SPARE_AREA(this, spare_offset);
+                /* Check all data is 0xff chars */
+                if (!memcmp(src, ffchars, mtd->oobsize))
+                        break;
+
+                dest = ONENAND_CORE_SPARE(flash, this, offset);
+                if (memcmp(dest, ffchars, mtd->oobsize) &&
+                    onenand_check_overwrite(dest, src, mtd->oobsize))
+                        printk(KERN_ERR "OOB: over-write happend at 0x%08x\n",
+                               offset);
+                memcpy(dest, src, mtd->oobsize);
+                break;
+
+        case ONENAND_CMD_ERASE:
+                memset(ONENAND_CORE(flash) + offset, 0xff, mtd->erasesize);
+                memset(ONENAND_CORE_SPARE(flash, this, offset), 0xff,
+                       (mtd->erasesize >> 5));
+                break;
+
+        default:
+                break;
+        }
+}
+
+/**
+ * onenand_command_handle - Handle command
+ * @param this          OneNAND device structure
+ * @param cmd           The command to be sent
+ *
+ * Emulate OneNAND command.
+ */
+static void onenand_command_handle(struct onenand_chip *this, int cmd)
+{
+        unsigned long offset = 0;
+        int block = -1, page = -1, bufferram = -1;
+        int dataram = 0;
+
+        switch (cmd) {
+        case ONENAND_CMD_UNLOCK:
+        case ONENAND_CMD_LOCK:
+        case ONENAND_CMD_LOCK_TIGHT:
+        case ONENAND_CMD_UNLOCK_ALL:
+                onenand_lock_handle(this, cmd);
+                break;
+
+        case ONENAND_CMD_BUFFERRAM:
+                /* Do nothing */
+                return;
+
+        default:
+                block = (int) readw(this->base + ONENAND_REG_START_ADDRESS1);
+                if (block & (1 << ONENAND_DDP_SHIFT)) {
+                        block &= ~(1 << ONENAND_DDP_SHIFT);
+                        /* The half of chip block */
+                        block += this->chipsize >> (this->erase_shift + 1);
+                }
+                if (cmd == ONENAND_CMD_ERASE)
+                        break;
+
+                page = (int) readw(this->base + ONENAND_REG_START_ADDRESS8);
+                page = (page >> ONENAND_FPA_SHIFT);
+                bufferram = (int) readw(this->base + ONENAND_REG_START_BUFFER);
+                bufferram >>= ONENAND_BSA_SHIFT;
+                bufferram &= ONENAND_BSA_DATARAM1;
+                dataram = (bufferram == ONENAND_BSA_DATARAM1) ? 1 : 0;
+                break;
+        }
+
+        if (block != -1)
+                offset += block << this->erase_shift;
+
+        if (page != -1)
+                offset += page << this->page_shift;
+
+        onenand_data_handle(this, cmd, dataram, offset);
+
+        onenand_update_interrupt(this, cmd);
+}
+
+/**
+ * onenand_writew - [OneNAND Interface] Emulate write operation
+ * @param value         value to write
+ * @param addr          address to write
+ *
+ * Write OneNAND register with value
+ */
+static void onenand_writew(unsigned short value, void __iomem * addr)
+{
+        struct onenand_chip *this = info->mtd.priv;
+
+        /* BootRAM handling */
+        if (addr < this->base + ONENAND_DATARAM) {
+                onenand_bootram_handle(this, value);
+                return;
+        }
+        /* Command handling */
+        if (addr == this->base + ONENAND_REG_COMMAND)
+                onenand_command_handle(this, value);
+
+        writew(value, addr);
+}
+
+/**
+ * flash_init - Initialize OneNAND simulator
+ * @param flash         OneNAND simulaotr data strucutres
+ *
+ * Initialize OneNAND simulator.
+ */
+static int __init flash_init(struct onenand_flash *flash)
+{
+        int density, size;
+        int buffer_size;
+
+        flash->base = kzalloc(131072, GFP_KERNEL);
+        if (!flash->base) {
+                printk(KERN_ERR "Unable to allocate base address.\n");
+                return -ENOMEM;
+        }
+
+        density = device_id >> ONENAND_DEVICE_DENSITY_SHIFT;
+        size = ((16 << 20) << density);
+
+        ONENAND_CORE(flash) = vmalloc(size + (size >> 5));
+        if (!ONENAND_CORE(flash)) {
+                printk(KERN_ERR "Unable to allocate nand core address.\n");
+                kfree(flash->base);
+                return -ENOMEM;
+        }
+
+        memset(ONENAND_CORE(flash), 0xff, size + (size >> 5));
+
+        /* Setup registers */
+        writew(manuf_id, flash->base + ONENAND_REG_MANUFACTURER_ID);
+        writew(device_id, flash->base + ONENAND_REG_DEVICE_ID);
+        writew(version_id, flash->base + ONENAND_REG_VERSION_ID);
+
+        if (density < 2)
+                buffer_size = 0x0400;   /* 1KiB page */
+        else
+                buffer_size = 0x0800;   /* 2KiB page */
+        writew(buffer_size, flash->base + ONENAND_REG_DATA_BUFFER_SIZE);
+
+        return 0;
+}
+
+/**
+ * flash_exit - Clean up OneNAND simulator
+ * @param flash         OneNAND simulaotr data strucutres
+ *
+ * Clean up OneNAND simulator.
+ */
+static void flash_exit(struct onenand_flash *flash)
+{
+        vfree(ONENAND_CORE(flash));
+        kfree(flash->base);
+        kfree(flash);
+}
+
+static int __init onenand_sim_init(void)
+{
+        /* Allocate all 0xff chars pointer */
+        ffchars = kmalloc(MAX_ONENAND_PAGESIZE, GFP_KERNEL);
+        if (!ffchars) {
+                printk(KERN_ERR "Unable to allocate ff chars.\n");
+                return -ENOMEM;
+        }
+        memset(ffchars, 0xff, MAX_ONENAND_PAGESIZE);
+
+        /* Allocate OneNAND simulator mtd pointer */
+        info = kzalloc(sizeof(struct onenand_info), GFP_KERNEL);
+        if (!info) {
+                printk(KERN_ERR "Unable to allocate core structures.\n");
+                kfree(ffchars);
+                return -ENOMEM;
+        }
+
+        /* Override write_word function */
+        info->onenand.write_word = onenand_writew;
+
+        if (flash_init(&info->flash)) {
+                printk(KERN_ERR "Unable to allocat flash.\n");
+                kfree(ffchars);
+                kfree(info);
+                return -ENOMEM;
+        }
+
+        info->parts = os_partitions;
+
+        info->onenand.base = info->flash.base;
+        info->onenand.priv = &info->flash;
+
+        info->mtd.name = "OneNAND simulator";
+        info->mtd.priv = &info->onenand;
+        info->mtd.owner = THIS_MODULE;
+
+        if (onenand_scan(&info->mtd, 1)) {
+                flash_exit(&info->flash);
+                kfree(ffchars);
+                kfree(info);
+                return -ENXIO;
+        }
+
+        add_mtd_partitions(&info->mtd, info->parts, ARRAY_SIZE(os_partitions));
+
+        return 0;
+}
+
+static void __exit onenand_sim_exit(void)
+{
+        struct onenand_chip *this = info->mtd.priv;
+        struct onenand_flash *flash = this->priv;
+
+        onenand_release(&info->mtd);
+        flash_exit(flash);
+        kfree(ffchars);
+        kfree(info);
+}
+
+module_init(onenand_sim_init);
+module_exit(onenand_sim_exit);
+
+MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
+MODULE_DESCRIPTION("The OneNAND flash simulator");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/rfd_ftl.c b/drivers/mtd/rfd_ftl.c
index 006c03aacb..823fba4e6d 100644
--- a/drivers/mtd/rfd_ftl.c
+++ b/drivers/mtd/rfd_ftl.c
@@ -779,10 +779,8 @@ static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         else {
                 if (!mtd->erasesize) {
                         printk(KERN_WARNING PREFIX "please provide block_size");
-                        kfree(part);
-                        return;
-                }
-                else
+                        goto out;
+                } else
                         part->block_size = mtd->erasesize;
         }
 
@@ -804,7 +802,7 @@ static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
                 if (!add_mtd_blktrans_dev((void*)part))
                         return;
         }
-
+out:
         kfree(part);
 }
 
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index 94ee549344..29c41eeb09 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -1314,11 +1314,10 @@ static int paranoid_check_si(const struct ubi_device *ubi,
          * Make sure that all the physical eraseblocks are in one of the lists
          * or trees.
          */
-        buf = kmalloc(ubi->peb_count, GFP_KERNEL);
+        buf = kzalloc(ubi->peb_count, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
 
-        memset(buf, 1, ubi->peb_count);
         for (pnum = 0; pnum < ubi->peb_count; pnum++) {
                 err = ubi_io_is_bad(ubi, pnum);
                 if (err < 0) {
@@ -1326,28 +1325,28 @@ static int paranoid_check_si(const struct ubi_device *ubi,
                         return err;
                 }
                 else if (err)
-                        buf[pnum] = 0;
+                        buf[pnum] = 1;
         }
 
         ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb)
                 ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb)
-                        buf[seb->pnum] = 0;
+                        buf[seb->pnum] = 1;
 
         list_for_each_entry(seb, &si->free, u.list)
-                buf[seb->pnum] = 0;
+                buf[seb->pnum] = 1;
 
         list_for_each_entry(seb, &si->corr, u.list)
-                buf[seb->pnum] = 0;
+                buf[seb->pnum] = 1;
 
         list_for_each_entry(seb, &si->erase, u.list)
-                buf[seb->pnum] = 0;
+                buf[seb->pnum] = 1;
 
         list_for_each_entry(seb, &si->alien, u.list)
-                buf[seb->pnum] = 0;
+                buf[seb->pnum] = 1;
 
         err = 0;
         for (pnum = 0; pnum < ubi->peb_count; pnum++)
-                if (buf[pnum]) {
+                if (!buf[pnum]) {
                         ubi_err("PEB %d is not referred", pnum);
                         err = 1;
                 }
diff --git a/drivers/net/atarilance.c b/drivers/net/atarilance.c
index ebf1a3a88e..b74dbeef80 100644
--- a/drivers/net/atarilance.c
+++ b/drivers/net/atarilance.c
@@ -1023,7 +1023,7 @@ static int lance_rx( struct net_device *dev )
                                         DECLARE_MAC_BUF(mac);
                                         DECLARE_MAC_BUF(mac2);
 
-                                        printk(KERN_DEBUG "%s: RX pkt type 0x%04x from %s to %s ",
+                                        printk(KERN_DEBUG "%s: RX pkt type 0x%04x from %s to %s "
                                                    "data %02x %02x %02x %02x %02x %02x %02x %02x "
                                                    "len %d\n",
                                                    dev->name, ((u_short *)data)[6],
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index d68accea38..78ed633ceb 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -2652,10 +2652,10 @@ static int bnx2_poll_work(struct bnx2 *bp, int work_done, int budget)
                 REG_RD(bp, BNX2_HC_COMMAND);
         }
 
-        if (bp->status_blk->status_tx_quick_consumer_index0 != bp->hw_tx_cons)
+        if (sblk->status_tx_quick_consumer_index0 != bp->hw_tx_cons)
                 bnx2_tx_int(bp);
 
-        if (bp->status_blk->status_rx_quick_consumer_index0 != bp->hw_rx_cons)
+        if (sblk->status_rx_quick_consumer_index0 != bp->hw_rx_cons)
                 work_done += bnx2_rx_int(bp, budget - work_done);
 
         return work_done;
@@ -2665,6 +2665,7 @@ static int bnx2_poll(struct napi_struct *napi, int budget)
 {
         struct bnx2 *bp = container_of(napi, struct bnx2, napi);
         int work_done = 0;
+        struct status_block *sblk = bp->status_blk;
 
         while (1) {
                 work_done = bnx2_poll_work(bp, work_done, budget);
@@ -2672,16 +2673,19 @@ static int bnx2_poll(struct napi_struct *napi, int budget)
                 if (unlikely(work_done >= budget))
                         break;
 
+                /* bp->last_status_idx is used below to tell the hw how
+                 * much work has been processed, so we must read it before
+                 * checking for more work.
+                 */
+                bp->last_status_idx = sblk->status_idx;
+                rmb();
                 if (likely(!bnx2_has_work(bp))) {
-                        bp->last_status_idx = bp->status_blk->status_idx;
-                        rmb();
-
                         netif_rx_complete(bp->dev, napi);
                         if (likely(bp->flags & USING_MSI_FLAG)) {
                                 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
                                        BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
                                        bp->last_status_idx);
-                                return 0;
+                                break;
                         }
                         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
                                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index 4ac161e1ca..7d7758f3ad 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -1183,7 +1183,7 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
                                          pool_count[i], pool_size[i],
                                          pool_active[i]);
                 kobj->parent = &dev->dev.kobj;
-                sprintf(kobj->name, "pool%d", i);
+                kobject_set_name(kobj, "pool%d", i);
                 kobj->ktype = &ktype_veth_pool;
                 kobject_register(kobj);
         }
diff --git a/drivers/net/macmace.c b/drivers/net/macmace.c
index 6589239b79..18770527df 100644
--- a/drivers/net/macmace.c
+++ b/drivers/net/macmace.c
@@ -538,8 +538,9 @@ static void mace_set_multicast(struct net_device *dev)
         local_irq_restore(flags);
 }
 
-static void mace_handle_misc_intrs(struct mace_data *mp, int intr)
+static void mace_handle_misc_intrs(struct net_device *dev, int intr)
 {
+        struct mace_data *mp = netdev_priv(dev);
         volatile struct mace *mb = mp->mace;
         static int mace_babbles, mace_jabbers;
 
@@ -571,7 +572,7 @@ static irqreturn_t mace_interrupt(int irq, void *dev_id)
         local_irq_save(flags);
 
         intr = mb->ir; /* read interrupt register */
-        mace_handle_misc_intrs(mp, intr);
+        mace_handle_misc_intrs(dev, intr);
 
         if (intr & XMTINT) {
                 fs = mb->xmtfs;
@@ -645,7 +646,6 @@ static void mace_tx_timeout(struct net_device *dev)
 
 static void mace_dma_rx_frame(struct net_device *dev, struct mace_frame *mf)
 {
-        struct mace_data *mp = netdev_priv(dev);
         struct sk_buff *skb;
         unsigned int frame_status = mf->rcvsts;
 
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index b33d21f4ef..84f2d6382f 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -784,7 +784,6 @@ static int mv643xx_eth_open(struct net_device *dev)
         unsigned int port_num = mp->port_num;
         unsigned int size;
         int err;
-        DECLARE_MAC_BUF(mac);
 
         /* Clear any pending ethernet port interrupts */
         mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
@@ -1296,6 +1295,7 @@ static int mv643xx_eth_probe(struct platform_device *pdev)
         struct ethtool_cmd cmd;
         int duplex = DUPLEX_HALF;
         int speed = 0;                  /* default to auto-negotiation */
+        DECLARE_MAC_BUF(mac);
 
         pd = pdev->dev.platform_data;
         if (pd == NULL) {
diff --git a/drivers/net/mvme147.c b/drivers/net/mvme147.c
index 86c9c06433..06ca425215 100644
--- a/drivers/net/mvme147.c
+++ b/drivers/net/mvme147.c
@@ -85,7 +85,6 @@ struct net_device * __init mvme147lance_probe(int unit)
         dev->open = &m147lance_open;
         dev->stop = &m147lance_close;
         dev->hard_start_xmit = &lance_start_xmit;
-        dev->get_stats = &lance_get_stats;
         dev->set_multicast_list = &lance_set_multicast;
         dev->tx_timeout = &lance_tx_timeout;
         dev->dma = 0;
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 0a32034654..68f728f0b6 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -52,7 +52,7 @@
 #include "sky2.h"
 
 #define DRV_NAME                "sky2"
-#define DRV_VERSION             "1.18"
+#define DRV_VERSION             "1.19"
 #define PFX                     DRV_NAME " "
 
 /*
@@ -296,10 +296,10 @@ static const u16 copper_fc_adv[] = {
 
 /* flow control to advertise bits when using 1000BaseX */
 static const u16 fiber_fc_adv[] = {
-        [FC_BOTH] = PHY_M_P_BOTH_MD_X,
+        [FC_NONE] = PHY_M_P_NO_PAUSE_X,
         [FC_TX]   = PHY_M_P_ASYM_MD_X,
         [FC_RX]   = PHY_M_P_SYM_MD_X,
-        [FC_NONE] = PHY_M_P_NO_PAUSE_X,
+        [FC_BOTH] = PHY_M_P_BOTH_MD_X,
 };
 
 /* flow control to GMA disable bits */
@@ -606,20 +606,19 @@ static void sky2_phy_power(struct sky2_hw *hw, unsigned port, int onoff)
 {
         struct pci_dev *pdev = hw->pdev;
         u32 reg1;
-        static const u32 phy_power[]
-                = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
-
-        /* looks like this XL is back asswards .. */
-        if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
-                onoff = !onoff;
+        static const u32 phy_power[] = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
+        static const u32 coma_mode[] = { PCI_Y2_PHY1_COMA, PCI_Y2_PHY2_COMA };
 
         pci_read_config_dword(pdev, PCI_DEV_REG1, &reg1);
+        /* Turn on/off phy power saving */
         if (onoff)
-                /* Turn off phy power saving */
                 reg1 &= ~phy_power[port];
         else
                 reg1 |= phy_power[port];
 
+        if (onoff && hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
+                reg1 |= coma_mode[port];
+
         pci_write_config_dword(pdev, PCI_DEV_REG1, reg1);
         pci_read_config_dword(pdev, PCI_DEV_REG1, &reg1);
 
@@ -1636,8 +1635,8 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
                                 printk(KERN_DEBUG "%s: tx done %u\n",
                                        dev->name, idx);
 
-                        sky2->net_stats.tx_packets++;
-                        sky2->net_stats.tx_bytes += re->skb->len;
+                        dev->stats.tx_packets++;
+                        dev->stats.tx_bytes += re->skb->len;
 
                         dev_kfree_skb_any(re->skb);
                         sky2->tx_next = RING_NEXT(idx, TX_RING_SIZE);
@@ -2205,16 +2204,16 @@ resubmit:
 len_error:
         /* Truncation of overlength packets
            causes PHY length to not match MAC length */
-        ++sky2->net_stats.rx_length_errors;
+        ++dev->stats.rx_length_errors;
         if (netif_msg_rx_err(sky2) && net_ratelimit())
                 pr_info(PFX "%s: rx length error: status %#x length %d\n",
                         dev->name, status, length);
         goto resubmit;
 
 error:
-        ++sky2->net_stats.rx_errors;
+        ++dev->stats.rx_errors;
         if (status & GMR_FS_RX_FF_OV) {
-                sky2->net_stats.rx_over_errors++;
+                dev->stats.rx_over_errors++;
                 goto resubmit;
         }
 
@@ -2223,11 +2222,11 @@ error:
                        dev->name, status, length);
 
         if (status & (GMR_FS_LONG_ERR | GMR_FS_UN_SIZE))
-                sky2->net_stats.rx_length_errors++;
+                dev->stats.rx_length_errors++;
         if (status & GMR_FS_FRAGMENT)
-                sky2->net_stats.rx_frame_errors++;
+                dev->stats.rx_frame_errors++;
         if (status & GMR_FS_CRC_ERR)
-                sky2->net_stats.rx_crc_errors++;
+                dev->stats.rx_crc_errors++;
 
         goto resubmit;
 }
@@ -2272,7 +2271,7 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
                         ++rx[port];
                         skb = sky2_receive(dev, length, status);
                         if (unlikely(!skb)) {
-                                sky2->net_stats.rx_dropped++;
+                                dev->stats.rx_dropped++;
                                 break;
                         }
 
@@ -2287,8 +2286,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
                         }
 
                         skb->protocol = eth_type_trans(skb, dev);
-                        sky2->net_stats.rx_packets++;
-                        sky2->net_stats.rx_bytes += skb->len;
+                        dev->stats.rx_packets++;
+                        dev->stats.rx_bytes += skb->len;
                         dev->last_rx = jiffies;
 
 #ifdef SKY2_VLAN_TAG_USED
@@ -2479,12 +2478,12 @@ static void sky2_mac_intr(struct sky2_hw *hw, unsigned port)
                 gma_read16(hw, port, GM_TX_IRQ_SRC);
 
         if (status & GM_IS_RX_FF_OR) {
-                ++sky2->net_stats.rx_fifo_errors;
+                ++dev->stats.rx_fifo_errors;
                 sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_CLI_RX_FO);
         }
 
         if (status & GM_IS_TX_FF_UR) {
-                ++sky2->net_stats.tx_fifo_errors;
+                ++dev->stats.tx_fifo_errors;
                 sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_FU);
         }
 }
@@ -3223,12 +3222,6 @@ static void sky2_get_strings(struct net_device *dev, u32 stringset, u8 * data)
         }
 }
 
-static struct net_device_stats *sky2_get_stats(struct net_device *dev)
-{
-        struct sky2_port *sky2 = netdev_priv(dev);
-        return &sky2->net_stats;
-}
-
 static int sky2_set_mac_address(struct net_device *dev, void *p)
 {
         struct sky2_port *sky2 = netdev_priv(dev);
@@ -3569,20 +3562,64 @@ static void sky2_get_regs(struct net_device *dev, struct ethtool_regs *regs,
 {
         const struct sky2_port *sky2 = netdev_priv(dev);
         const void __iomem *io = sky2->hw->regs;
+        unsigned int b;
 
         regs->version = 1;
-        memset(p, 0, regs->len);
-
-        memcpy_fromio(p, io, B3_RAM_ADDR);
 
-        /* skip diagnostic ram region */
-        memcpy_fromio(p + B3_RI_WTO_R1, io + B3_RI_WTO_R1, 0x2000 - B3_RI_WTO_R1);
+        for (b = 0; b < 128; b++) {
+                /* This complicated switch statement is to make sure and
+                 * only access regions that are unreserved.
+                 * Some blocks are only valid on dual port cards.
+                 * and block 3 has some special diagnostic registers that
+                 * are poison.
+                 */
+                switch (b) {
+                case 3:
+                        /* skip diagnostic ram region */
+                        memcpy_fromio(p + 0x10, io + 0x10, 128 - 0x10);
+                        break;
 
-        /* copy GMAC registers */
-        memcpy_fromio(p + BASE_GMAC_1, io + BASE_GMAC_1, 0x1000);
-        if (sky2->hw->ports > 1)
-                memcpy_fromio(p + BASE_GMAC_2, io + BASE_GMAC_2, 0x1000);
+                /* dual port cards only */
+                case 5:         /* Tx Arbiter 2 */
+                case 9:         /* RX2 */
+                case 14 ... 15: /* TX2 */
+                case 17: case 19: /* Ram Buffer 2 */
+                case 22 ... 23: /* Tx Ram Buffer 2 */
+                case 25:        /* Rx MAC Fifo 1 */
+                case 27:        /* Tx MAC Fifo 2 */
+                case 31:        /* GPHY 2 */
+                case 40 ... 47: /* Pattern Ram 2 */
+                case 52: case 54: /* TCP Segmentation 2 */
+                case 112 ... 116: /* GMAC 2 */
+                        if (sky2->hw->ports == 1)
+                                goto reserved;
+                        /* fall through */
+                case 0:         /* Control */
+                case 2:         /* Mac address */
+                case 4:         /* Tx Arbiter 1 */
+                case 7:         /* PCI express reg */
+                case 8:         /* RX1 */
+                case 12 ... 13: /* TX1 */
+                case 16: case 18:/* Rx Ram Buffer 1 */
+                case 20 ... 21: /* Tx Ram Buffer 1 */
+                case 24:        /* Rx MAC Fifo 1 */
+                case 26:        /* Tx MAC Fifo 1 */
+                case 28 ... 29: /* Descriptor and status unit */
+                case 30:        /* GPHY 1*/
+                case 32 ... 39: /* Pattern Ram 1 */
+                case 48: case 50: /* TCP Segmentation 1 */
+                case 56 ... 60: /* PCI space */
+                case 80 ... 84: /* GMAC 1 */
+                        memcpy_fromio(p, io, 128);
+                        break;
+                default:
+reserved:
+                        memset(p, 0, 128);
+                }
 
+                p += 128;
+                io += 128;
+        }
 }
 
 /* In order to do Jumbo packets on these chips, need to turn off the
@@ -3934,7 +3971,6 @@ static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw,
         dev->stop = sky2_down;
         dev->do_ioctl = sky2_ioctl;
         dev->hard_start_xmit = sky2_xmit_frame;
-        dev->get_stats = sky2_get_stats;
         dev->set_multicast_list = sky2_set_multicast;
         dev->set_mac_address = sky2_set_mac_address;
         dev->change_mtu = sky2_change_mtu;
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index f4a3c2f403..49ee264064 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -2031,8 +2031,6 @@ struct sky2_port {
 #ifdef CONFIG_SKY2_DEBUG
         struct dentry        *debugfs;
 #endif
-        struct net_device_stats net_stats;
-
 };
 
 struct sky2_hw {
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index a402b5c018..30b1cca814 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -3576,7 +3576,7 @@ static int tg3_poll_work(struct tg3 *tp, int work_done, int budget)
         if (sblk->idx[0].tx_consumer != tp->tx_cons) {
                 tg3_tx(tp);
                 if (unlikely(tp->tg3_flags & TG3_FLAG_TX_RECOVERY_PENDING))
-                        return 0;
+                        return work_done;
         }
 
         /* run RX thread, within the bounds set by NAPI.
@@ -3593,6 +3593,7 @@ static int tg3_poll(struct napi_struct *napi, int budget)
 {
         struct tg3 *tp = container_of(napi, struct tg3, napi);
         int work_done = 0;
+        struct tg3_hw_status *sblk = tp->hw_status;
 
         while (1) {
                 work_done = tg3_poll_work(tp, work_done, budget);
@@ -3603,15 +3604,17 @@ static int tg3_poll(struct napi_struct *napi, int budget)
                 if (unlikely(work_done >= budget))
                         break;
 
-                if (likely(!tg3_has_work(tp))) {
-                        struct tg3_hw_status *sblk = tp->hw_status;
-
-                        if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
-                                tp->last_tag = sblk->status_tag;
-                                rmb();
-                        } else
-                                sblk->status &= ~SD_STATUS_UPDATED;
+                if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
+                        /* tp->last_tag is used in tg3_restart_ints() below
+                         * to tell the hw how much work has been processed,
+                         * so we must read it before checking for more work.
+                         */
+                        tp->last_tag = sblk->status_tag;
+                        rmb();
+                } else
+                        sblk->status &= ~SD_STATUS_UPDATED;
 
+                if (likely(!tg3_has_work(tp))) {
                         netif_rx_complete(tp->dev, napi);
                         tg3_restart_ints(tp);
                         break;
@@ -3621,9 +3624,10 @@ static int tg3_poll(struct napi_struct *napi, int budget)
         return work_done;
 
 tx_recovery:
+        /* work_done is guaranteed to be less than budget. */
         netif_rx_complete(tp->dev, napi);
         schedule_work(&tp->reset_task);
-        return 0;
+        return work_done;
 }
 
 static void tg3_irq_quiesce(struct tg3 *tp)
@@ -6985,9 +6989,10 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                 break;
         };
 
-        /* Write our heartbeat update interval to APE. */
-        tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_INT_MS,
-                        APE_HOST_HEARTBEAT_INT_DISABLE);
+        if (tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)
+                /* Write our heartbeat update interval to APE. */
+                tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_INT_MS,
+                                APE_HOST_HEARTBEAT_INT_DISABLE);
 
         tg3_write_sig_post_reset(tp, RESET_KIND_INIT);
 
diff --git a/drivers/net/wireless/b43/phy.c b/drivers/net/wireless/b43/phy.c
index 5f7ffa0a76..3d4ed647c3 100644
--- a/drivers/net/wireless/b43/phy.c
+++ b/drivers/net/wireless/b43/phy.c
@@ -26,6 +26,7 @@
 */
 
 #include <linux/delay.h>
+#include <linux/io.h>
 #include <linux/types.h>
 
 #include "b43.h"
diff --git a/drivers/net/wireless/b43/pio.h b/drivers/net/wireless/b43/pio.h
index 34a44c1b63..3488f2447b 100644
--- a/drivers/net/wireless/b43/pio.h
+++ b/drivers/net/wireless/b43/pio.h
@@ -4,6 +4,7 @@
 #include "b43.h"
 
 #include <linux/interrupt.h>
+#include <linux/io.h>
 #include <linux/list.h>
 #include <linux/skbuff.h>
 
diff --git a/drivers/net/wireless/b43/sysfs.c b/drivers/net/wireless/b43/sysfs.c
index fcb777383e..f4faff6a7d 100644
--- a/drivers/net/wireless/b43/sysfs.c
+++ b/drivers/net/wireless/b43/sysfs.c
@@ -23,13 +23,14 @@
 
 */
 
+#include <linux/capability.h>
+#include <linux/io.h>
+
 #include "b43.h"
 #include "sysfs.h"
 #include "main.h"
 #include "phy.h"
 
-#include <linux/capability.h>
-
 #define GENERIC_FILESIZE        64
 
 static int get_integer(const char *buf, size_t count)
diff --git a/drivers/pci/hotplug.c b/drivers/pci/hotplug.c
index 1c97e7dd13..2b5352a7df 100644
--- a/drivers/pci/hotplug.c
+++ b/drivers/pci/hotplug.c
@@ -3,12 +3,9 @@
 #include <linux/module.h>
 #include "pci.h"
 
-int pci_uevent(struct device *dev, char **envp, int num_envp,
-               char *buffer, int buffer_size)
+int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct pci_dev *pdev;
-        int i = 0;
-        int length = 0;
 
         if (!dev)
                 return -ENODEV;
@@ -17,37 +14,24 @@ int pci_uevent(struct device *dev, char **envp, int num_envp,
         if (!pdev)
                 return -ENODEV;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PCI_CLASS=%04X", pdev->class))
+        if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
+        if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
+        if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
                            pdev->subsystem_device))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PCI_SLOT_NAME=%s", pci_name(pdev)))
+        if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
+        if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
                            pdev->vendor, pdev->device,
                            pdev->subsystem_vendor, pdev->subsystem_device,
                            (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
                            (u8)(pdev->class)))
                 return -ENOMEM;
-
-        envp[i] = NULL;
-
         return 0;
 }
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 2305cc450a..a96b739b2d 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -549,7 +549,7 @@ get_slot_mapping(struct pci_bus *bus, u8 bus_num, u8 dev_num, u8 *slot)
                          * slot. */
                         bus->number = tbus;
                         pci_bus_read_config_dword(bus, PCI_DEVFN(tdevice, 0),
-                                                PCI_REVISION_ID, &work);
+                                                PCI_CLASS_REVISION, &work);
 
                         if ((work >> 8) == PCI_TO_PCI_BRIDGE_CLASS) {
                                 pci_bus_read_config_dword(bus,
diff --git a/drivers/pci/hotplug/cpqphp_ctrl.c b/drivers/pci/hotplug/cpqphp_ctrl.c
index 37d72f123a..3ef0a4875a 100644
--- a/drivers/pci/hotplug/cpqphp_ctrl.c
+++ b/drivers/pci/hotplug/cpqphp_ctrl.c
@@ -37,6 +37,7 @@
 #include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
+#include <linux/kthread.h>
 #include "cpqphp.h"
 
 static u32 configure_new_device(struct controller* ctrl, struct pci_func *func,
@@ -45,34 +46,20 @@ static int configure_new_function(struct controller* ctrl, struct pci_func *func
                         u8 behind_bridge, struct resource_lists *resources);
 static void interrupt_event_handler(struct controller *ctrl);
 
-static struct semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
-static struct semaphore event_exit;             /* guard ensure thread has exited before calling it quits */
-static int event_finished;
-static unsigned long pushbutton_pending;        /* = 0 */
 
-/* things needed for the long_delay function */
-static struct semaphore         delay_sem;
-static wait_queue_head_t        delay_wait;
+static struct task_struct *cpqhp_event_thread;
+static unsigned long pushbutton_pending;        /* = 0 */
 
 /* delay is in jiffies to wait for */
 static void long_delay(int delay)
 {
-        DECLARE_WAITQUEUE(wait, current);
-        
-        /* only allow 1 customer into the delay queue at once
-         * yes this makes some people wait even longer, but who really cares?
-         * this is for _huge_ delays to make the hardware happy as the 
-         * signals bounce around
+        /*
+         * XXX(hch): if someone is bored please convert all callers
+         * to call msleep_interruptible directly.  They really want
+         * to specify timeouts in natural units and spend a lot of
+         * effort converting them to jiffies..
          */
-        down (&delay_sem);
-
-        init_waitqueue_head(&delay_wait);
-
-        add_wait_queue(&delay_wait, &wait);
         msleep_interruptible(jiffies_to_msecs(delay));
-        remove_wait_queue(&delay_wait, &wait);
-        
-        up(&delay_sem);
 }
 
 
@@ -955,8 +942,8 @@ irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data)
         }
 
         if (schedule_flag) {
-                up(&event_semaphore);
-                dbg("Signal event_semaphore\n");
+                wake_up_process(cpqhp_event_thread);
+                dbg("Waking even thread");
         }
         return IRQ_HANDLED;
 }
@@ -973,16 +960,13 @@ struct pci_func *cpqhp_slot_create(u8 busnumber)
         struct pci_func *new_slot;
         struct pci_func *next;
 
-        new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL);
-
+        new_slot = kzalloc(sizeof(*new_slot), GFP_KERNEL);
         if (new_slot == NULL) {
                 /* I'm not dead yet!
                  * You will be. */
                 return new_slot;
         }
 
-        memset(new_slot, 0, sizeof(struct pci_func));
-
         new_slot->next = NULL;
         new_slot->configured = 1;
 
@@ -1738,7 +1722,7 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
 static void pushbutton_helper_thread(unsigned long data)
 {
         pushbutton_pending = data;
-        up(&event_semaphore);
+        wake_up_process(cpqhp_event_thread);
 }
 
 
@@ -1747,13 +1731,13 @@ static int event_thread(void* data)
 {
         struct controller *ctrl;
 
-        daemonize("phpd_event");
-
         while (1) {
                 dbg("!!!!event_thread sleeping\n");
-                down_interruptible (&event_semaphore);
-                dbg("event_thread woken finished = %d\n", event_finished);
-                if (event_finished) break;
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule();
+
+                if (kthread_should_stop())
+                        break;
                 /* Do stuff here */
                 if (pushbutton_pending)
                         cpqhp_pushbutton_thread(pushbutton_pending);
@@ -1762,38 +1746,24 @@ static int event_thread(void* data)
                                 interrupt_event_handler(ctrl);
         }
         dbg("event_thread signals exit\n");
-        up(&event_exit);
         return 0;
 }
 
-
 int cpqhp_event_start_thread(void)
 {
-        int pid;
-
-        /* initialize our semaphores */
-        init_MUTEX(&delay_sem);
-        init_MUTEX_LOCKED(&event_semaphore);
-        init_MUTEX_LOCKED(&event_exit);
-        event_finished=0;
-
-        pid = kernel_thread(event_thread, NULL, 0);
-        if (pid < 0) {
+        cpqhp_event_thread = kthread_run(event_thread, NULL, "phpd_event");
+        if (IS_ERR(cpqhp_event_thread)) {
                 err ("Can't start up our event thread\n");
-                return -1;
+                return PTR_ERR(cpqhp_event_thread);
         }
-        dbg("Our event thread pid = %d\n", pid);
+
         return 0;
 }
 
 
 void cpqhp_event_stop_thread(void)
 {
-        event_finished = 1;
-        dbg("event_thread finish command given\n");
-        up(&event_semaphore);
-        dbg("wait for event_thread to exit\n");
-        down(&event_exit);
+        kthread_stop(cpqhp_event_thread);
 }
 
 
diff --git a/drivers/pci/hotplug/ibmphp_hpc.c b/drivers/pci/hotplug/ibmphp_hpc.c
index d06ccb69e4..c31e7bf345 100644
--- a/drivers/pci/hotplug/ibmphp_hpc.c
+++ b/drivers/pci/hotplug/ibmphp_hpc.c
@@ -35,7 +35,7 @@
 #include <linux/init.h>
 #include <linux/mutex.h>
 #include <linux/sched.h>
-
+#include <linux/kthread.h>
 #include "ibmphp.h"
 
 static int to_debug = 0;
@@ -101,12 +101,11 @@ static int to_debug = 0;
 //----------------------------------------------------------------------------
 // global variables
 //----------------------------------------------------------------------------
-static int ibmphp_shutdown;
-static int tid_poll;
 static struct mutex sem_hpcaccess;      // lock access to HPC
 static struct semaphore semOperations;  // lock all operations and
                                         // access to data structures
 static struct semaphore sem_exit;       // make sure polling thread goes away
+static struct task_struct *ibmphp_poll_thread;
 //----------------------------------------------------------------------------
 // local function prototypes
 //----------------------------------------------------------------------------
@@ -116,10 +115,9 @@ static u8 hpc_writecmdtoindex (u8, u8);
 static u8 hpc_readcmdtoindex (u8, u8);
 static void get_hpc_access (void);
 static void free_hpc_access (void);
-static void poll_hpc (void);
+static int poll_hpc(void *data);
 static int process_changeinstatus (struct slot *, struct slot *);
 static int process_changeinlatch (u8, u8, struct controller *);
-static int hpc_poll_thread (void *);
 static int hpc_wait_ctlr_notworking (int, struct controller *, void __iomem *, u8 *);
 //----------------------------------------------------------------------------
 
@@ -137,8 +135,6 @@ void __init ibmphp_hpc_initvars (void)
         init_MUTEX (&semOperations);
         init_MUTEX_LOCKED (&sem_exit);
         to_debug = 0;
-        ibmphp_shutdown = 0;
-        tid_poll = 0;
 
         debug ("%s - Exit\n", __FUNCTION__);
 }
@@ -819,7 +815,7 @@ void ibmphp_unlock_operations (void)
 #define POLL_LATCH_REGISTER     0
 #define POLL_SLOTS              1
 #define POLL_SLEEP              2
-static void poll_hpc (void)
+static int poll_hpc(void *data)
 {
         struct slot myslot;
         struct slot *pslot = NULL;
@@ -833,10 +829,7 @@ static void poll_hpc (void)
 
         debug ("%s - Entry\n", __FUNCTION__);
 
-        while (!ibmphp_shutdown) {
-                if (ibmphp_shutdown) 
-                        break;
-                
+        while (!kthread_should_stop()) {
                 /* try to get the lock to do some kind of hardware access */
                 down (&semOperations);
 
@@ -896,7 +889,7 @@ static void poll_hpc (void)
                         up (&semOperations);
                         msleep(POLL_INTERVAL_SEC * 1000);
 
-                        if (ibmphp_shutdown) 
+                        if (kthread_should_stop())
                                 break;
                         
                         down (&semOperations);
@@ -915,6 +908,7 @@ static void poll_hpc (void)
         }
         up (&sem_exit);
         debug ("%s - Exit\n", __FUNCTION__);
+        return 0;
 }
 
 
@@ -1050,47 +1044,20 @@ static int process_changeinlatch (u8 old, u8 new, struct controller *ctrl)
 }
 
 /*----------------------------------------------------------------------
-* Name:    hpc_poll_thread
-*
-* Action:  polling
-*
-* Return   0
-* Value:
-*---------------------------------------------------------------------*/
-static int hpc_poll_thread (void *data)
-{
-        debug ("%s - Entry\n", __FUNCTION__);
-
-        daemonize("hpc_poll");
-        allow_signal(SIGKILL);
-
-        poll_hpc ();
-
-        tid_poll = 0;
-        debug ("%s - Exit\n", __FUNCTION__);
-        return 0;
-}
-
-
-/*----------------------------------------------------------------------
 * Name:    ibmphp_hpc_start_poll_thread
 *
 * Action:  start polling thread
 *---------------------------------------------------------------------*/
 int __init ibmphp_hpc_start_poll_thread (void)
 {
-        int rc = 0;
-
         debug ("%s - Entry\n", __FUNCTION__);
 
-        tid_poll = kernel_thread (hpc_poll_thread, NULL, 0);
-        if (tid_poll < 0) {
+        ibmphp_poll_thread = kthread_run(poll_hpc, NULL, "hpc_poll");
+        if (IS_ERR(ibmphp_poll_thread)) {
                 err ("%s - Error, thread not started\n", __FUNCTION__);
-                rc = -1;
+                return PTR_ERR(ibmphp_poll_thread);
         }
-
-        debug ("%s - Exit tid_poll[%d] rc[%d]\n", __FUNCTION__, tid_poll, rc);
-        return rc;
+        return 0;
 }
 
 /*----------------------------------------------------------------------
@@ -1102,7 +1069,7 @@ void __exit ibmphp_hpc_stop_poll_thread (void)
 {
         debug ("%s - Entry\n", __FUNCTION__);
 
-        ibmphp_shutdown = 1;
+        kthread_stop(ibmphp_poll_thread);
         debug ("before locking operations \n");
         ibmphp_lock_operations ();
         debug ("after locking operations \n");
diff --git a/drivers/pci/hotplug/pci_hotplug_core.c b/drivers/pci/hotplug/pci_hotplug_core.c
index bd433ef6bf..f0eba534f8 100644
--- a/drivers/pci/hotplug/pci_hotplug_core.c
+++ b/drivers/pci/hotplug/pci_hotplug_core.c
@@ -694,66 +694,6 @@ int __must_check pci_hp_change_slot_info(struct hotplug_slot *slot,
         if ((slot == NULL) || (info == NULL))
                 return -ENODEV;
 
-        /*
-        * check all fields in the info structure, and update timestamps
-        * for the files referring to the fields that have now changed.
-        */
-        if ((has_power_file(slot) == 0) &&
-            (slot->info->power_status != info->power_status)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_power.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_attention_file(slot) == 0) &&
-            (slot->info->attention_status != info->attention_status)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_attention.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_latch_file(slot) == 0) &&
-            (slot->info->latch_status != info->latch_status)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_latch.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_adapter_file(slot) == 0) &&
-            (slot->info->adapter_status != info->adapter_status)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_presence.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_address_file(slot) == 0) &&
-            (slot->info->address != info->address)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_address.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_max_bus_speed_file(slot) == 0) &&
-            (slot->info->max_bus_speed != info->max_bus_speed)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_max_bus_speed.attr);
-                if (retval)
-                        return retval;
-        }
-
-        if ((has_cur_bus_speed_file(slot) == 0) &&
-            (slot->info->cur_bus_speed != info->cur_bus_speed)) {
-                retval = sysfs_update_file(&slot->kobj,
-                                           &hotplug_slot_attr_cur_bus_speed.attr);
-                if (retval)
-                        return retval;
-        }
-
         memcpy (slot->info, info, sizeof (struct hotplug_slot_info));
 
         return 0;
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index e5d3f0b4f4..6462ac3b40 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -304,8 +304,8 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
         hotplug_slot->info->attention_status = status;
-        
-        if (ATTN_LED(slot->ctrl->ctrlcap)) 
+
+        if (ATTN_LED(slot->ctrl->ctrlcap))
                 slot->hpc_ops->set_attention_status(slot, status);
 
         return 0;
@@ -405,7 +405,7 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
-        
+
         retval = slot->hpc_ops->get_max_bus_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
@@ -419,7 +419,7 @@ static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
-        
+
         retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
@@ -434,7 +434,7 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         struct slot *t_slot;
         u8 value;
         struct pci_dev *pdev;
-        
+
         ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
         if (!ctrl) {
                 err("%s : out of memory\n", __FUNCTION__);
@@ -502,23 +502,23 @@ static void pciehp_remove (struct pcie_device *dev)
 #ifdef CONFIG_PM
 static int pciehp_suspend (struct pcie_device *dev, pm_message_t state)
 {
-        printk("%s ENTRY\n", __FUNCTION__);     
+        printk("%s ENTRY\n", __FUNCTION__);
         return 0;
 }
 
 static int pciehp_resume (struct pcie_device *dev)
 {
-        printk("%s ENTRY\n", __FUNCTION__);     
+        printk("%s ENTRY\n", __FUNCTION__);
         return 0;
 }
 #endif
 
-static struct pcie_port_service_id port_pci_ids[] = { { 
-        .vendor = PCI_ANY_ID, 
+static struct pcie_port_service_id port_pci_ids[] = { {
+        .vendor = PCI_ANY_ID,
         .device = PCI_ANY_ID,
         .port_type = PCIE_ANY_PORT,
         .service_type = PCIE_PORT_SERVICE_HP,
-        .driver_data =  0, 
+        .driver_data =  0,
         }, { /* end: all zeroes */ }
 };
 static const char device_name[] = "hpdriver";
@@ -540,10 +540,6 @@ static int __init pcied_init(void)
 {
         int retval = 0;
 
-#ifdef CONFIG_HOTPLUG_PCI_PCIE_POLL_EVENT_MODE
-        pciehp_poll_mode = 1;
-#endif
-
         retval = pcie_port_service_register(&hpdriver_portdrv);
         dbg("pcie_port_service_register = %d\n", retval);
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 98e541ffef..c8cb49c5a7 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -173,7 +173,7 @@ u8 pciehp_handle_power_fault(u8 hp_slot, struct controller *ctrl)
         return 1;
 }
 
-/* The following routines constitute the bulk of the 
+/* The following routines constitute the bulk of the
    hotplug controller logic
  */
 
@@ -181,7 +181,7 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 {
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl->ctrlcap)) {
-                if (pslot->hpc_ops->power_off_slot(pslot)) {   
+                if (pslot->hpc_ops->power_off_slot(pslot)) {
                         err("%s: Issue of Slot Power Off command failed\n",
                             __FUNCTION__);
                         return;
@@ -189,7 +189,7 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
         }
 
         if (PWR_LED(ctrl->ctrlcap))
-                pslot->hpc_ops->green_led_off(pslot);   
+                pslot->hpc_ops->green_led_off(pslot);
 
         if (ATTN_LED(ctrl->ctrlcap)) {
                 if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
@@ -231,7 +231,7 @@ static int board_added(struct slot *p_slot)
                 if (retval)
                         return retval;
         }
-        
+
         if (PWR_LED(ctrl->ctrlcap))
                 p_slot->hpc_ops->green_led_blink(p_slot);
 
@@ -548,7 +548,7 @@ int pciehp_enable_slot(struct slot *p_slot)
                 mutex_unlock(&p_slot->ctrl->crit_sect);
                 return -ENODEV;
         }
-        if (MRL_SENS(p_slot->ctrl->ctrlcap)) {  
+        if (MRL_SENS(p_slot->ctrl->ctrlcap)) {
                 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         info("%s: latch open on slot(%s)\n", __FUNCTION__,
@@ -557,8 +557,8 @@ int pciehp_enable_slot(struct slot *p_slot)
                         return -ENODEV;
                 }
         }
-        
-        if (POWER_CTRL(p_slot->ctrl->ctrlcap)) {        
+
+        if (POWER_CTRL(p_slot->ctrl->ctrlcap)) {
                 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         info("%s: already enabled on slot(%s)\n", __FUNCTION__,
@@ -593,7 +593,7 @@ int pciehp_disable_slot(struct slot *p_slot)
         /* Check to see if (latch closed, card present, power on) */
         mutex_lock(&p_slot->ctrl->crit_sect);
 
-        if (!HP_SUPR_RM(p_slot->ctrl->ctrlcap)) {       
+        if (!HP_SUPR_RM(p_slot->ctrl->ctrlcap)) {
                 ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         info("%s: no adapter on slot(%s)\n", __FUNCTION__,
@@ -603,7 +603,7 @@ int pciehp_disable_slot(struct slot *p_slot)
                 }
         }
 
-        if (MRL_SENS(p_slot->ctrl->ctrlcap)) {  
+        if (MRL_SENS(p_slot->ctrl->ctrlcap)) {
                 ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (ret || getstatus) {
                         info("%s: latch open on slot(%s)\n", __FUNCTION__,
@@ -613,7 +613,7 @@ int pciehp_disable_slot(struct slot *p_slot)
                 }
         }
 
-        if (POWER_CTRL(p_slot->ctrl->ctrlcap)) {        
+        if (POWER_CTRL(p_slot->ctrl->ctrlcap)) {
                 ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         info("%s: already disabled slot(%s)\n", __FUNCTION__,
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 016eea94a8..06d025b8b1 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -39,37 +39,6 @@
 
 #include "../pci.h"
 #include "pciehp.h"
-#ifdef DEBUG
-#define DBG_K_TRACE_ENTRY      ((unsigned int)0x00000001)       /* On function entry */
-#define DBG_K_TRACE_EXIT       ((unsigned int)0x00000002)       /* On function exit */
-#define DBG_K_INFO             ((unsigned int)0x00000004)       /* Info messages */
-#define DBG_K_ERROR            ((unsigned int)0x00000008)       /* Error messages */
-#define DBG_K_TRACE            (DBG_K_TRACE_ENTRY|DBG_K_TRACE_EXIT)
-#define DBG_K_STANDARD         (DBG_K_INFO|DBG_K_ERROR|DBG_K_TRACE)
-/* Redefine this flagword to set debug level */
-#define DEBUG_LEVEL            DBG_K_STANDARD
-
-#define DEFINE_DBG_BUFFER     char __dbg_str_buf[256];
-
-#define DBG_PRINT( dbg_flags, args... )              \
-        do {                                             \
-          if ( DEBUG_LEVEL & ( dbg_flags ) )             \
-          {                                              \
-            int len;                                     \
-            len = sprintf( __dbg_str_buf, "%s:%d: %s: ", \
-                  __FILE__, __LINE__, __FUNCTION__ );    \
-            sprintf( __dbg_str_buf + len, args );        \
-            printk( KERN_NOTICE "%s\n", __dbg_str_buf ); \
-          }                                              \
-        } while (0)
-
-#define DBG_ENTER_ROUTINE       DBG_PRINT (DBG_K_TRACE_ENTRY, "%s", "[Entry]");
-#define DBG_LEAVE_ROUTINE       DBG_PRINT (DBG_K_TRACE_EXIT, "%s", "[Exit]");
-#else
-#define DEFINE_DBG_BUFFER
-#define DBG_ENTER_ROUTINE
-#define DBG_LEAVE_ROUTINE
-#endif                          /* DEBUG */
 
 static atomic_t pciehp_num_controllers = ATOMIC_INIT(0);
 
@@ -160,10 +129,10 @@ static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
 /* Link Width Encoding */
 #define LNK_X1          0x01
 #define LNK_X2          0x02
-#define LNK_X4          0x04    
+#define LNK_X4          0x04
 #define LNK_X8          0x08
 #define LNK_X12         0x0C
-#define LNK_X16         0x10    
+#define LNK_X16         0x10
 #define LNK_X32         0x20
 
 /*Field definitions of Link Status Register */
@@ -221,8 +190,6 @@ static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
 #define EMI_STATE               0x0080
 #define EMI_STATUS_BIT          7
 
-DEFINE_DBG_BUFFER               /* Debug string buffer for entire HPC defined here */
-
 static irqreturn_t pcie_isr(int irq, void *dev_id);
 static void start_int_poll_timer(struct controller *ctrl, int sec);
 
@@ -231,14 +198,12 @@ static void int_poll_timeout(unsigned long data)
 {
         struct controller *ctrl = (struct controller *)data;
 
-        DBG_ENTER_ROUTINE
-
         /* Poll for interrupt events.  regs == NULL => polling */
         pcie_isr(0, ctrl);
 
         init_timer(&ctrl->poll_timer);
         if (!pciehp_poll_time)
-                pciehp_poll_time = 2; /* reset timer to poll in 2 secs if user doesn't specify at module installation*/
+                pciehp_poll_time = 2; /* default polling interval is 2 sec */
 
         start_int_poll_timer(ctrl, pciehp_poll_time);
 }
@@ -289,8 +254,6 @@ static int pcie_write_cmd(struct slot *slot, u16 cmd, u16 mask)
         u16 slot_ctrl;
         unsigned long flags;
 
-        DBG_ENTER_ROUTINE 
-
         mutex_lock(&ctrl->ctrl_lock);
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
@@ -299,7 +262,7 @@ static int pcie_write_cmd(struct slot *slot, u16 cmd, u16 mask)
                 goto out;
         }
 
-        if ((slot_status & CMD_COMPLETED) == CMD_COMPLETED ) { 
+        if ((slot_status & CMD_COMPLETED) == CMD_COMPLETED ) {
                 /* After 1 sec and CMD_COMPLETED still not set, just
                    proceed forward to issue the next command according
                    to spec.  Just print out the error message */
@@ -332,7 +295,6 @@ static int pcie_write_cmd(struct slot *slot, u16 cmd, u16 mask)
                 retval = pcie_wait_cmd(ctrl);
  out:
         mutex_unlock(&ctrl->ctrl_lock);
-        DBG_LEAVE_ROUTINE 
         return retval;
 }
 
@@ -341,8 +303,6 @@ static int hpc_check_lnk_status(struct controller *ctrl)
         u16 lnk_status;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
                 err("%s: Cannot read LNKSTATUS register\n", __FUNCTION__);
@@ -350,26 +310,22 @@ static int hpc_check_lnk_status(struct controller *ctrl)
         }
 
         dbg("%s: lnk_status = %x\n", __FUNCTION__, lnk_status);
-        if ( (lnk_status & LNK_TRN) || (lnk_status & LNK_TRN_ERR) || 
+        if ( (lnk_status & LNK_TRN) || (lnk_status & LNK_TRN_ERR) ||
                 !(lnk_status & NEG_LINK_WD)) {
                 err("%s : Link Training Error occurs \n", __FUNCTION__);
                 retval = -1;
                 return retval;
         }
 
-        DBG_LEAVE_ROUTINE 
         return retval;
 }
 
-
 static int hpc_get_attention_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_ctrl;
         u8 atten_led_state;
         int retval = 0;
-        
-        DBG_ENTER_ROUTINE 
 
         retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
@@ -400,7 +356,6 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
                 break;
         }
 
-        DBG_LEAVE_ROUTINE 
         return 0;
 }
 
@@ -410,8 +365,6 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
         u16 slot_ctrl;
         u8 pwr_state;
         int     retval = 0;
-        
-        DBG_ENTER_ROUTINE 
 
         retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
@@ -428,35 +381,30 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
                 *status = 1;
                 break;
         case 1:
-                *status = 0;    
+                *status = 0;
                 break;
         default:
                 *status = 0xFF;
                 break;
         }
 
-        DBG_LEAVE_ROUTINE 
         return retval;
 }
 
-
 static int hpc_get_latch_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
                 err("%s: Cannot read SLOTSTATUS register\n", __FUNCTION__);
                 return retval;
         }
 
-        *status = (((slot_status & MRL_STATE) >> 5) == 0) ? 0 : 1;  
+        *status = (((slot_status & MRL_STATE) >> 5) == 0) ? 0 : 1;
 
-        DBG_LEAVE_ROUTINE 
         return 0;
 }
 
@@ -467,8 +415,6 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
         u8 card_state;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
                 err("%s: Cannot read SLOTSTATUS register\n", __FUNCTION__);
@@ -477,7 +423,6 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
         card_state = (u8)((slot_status & PRSN_STATE) >> 6);
         *status = (card_state == 1) ? 1 : 0;
 
-        DBG_LEAVE_ROUTINE 
         return 0;
 }
 
@@ -488,16 +433,13 @@ static int hpc_query_power_fault(struct slot *slot)
         u8 pwr_fault;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
                 err("%s: Cannot check for power fault\n", __FUNCTION__);
                 return retval;
         }
         pwr_fault = (u8)((slot_status & PWR_FAULT_DETECTED) >> 1);
-        
-        DBG_LEAVE_ROUTINE
+
         return pwr_fault;
 }
 
@@ -507,8 +449,6 @@ static int hpc_get_emi_status(struct slot *slot, u8 *status)
         u16 slot_status;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE
-
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
                 err("%s : Cannot check EMI status\n", __FUNCTION__);
@@ -516,7 +456,6 @@ static int hpc_get_emi_status(struct slot *slot, u8 *status)
         }
         *status = (slot_status & EMI_STATE) >> EMI_STATUS_BIT;
 
-        DBG_LEAVE_ROUTINE
         return retval;
 }
 
@@ -526,8 +465,6 @@ static int hpc_toggle_emi(struct slot *slot)
         u16 cmd_mask;
         int rc;
 
-        DBG_ENTER_ROUTINE
-
         slot_cmd = EMI_CTRL;
         cmd_mask = EMI_CTRL;
         if (!pciehp_poll_mode) {
@@ -537,7 +474,7 @@ static int hpc_toggle_emi(struct slot *slot)
 
         rc = pcie_write_cmd(slot, slot_cmd, cmd_mask);
         slot->last_emi_toggle = get_seconds();
-        DBG_LEAVE_ROUTINE
+
         return rc;
 }
 
@@ -548,8 +485,6 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
         u16 cmd_mask;
         int rc;
 
-        DBG_ENTER_ROUTINE
-
         cmd_mask = ATTN_LED_CTRL;
         switch (value) {
                 case 0 :        /* turn off */
@@ -572,19 +507,15 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
         rc = pcie_write_cmd(slot, slot_cmd, cmd_mask);
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
-        
-        DBG_LEAVE_ROUTINE
+
         return rc;
 }
 
-
 static void hpc_set_green_led_on(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
         u16 cmd_mask;
-        
-        DBG_ENTER_ROUTINE
 
         slot_cmd = 0x0100;
         cmd_mask = PWR_LED_CTRL;
@@ -597,8 +528,6 @@ static void hpc_set_green_led_on(struct slot *slot)
 
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
-        DBG_LEAVE_ROUTINE
-        return;
 }
 
 static void hpc_set_green_led_off(struct slot *slot)
@@ -607,8 +536,6 @@ static void hpc_set_green_led_off(struct slot *slot)
         u16 slot_cmd;
         u16 cmd_mask;
 
-        DBG_ENTER_ROUTINE
-
         slot_cmd = 0x0300;
         cmd_mask = PWR_LED_CTRL;
         if (!pciehp_poll_mode) {
@@ -619,9 +546,6 @@ static void hpc_set_green_led_off(struct slot *slot)
         pcie_write_cmd(slot, slot_cmd, cmd_mask);
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
-
-        DBG_LEAVE_ROUTINE
-        return;
 }
 
 static void hpc_set_green_led_blink(struct slot *slot)
@@ -629,8 +553,6 @@ static void hpc_set_green_led_blink(struct slot *slot)
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
         u16 cmd_mask;
-        
-        DBG_ENTER_ROUTINE
 
         slot_cmd = 0x0200;
         cmd_mask = PWR_LED_CTRL;
@@ -643,14 +565,10 @@ static void hpc_set_green_led_blink(struct slot *slot)
 
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
-        DBG_LEAVE_ROUTINE
-        return;
 }
 
 static void hpc_release_ctlr(struct controller *ctrl)
 {
-        DBG_ENTER_ROUTINE 
-
         if (pciehp_poll_mode)
                 del_timer(&ctrl->poll_timer);
         else
@@ -662,8 +580,6 @@ static void hpc_release_ctlr(struct controller *ctrl)
          */
         if (atomic_dec_and_test(&pciehp_num_controllers))
                 destroy_workqueue(pciehp_wq);
-
-        DBG_LEAVE_ROUTINE
 }
 
 static int hpc_power_on_slot(struct slot * slot)
@@ -674,8 +590,6 @@ static int hpc_power_on_slot(struct slot * slot)
         u16 slot_status;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         dbg("%s: slot->hp_slot %x\n", __FUNCTION__, slot->hp_slot);
 
         /* Clear sticky power-fault bit from previous power failures */
@@ -719,8 +633,6 @@ static int hpc_power_on_slot(struct slot * slot)
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 
-        DBG_LEAVE_ROUTINE
-
         return retval;
 }
 
@@ -731,8 +643,6 @@ static int hpc_power_off_slot(struct slot * slot)
         u16 cmd_mask;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         dbg("%s: slot->hp_slot %x\n", __FUNCTION__, slot->hp_slot);
 
         slot_cmd = POWER_OFF;
@@ -764,8 +674,6 @@ static int hpc_power_off_slot(struct slot * slot)
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 
-        DBG_LEAVE_ROUTINE
-
         return retval;
 }
 
@@ -784,8 +692,8 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 return IRQ_NONE;
         }
 
-        intr_detect = ( ATTN_BUTTN_PRESSED | PWR_FAULT_DETECTED | MRL_SENS_CHANGED |
-                                        PRSN_DETECT_CHANGED | CMD_COMPLETED );
+        intr_detect = (ATTN_BUTTN_PRESSED | PWR_FAULT_DETECTED |
+                       MRL_SENS_CHANGED | PRSN_DETECT_CHANGED | CMD_COMPLETED);
 
         intr_loc = slot_status & intr_detect;
 
@@ -807,7 +715,8 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
 
                 dbg("%s: pciehp_readw(SLOTCTRL) with value %x\n",
                     __FUNCTION__, temp_word);
-                temp_word = (temp_word & ~HP_INTR_ENABLE & ~CMD_CMPL_INTR_ENABLE) | 0x00;
+                temp_word = (temp_word & ~HP_INTR_ENABLE &
+                             ~CMD_CMPL_INTR_ENABLE) | 0x00;
                 rc = pciehp_writew(ctrl, SLOTCTRL, temp_word);
                 if (rc) {
                         err("%s: Cannot write to SLOTCTRL register\n",
@@ -825,7 +734,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 }
                 dbg("%s: pciehp_readw(SLOTSTATUS) with value %x\n",
                     __FUNCTION__, slot_status);
-                
+
                 /* Clear command complete interrupt caused by this write */
                 temp_word = 0x1f;
                 rc = pciehp_writew(ctrl, SLOTSTATUS, temp_word);
@@ -835,10 +744,10 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                         return IRQ_NONE;
                 }
         }
-        
+
         if (intr_loc & CMD_COMPLETED) {
-                /* 
-                 * Command Complete Interrupt Pending 
+                /*
+                 * Command Complete Interrupt Pending
                  */
                 ctrl->cmd_busy = 0;
                 wake_up_interruptible(&ctrl->queue);
@@ -892,7 +801,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                             __FUNCTION__);
                         return IRQ_NONE;
                 }
-                
+
                 /* Clear command complete interrupt caused by this write */
                 temp_word = 0x1F;
                 rc = pciehp_writew(ctrl, SLOTSTATUS, temp_word);
@@ -904,19 +813,17 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 dbg("%s: pciehp_writew(SLOTSTATUS) with value %x\n",
                     __FUNCTION__, temp_word);
         }
-        
+
         return IRQ_HANDLED;
 }
 
-static int hpc_get_max_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
+static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_speed lnk_speed;
         u32     lnk_cap;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
         if (retval) {
                 err("%s: Cannot read LNKCAP register\n", __FUNCTION__);
@@ -934,19 +841,18 @@ static int hpc_get_max_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
 
         *value = lnk_speed;
         dbg("Max link speed = %d\n", lnk_speed);
-        DBG_LEAVE_ROUTINE 
+
         return retval;
 }
 
-static int hpc_get_max_lnk_width (struct slot *slot, enum pcie_link_width *value)
+static int hpc_get_max_lnk_width(struct slot *slot,
+                                 enum pcie_link_width *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_width lnk_wdth;
         u32     lnk_cap;
         int retval = 0;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
         if (retval) {
                 err("%s: Cannot read LNKCAP register\n", __FUNCTION__);
@@ -985,19 +891,17 @@ static int hpc_get_max_lnk_width (struct slot *slot, enum pcie_link_width *value
 
         *value = lnk_wdth;
         dbg("Max link width = %d\n", lnk_wdth);
-        DBG_LEAVE_ROUTINE 
+
         return retval;
 }
 
-static int hpc_get_cur_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
+static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
         int retval = 0;
         u16 lnk_status;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
                 err("%s: Cannot read LNKSTATUS register\n", __FUNCTION__);
@@ -1015,25 +919,24 @@ static int hpc_get_cur_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
 
         *value = lnk_speed;
         dbg("Current link speed = %d\n", lnk_speed);
-        DBG_LEAVE_ROUTINE 
+
         return retval;
 }
 
-static int hpc_get_cur_lnk_width (struct slot *slot, enum pcie_link_width *value)
+static int hpc_get_cur_lnk_width(struct slot *slot,
+                                 enum pcie_link_width *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_width lnk_wdth = PCIE_LNK_WIDTH_UNKNOWN;
         int retval = 0;
         u16 lnk_status;
 
-        DBG_ENTER_ROUTINE 
-
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
                 err("%s: Cannot read LNKSTATUS register\n", __FUNCTION__);
                 return retval;
         }
-        
+
         switch ((lnk_status & 0x03F0) >> 4){
         case 0:
                 lnk_wdth = PCIE_LNK_WIDTH_RESRV;
@@ -1066,7 +969,7 @@ static int hpc_get_cur_lnk_width (struct slot *slot, enum pcie_link_width *value
 
         *value = lnk_wdth;
         dbg("Current link width = %d\n", lnk_wdth);
-        DBG_LEAVE_ROUTINE 
+
         return retval;
 }
 
@@ -1085,12 +988,12 @@ static struct hpc_ops pciehp_hpc_ops = {
         .get_cur_bus_speed              = hpc_get_cur_lnk_speed,
         .get_max_lnk_width              = hpc_get_max_lnk_width,
         .get_cur_lnk_width              = hpc_get_cur_lnk_width,
-        
+
         .query_power_fault              = hpc_query_power_fault,
         .green_led_on                   = hpc_set_green_led_on,
         .green_led_off                  = hpc_set_green_led_off,
         .green_led_blink                = hpc_set_green_led_blink,
-        
+
         .release_ctlr                   = hpc_release_ctlr,
         .check_lnk_status               = hpc_check_lnk_status,
 };
@@ -1138,6 +1041,7 @@ int pciehp_acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev)
                 dbg("Trying to get hotplug control for %s \n",
                         (char *)string.pointer);
                 status = pci_osc_control_set(handle,
+                                OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL |
                                 OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
                 if (status == AE_NOT_FOUND)
                         status = acpi_run_oshp(handle);
@@ -1163,8 +1067,6 @@ int pciehp_acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev)
 }
 #endif
 
-
-
 int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 {
         int rc;
@@ -1176,8 +1078,6 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
         u16 slot_status, slot_ctrl;
         struct pci_dev *pdev;
 
-        DBG_ENTER_ROUTINE
-        
         pdev = dev->port;
         ctrl->pci_dev = pdev;   /* save pci_dev in context */
 
@@ -1201,9 +1101,11 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
         dbg("%s: CAPREG offset %x cap_reg %x\n",
             __FUNCTION__, ctrl->cap_base + CAPREG, cap_reg);
 
-        if (((cap_reg & SLOT_IMPL) == 0) || (((cap_reg & DEV_PORT_TYPE) != 0x0040)
+        if (((cap_reg & SLOT_IMPL) == 0) ||
+            (((cap_reg & DEV_PORT_TYPE) != 0x0040)
                 && ((cap_reg & DEV_PORT_TYPE) != 0x0060))) {
-                dbg("%s : This is not a root port or the port is not connected to a slot\n", __FUNCTION__);
+                dbg("%s : This is not a root port or the port is not "
+                    "connected to a slot\n", __FUNCTION__);
                 goto abort_free_ctlr;
         }
 
@@ -1236,14 +1138,15 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
         dbg("%s: SLOTCTRL offset %x slot_ctrl %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
 
-        for ( rc = 0; rc < DEVICE_COUNT_RESOURCE; rc++)
+        for (rc = 0; rc < DEVICE_COUNT_RESOURCE; rc++)
                 if (pci_resource_len(pdev, rc) > 0)
                         dbg("pci resource[%d] start=0x%llx(len=0x%llx)\n", rc,
                             (unsigned long long)pci_resource_start(pdev, rc),
                             (unsigned long long)pci_resource_len(pdev, rc));
 
-        info("HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n", pdev->vendor, pdev->device, 
-                pdev->subsystem_vendor, pdev->subsystem_device);
+        info("HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
+             pdev->vendor, pdev->device,
+             pdev->subsystem_vendor, pdev->subsystem_device);
 
         mutex_init(&ctrl->crit_sect);
         mutex_init(&ctrl->ctrl_lock);
@@ -1267,7 +1170,8 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 
         dbg("%s: SLOTCTRL %x value read %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, temp_word);
-        temp_word = (temp_word & ~HP_INTR_ENABLE & ~CMD_CMPL_INTR_ENABLE) | 0x00;
+        temp_word = (temp_word & ~HP_INTR_ENABLE & ~CMD_CMPL_INTR_ENABLE) |
+                0x00;
 
         rc = pciehp_writew(ctrl, SLOTCTRL, temp_word);
         if (rc) {
@@ -1330,14 +1234,14 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 
         if (ATTN_BUTTN(slot_cap))
                 intr_enable = intr_enable | ATTN_BUTTN_ENABLE;
-        
+
         if (POWER_CTRL(slot_cap))
                 intr_enable = intr_enable | PWR_FAULT_DETECT_ENABLE;
-        
+
         if (MRL_SENS(slot_cap))
                 intr_enable = intr_enable | MRL_DETECT_ENABLE;
 
-        temp_word = (temp_word & ~intr_enable) | intr_enable; 
+        temp_word = (temp_word & ~intr_enable) | intr_enable;
 
         if (pciehp_poll_mode) {
                 temp_word = (temp_word & ~HP_INTR_ENABLE) | 0x0;
@@ -1345,7 +1249,10 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
                 temp_word = (temp_word & ~HP_INTR_ENABLE) | HP_INTR_ENABLE;
         }
 
-        /* Unmask Hot-plug Interrupt Enable for the interrupt notification mechanism case */
+        /*
+         * Unmask Hot-plug Interrupt Enable for the interrupt
+         * notification mechanism case.
+         */
         rc = pciehp_writew(ctrl, SLOTCTRL, temp_word);
         if (rc) {
                 err("%s: Cannot write to SLOTCTRL register\n", __FUNCTION__);
@@ -1356,14 +1263,14 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
                 err("%s: Cannot read SLOTSTATUS register\n", __FUNCTION__);
                 goto abort_disable_intr;
         }
-        
+
         temp_word =  0x1F; /* Clear all events */
         rc = pciehp_writew(ctrl, SLOTSTATUS, temp_word);
         if (rc) {
                 err("%s: Cannot write to SLOTSTATUS register\n", __FUNCTION__);
                 goto abort_disable_intr;
         }
-        
+
         if (pciehp_force) {
                 dbg("Bypassing BIOS check for pciehp use on %s\n",
                                 pci_name(ctrl->pci_dev));
@@ -1375,10 +1282,9 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 
         ctrl->hpc_ops = &pciehp_hpc_ops;
 
-        DBG_LEAVE_ROUTINE
         return 0;
 
-        /* We end up here for the many possible ways to fail this API.  */
+        /* We end up here for the many possible ways to fail this API. */
 abort_disable_intr:
         rc = pciehp_readw(ctrl, SLOTCTRL, &temp_word);
         if (!rc) {
@@ -1395,6 +1301,5 @@ abort_free_irq:
                 free_irq(ctrl->pci_dev->irq, ctrl);
 
 abort_free_ctlr:
-        DBG_LEAVE_ROUTINE
         return -1;
 }
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 854aaea09e..c424aded13 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -243,9 +243,10 @@ int pciehp_configure_device(struct slot *p_slot)
 
 int pciehp_unconfigure_device(struct slot *p_slot)
 {
-        int rc = 0;
+        int ret, rc = 0;
         int j;
         u8 bctl = 0;
+        u8 presence = 0;
         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
 
         dbg("%s: bus/dev = %x/%x\n", __FUNCTION__, p_slot->bus,
@@ -263,23 +264,28 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                         continue;
                 }
                 if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
-                        pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
-                        if (bctl & PCI_BRIDGE_CTL_VGA) {
-                                err("Cannot remove display device %s\n",
+                        ret = p_slot->hpc_ops->get_adapter_status(p_slot,
+                                                                &presence);
+                        if (!ret && presence) {
+                                pci_read_config_byte(temp, PCI_BRIDGE_CONTROL,
+                                        &bctl);
+                                if (bctl & PCI_BRIDGE_CTL_VGA) {
+                                        err("Cannot remove display device %s\n",
                                                 pci_name(temp));
-                                pci_dev_put(temp);
-                                continue;
+                                        pci_dev_put(temp);
+                                        continue;
+                                }
                         }
                 }
                 pci_remove_bus_device(temp);
                 pci_dev_put(temp);
         }
-        /* 
+        /*
          * Some PCI Express root ports require fixup after hot-plug operation.
          */
-        if (pcie_mch_quirk) 
+        if (pcie_mch_quirk)
                 pci_fixup_device(pci_fixup_final, p_slot->ctrl->pci_dev);
-        
+
         return rc;
 }
 
diff --git a/drivers/pci/hotplug/rpadlpar_sysfs.c b/drivers/pci/hotplug/rpadlpar_sysfs.c
index df076064a3..a080fedf03 100644
--- a/drivers/pci/hotplug/rpadlpar_sysfs.c
+++ b/drivers/pci/hotplug/rpadlpar_sysfs.c
@@ -129,17 +129,17 @@ struct kobj_type ktype_dlpar_io = {
 };
 
 struct kset dlpar_io_kset = {
-        .kobj = {.name = DLPAR_KOBJ_NAME,
-                 .ktype = &ktype_dlpar_io,
+        .kobj = {.ktype = &ktype_dlpar_io,
                  .parent = &pci_hotplug_slots_subsys.kobj},
         .ktype = &ktype_dlpar_io,
 };
 
 int dlpar_sysfs_init(void)
 {
+        kobject_set_name(&dlpar_io_kset.kobj, DLPAR_KOBJ_NAME);
         if (kset_register(&dlpar_io_kset)) {
                 printk(KERN_ERR "rpadlpar_io: cannot register kset for %s\n",
-                                dlpar_io_kset.kobj.name);
+                                kobject_name(&dlpar_io_kset.kobj));
                 return -EINVAL;
         }
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index be1df85e5e..87e0161505 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -132,7 +132,7 @@ void read_msi_msg(unsigned int irq, struct msi_msg *msg)
                         pci_read_config_word(dev, msi_data_reg(pos, 1), &data);
                 } else {
                         msg->address_hi = 0;
-                        pci_read_config_word(dev, msi_data_reg(pos, 1), &data);
+                        pci_read_config_word(dev, msi_data_reg(pos, 0), &data);
                 }
                 msg->data = data;
                 break;
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 004bc24872..6e2760b6c2 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -54,7 +54,6 @@ store_new_id(struct device_driver *driver, const char *buf, size_t count)
         if (!dynid)
                 return -ENOMEM;
 
-        INIT_LIST_HEAD(&dynid->node);
         dynid->id.vendor = vendor;
         dynid->id.device = device;
         dynid->id.subvendor = subvendor;
@@ -65,7 +64,7 @@ store_new_id(struct device_driver *driver, const char *buf, size_t count)
                 driver_data : 0UL;
 
         spin_lock(&pdrv->dynids.lock);
-        list_add_tail(&pdrv->dynids.list, &dynid->node);
+        list_add_tail(&dynid->node, &pdrv->dynids.list);
         spin_unlock(&pdrv->dynids.lock);
 
         if (get_driver(&pdrv->driver)) {
@@ -532,8 +531,7 @@ void pci_dev_put(struct pci_dev *dev)
 }
 
 #ifndef CONFIG_HOTPLUG
-int pci_uevent(struct device *dev, char **envp, int num_envp,
-               char *buffer, int buffer_size)
+int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 37c00f6fd8..728b3c863d 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -17,11 +17,16 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
+#include <linux/log2.h>
 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
 unsigned int pci_pm_d3_delay = 10;
 
+#ifdef CONFIG_PCI_DOMAINS
+int pci_domains_supported = 1;
+#endif
+
 #define DEFAULT_CARDBUS_IO_SIZE         (256)
 #define DEFAULT_CARDBUS_MEM_SIZE        (64*1024*1024)
 /* pci=cbmemsize=nnM,cbiosize=nn can override this */
@@ -1454,7 +1459,7 @@ int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc)
         int cap, err = -EINVAL;
         u32 stat, cmd, v, o;
 
-        if (mmrbc < 512 || mmrbc > 4096 || (mmrbc & (mmrbc-1)))
+        if (mmrbc < 512 || mmrbc > 4096 || !is_power_of_2(mmrbc))
                 goto out;
 
         v = ffs(mmrbc) - 10;
@@ -1526,7 +1531,7 @@ int pcie_set_readrq(struct pci_dev *dev, int rq)
         int cap, err = -EINVAL;
         u16 ctl, v;
 
-        if (rq < 128 || rq > 4096 || (rq & (rq-1)))
+        if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
                 goto out;
 
         v = (ffs(rq) - 8) << 12;
@@ -1566,6 +1571,13 @@ int pci_select_bars(struct pci_dev *dev, unsigned long flags)
         return bars;
 }
 
+static void __devinit pci_no_domains(void)
+{
+#ifdef CONFIG_PCI_DOMAINS
+        pci_domains_supported = 0;
+#endif
+}
+
 static int __devinit pci_init(void)
 {
         struct pci_dev *dev = NULL;
@@ -1585,6 +1597,10 @@ static int __devinit pci_setup(char *str)
                 if (*str && (str = pcibios_setup(str)) && *str) {
                         if (!strcmp(str, "nomsi")) {
                                 pci_no_msi();
+                        } else if (!strcmp(str, "noaer")) {
+                                pci_no_aer();
+                        } else if (!strcmp(str, "nodomains")) {
+                                pci_no_domains();
                         } else if (!strncmp(str, "cbiosize=", 9)) {
                                 pci_cardbus_io_size = memparse(str + 9, &str);
                         } else if (!strncmp(str, "cbmemsize=", 10)) {
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 4c36e80f6d..6fda33de84 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -1,7 +1,6 @@
 /* Functions internal to the PCI core code */
 
-extern int pci_uevent(struct device *dev, char **envp, int num_envp,
-                      char *buffer, int buffer_size);
+extern int pci_uevent(struct device *dev, struct kobj_uevent_env *env);
 extern int pci_create_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_remove_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_cleanup_rom(struct pci_dev *dev);
@@ -52,6 +51,12 @@ void pci_restore_msi_state(struct pci_dev *dev);
 static inline void pci_restore_msi_state(struct pci_dev *dev) {}
 #endif
 
+#ifdef CONFIG_PCIEAER
+void pci_no_aer(void);
+#else
+static inline void pci_no_aer(void) { }
+#endif
+
 static inline int pci_no_d1d2(struct pci_dev *dev)
 {
         unsigned int parent_dstates = 0;
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index 0ad92a8ad8..287a931171 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -25,13 +25,4 @@ config HOTPLUG_PCI_PCIE
 
           When in doubt, say N.
 
-config HOTPLUG_PCI_PCIE_POLL_EVENT_MODE
-        bool "Use polling mechanism for hot-plug events (for testing purpose)"
-        depends on HOTPLUG_PCI_PCIE
-        help
-          Say Y here if you want to use the polling mechanism for hot-plug 
-          events for early platform testing.
-           
-          When in doubt, say N.
-
 source "drivers/pci/pcie/aer/Kconfig"
diff --git a/drivers/pci/pcie/aer/aerdrv.c b/drivers/pci/pcie/aer/aerdrv.c
index ad90a01b0d..7a62f7dd90 100644
--- a/drivers/pci/pcie/aer/aerdrv.c
+++ b/drivers/pci/pcie/aer/aerdrv.c
@@ -81,6 +81,13 @@ static struct pcie_port_service_driver aerdriver = {
         .reset_link     = aer_root_reset,
 };
 
+static int pcie_aer_disable;
+
+void pci_no_aer(void)
+{
+        pcie_aer_disable = 1;   /* has priority over 'forceload' */
+}
+
 /**
  * aer_irq - Root Port's ISR
  * @irq: IRQ assigned to Root Port
@@ -327,6 +334,8 @@ static void aer_error_resume(struct pci_dev *dev)
  **/
 static int __init aer_service_init(void)
 {
+        if (pcie_aer_disable)
+                return -ENXIO;
         return pcie_port_service_register(&aerdriver);
 }
 
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 171ca712e5..5db6b6690b 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -276,8 +276,7 @@ static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
                         sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK);
                         if (sz) {
                                 res->flags = (l & IORESOURCE_ROM_ENABLE) |
-                                  IORESOURCE_MEM | IORESOURCE_PREFETCH |
-                                  IORESOURCE_READONLY | IORESOURCE_CACHEABLE;
+                                  IORESOURCE_MEM | IORESOURCE_READONLY;
                                 res->start = l & PCI_ROM_ADDRESS_MASK;
                                 res->end = res->start + (unsigned long) sz;
                         }
@@ -597,7 +596,7 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass
                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 
                 if (!is_cardbus) {
-                        child->bridge_ctl = bctl | PCI_BRIDGE_CTL_NO_ISA;
+                        child->bridge_ctl = bctl;
                         /*
                          * Adjust subordinate busnr in parent buses.
                          * We do this before scanning for children because
@@ -744,22 +743,46 @@ static int pci_setup_device(struct pci_dev * dev)
                  */
                 if (class == PCI_CLASS_STORAGE_IDE) {
                         u8 progif;
+                        struct pci_bus_region region;
+
                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
                         if ((progif & 1) == 0) {
-                                dev->resource[0].start = 0x1F0;
-                                dev->resource[0].end = 0x1F7;
-                                dev->resource[0].flags = LEGACY_IO_RESOURCE;
-                                dev->resource[1].start = 0x3F6;
-                                dev->resource[1].end = 0x3F6;
-                                dev->resource[1].flags = LEGACY_IO_RESOURCE;
+                                struct resource resource = {
+                                        .start = 0x1F0,
+                                        .end = 0x1F7,
+                                        .flags = LEGACY_IO_RESOURCE,
+                                };
+
+                                pcibios_resource_to_bus(dev, &region, &resource);
+                                dev->resource[0].start = region.start;
+                                dev->resource[0].end = region.end;
+                                dev->resource[0].flags = resource.flags;
+                                resource.start = 0x3F6;
+                                resource.end = 0x3F6;
+                                resource.flags = LEGACY_IO_RESOURCE;
+                                pcibios_resource_to_bus(dev, &region, &resource);
+                                dev->resource[1].start = region.start;
+                                dev->resource[1].end = region.end;
+                                dev->resource[1].flags = resource.flags;
                         }
                         if ((progif & 4) == 0) {
-                                dev->resource[2].start = 0x170;
-                                dev->resource[2].end = 0x177;
-                                dev->resource[2].flags = LEGACY_IO_RESOURCE;
-                                dev->resource[3].start = 0x376;
-                                dev->resource[3].end = 0x376;
-                                dev->resource[3].flags = LEGACY_IO_RESOURCE;
+                                struct resource resource = {
+                                        .start = 0x170,
+                                        .end = 0x177,
+                                        .flags = LEGACY_IO_RESOURCE,
+                                };
+
+                                pcibios_resource_to_bus(dev, &region, &resource);
+                                dev->resource[2].start = region.start;
+                                dev->resource[2].end = region.end;
+                                dev->resource[2].flags = resource.flags;
+                                resource.start = 0x376;
+                                resource.end = 0x376;
+                                resource.flags = LEGACY_IO_RESOURCE;
+                                pcibios_resource_to_bus(dev, &region, &resource);
+                                dev->resource[3].start = region.start;
+                                dev->resource[3].end = region.end;
+                                dev->resource[3].flags = resource.flags;
                         }
                 }
                 break;
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index 90adc62d07..716439e25d 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -60,7 +60,7 @@ proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *pp
          */
 
         if (capable(CAP_SYS_ADMIN))
-                size = dev->cfg_size;
+                size = dp->size;
         else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
                 size = 128;
         else
@@ -129,11 +129,11 @@ proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *pp
 static ssize_t
 proc_bus_pci_write(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
 {
-        const struct inode *ino = file->f_path.dentry->d_inode;
+        struct inode *ino = file->f_path.dentry->d_inode;
         const struct proc_dir_entry *dp = PDE(ino);
         struct pci_dev *dev = dp->data;
         int pos = *ppos;
-        int size = dev->cfg_size;
+        int size = dp->size;
         int cnt;
 
         if (pos >= size)
@@ -193,6 +193,7 @@ proc_bus_pci_write(struct file *file, const char __user *buf, size_t nbytes, lof
         }
 
         *ppos = pos;
+        i_size_write(ino, dp->size);
         return nbytes;
 }
 
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 50f2dd9e1b..59d4da2734 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -472,11 +472,9 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_ICH8_3, quirk_
  */
 static void __devinit quirk_vt82c586_acpi(struct pci_dev *dev)
 {
-        u8 rev;
         u32 region;
 
-        pci_read_config_byte(dev, PCI_CLASS_REVISION, &rev);
-        if (rev & 0x10) {
+        if (dev->revision & 0x10) {
                 pci_read_config_dword(dev, 0x48, &region);
                 region &= PCI_BASE_ADDRESS_IO_MASK;
                 quirk_io_region(dev, region, 256, PCI_BRIDGE_RESOURCES, "vt82c586 ACPI");
@@ -629,12 +627,9 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk
  */
 static void __init quirk_amd_8131_mmrbc(struct pci_dev *dev)
 {
-        unsigned char revid;
-
-        pci_read_config_byte(dev, PCI_REVISION_ID, &revid);
-        if (dev->subordinate && revid <= 0x12) {
+        if (dev->subordinate && dev->revision <= 0x12) {
                 printk(KERN_INFO "AMD8131 rev %x detected, disabling PCI-X "
-                                "MMRBC\n", revid);
+                                "MMRBC\n", dev->revision);
                 dev->subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MMRBC;
         }
 }
@@ -930,38 +925,6 @@ static void __init quirk_eisa_bridge(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_82375,      quirk_eisa_bridge );
 
-/*
- * On the MSI-K8T-Neo2Fir Board, the internal Soundcard is disabled
- * when a PCI-Soundcard is added. The BIOS only gives Options
- * "Disabled" and "AUTO". This Quirk Sets the corresponding
- * Register-Value to enable the Soundcard.
- *
- * FIXME: Presently this quirk will run on anything that has an 8237
- * which isn't correct, we need to check DMI tables or something in
- * order to make sure it only runs on the MSI-K8T-Neo2Fir.  Because it
- * runs everywhere at present we suppress the printk output in most
- * irrelevant cases.
- */
-static void k8t_sound_hostbridge(struct pci_dev *dev)
-{
-        unsigned char val;
-
-        pci_read_config_byte(dev, 0x50, &val);
-        if (val == 0xc8) {
-                /* Assume it's probably a MSI-K8T-Neo2Fir */
-                printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, attempting to turn soundcard ON\n");
-                pci_write_config_byte(dev, 0x50, val & (~0x40));
-
-                /* Verify the Change for Status output */
-                pci_read_config_byte(dev, 0x50, &val);
-                if (val & 0x40)
-                        printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard still off\n");
-                else
-                        printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard on\n");
-        }
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237, k8t_sound_hostbridge);
-DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237, k8t_sound_hostbridge);
 
 /*
  * On ASUS P4B boards, the SMBus PCI Device within the ICH2/4 southbridge
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 5e5191ec8d..401e03c920 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -472,7 +472,12 @@ void pci_bus_size_bridges(struct pci_bus *bus)
                 break;
 
         case PCI_CLASS_BRIDGE_PCI:
+                /* don't size subtractive decoding (transparent)
+                 * PCI-to-PCI bridges */
+                if (bus->self->transparent)
+                        break;
                 pci_bridge_check_ranges(bus);
+                /* fall through */
         default:
                 pbus_size_io(bus);
                 /* If the bridge supports prefetchable range, size it
diff --git a/drivers/pci/setup-irq.c b/drivers/pci/setup-irq.c
index 568f187731..05ca2ed9eb 100644
--- a/drivers/pci/setup-irq.c
+++ b/drivers/pci/setup-irq.c
@@ -48,7 +48,7 @@ pdev_fixup_irq(struct pci_dev *dev,
         dev->irq = irq;
 
         pr_debug("PCI: fixup irq: (%s) got %d\n",
-                dev->dev.kobj.name, dev->irq);
+                kobject_name(&dev->dev.kobj), dev->irq);
 
         /* Always tell the device, so the driver knows what is
            the real IRQ to use; the device does not use it. */
diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
index f8b13f0270..a0aca46ce8 100644
--- a/drivers/pcmcia/cs.c
+++ b/drivers/pcmcia/cs.c
@@ -907,18 +907,14 @@ int pcmcia_insert_card(struct pcmcia_socket *skt)
 EXPORT_SYMBOL(pcmcia_insert_card);
 
 
-static int pcmcia_socket_uevent(struct device *dev, char **envp,
-                                int num_envp, char *buffer, int buffer_size)
+static int pcmcia_socket_uevent(struct device *dev,
+                                struct kobj_uevent_env *env)
 {
         struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
-        int i = 0, length = 0;
 
-        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size,
-                           &length, "SOCKET_NO=%u", s->sock))
+        if (add_uevent_var(env, "SOCKET_NO=%u", s->sock))
                 return -ENOMEM;
 
-        envp[i] = NULL;
-
         return 0;
 }
 
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index a99607142f..55baa1f0fc 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -1064,11 +1064,10 @@ static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
 
 #ifdef CONFIG_HOTPLUG
 
-static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
-                             char *buffer, int buffer_size)
+static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct pcmcia_device *p_dev;
-        int i, length = 0;
+        int i;
         u32 hash[4] = { 0, 0, 0, 0};
 
         if (!dev)
@@ -1083,23 +1082,13 @@ static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
                 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
         }
 
-        i = 0;
-
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "SOCKET_NO=%u",
-                           p_dev->socket->sock))
+        if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "DEVICE_NO=%02X",
-                           p_dev->device_no))
+        if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
+        if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
                            "pa%08Xpb%08Xpc%08Xpd%08X",
                            p_dev->has_manf_id ? p_dev->manf_id : 0,
                            p_dev->has_card_id ? p_dev->card_id : 0,
@@ -1112,15 +1101,12 @@ static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
                            hash[3]))
                 return -ENOMEM;
 
-        envp[i] = NULL;
-
         return 0;
 }
 
 #else
 
-static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp,
-                              char *buffer, int buffer_size)
+static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
diff --git a/drivers/pcmcia/pxa2xx_mainstone.c b/drivers/pcmcia/pxa2xx_mainstone.c
index 383107ba4b..f6722ba0dd 100644
--- a/drivers/pcmcia/pxa2xx_mainstone.c
+++ b/drivers/pcmcia/pxa2xx_mainstone.c
@@ -175,7 +175,6 @@ static int __init mst_pcmcia_init(void)
         if (!mst_pcmcia_device)
                 return -ENOMEM;
 
-        mst_pcmcia_device->dev.uevent_suppress = 0;
         mst_pcmcia_device->dev.platform_data = &mst_pcmcia_ops;
 
         ret = platform_device_add(mst_pcmcia_device);
@@ -195,3 +194,4 @@ fs_initcall(mst_pcmcia_init);
 module_exit(mst_pcmcia_exit);
 
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pxa2xx-pcmcia");
diff --git a/drivers/pcmcia/pxa2xx_sharpsl.c b/drivers/pcmcia/pxa2xx_sharpsl.c
index a2daa3f531..d5c33bd78d 100644
--- a/drivers/pcmcia/pxa2xx_sharpsl.c
+++ b/drivers/pcmcia/pxa2xx_sharpsl.c
@@ -261,7 +261,6 @@ static int __init sharpsl_pcmcia_init(void)
         if (!sharpsl_pcmcia_device)
                 return -ENOMEM;
 
-        sharpsl_pcmcia_device->dev.uevent_suppress = 0;
         sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops;
         sharpsl_pcmcia_device->dev.parent = platform_scoop_config->devs[0].dev;
 
@@ -284,3 +283,4 @@ module_exit(sharpsl_pcmcia_exit);
 
 MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pxa2xx-pcmcia");
diff --git a/drivers/power/power_supply.h b/drivers/power/power_supply.h
index a9880d468e..f38ba482be 100644
--- a/drivers/power/power_supply.h
+++ b/drivers/power/power_supply.h
@@ -14,8 +14,7 @@
 
 extern int power_supply_create_attrs(struct power_supply *psy);
 extern void power_supply_remove_attrs(struct power_supply *psy);
-extern int power_supply_uevent(struct device *dev, char **envp, int num_envp,
-                               char *buffer, int buffer_size);
+extern int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env);
 
 #else
 
diff --git a/drivers/power/power_supply_sysfs.c b/drivers/power/power_supply_sysfs.c
index de3155b212..249f61bae6 100644
--- a/drivers/power/power_supply_sysfs.c
+++ b/drivers/power/power_supply_sysfs.c
@@ -195,11 +195,10 @@ static char *kstruprdup(const char *str, gfp_t gfp)
         return ret;
 }
 
-int power_supply_uevent(struct device *dev, char **envp, int num_envp,
-                        char *buffer, int buffer_size)
+int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct power_supply *psy = dev_get_drvdata(dev);
-        int i = 0, length = 0, ret = 0, j;
+        int ret = 0, j;
         char *prop_buf;
         char *attrname;
 
@@ -212,8 +211,7 @@ int power_supply_uevent(struct device *dev, char **envp, int num_envp,
 
         dev_dbg(dev, "POWER_SUPPLY_NAME=%s\n", psy->name);
 
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size,
-                             &length, "POWER_SUPPLY_NAME=%s", psy->name);
+        ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->name);
         if (ret)
                 return ret;
 
@@ -243,9 +241,7 @@ int power_supply_uevent(struct device *dev, char **envp, int num_envp,
 
                 dev_dbg(dev, "Static prop %s=%s\n", attrname, prop_buf);
 
-                ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size,
-                                     &length, "POWER_SUPPLY_%s=%s",
-                                     attrname, prop_buf);
+                ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
                 kfree(attrname);
                 if (ret)
                         goto out;
@@ -282,14 +278,11 @@ int power_supply_uevent(struct device *dev, char **envp, int num_envp,
 
                 dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf);
 
-                ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size,
-                                     &length, "POWER_SUPPLY_%s=%s",
-                                     attrname, prop_buf);
+                ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
                 kfree(attrname);
                 if (ret)
                         goto out;
         }
-        envp[i] = NULL;
 
 out:
         free_page((unsigned long)prop_buf);
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 93ee05eeae..78277a118b 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -1,7 +1,7 @@
 /*
  * SuperH On-Chip RTC Support
  *
- * Copyright (C) 2006  Paul Mundt
+ * Copyright (C) 2006, 2007  Paul Mundt
  * Copyright (C) 2006  Jamie Lenehan
  *
  * Based on the old arch/sh/kernel/cpu/rtc.c by:
@@ -23,16 +23,19 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/io.h>
+#include <asm/rtc.h>
 
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.1.2"
+#define DRV_VERSION     "0.1.3"
 
 #ifdef CONFIG_CPU_SH3
 #define rtc_reg_size            sizeof(u16)
 #define RTC_BIT_INVERTED        0       /* No bug on SH7708, SH7709A */
+#define RTC_DEF_CAPABILITIES    0UL
 #elif defined(CONFIG_CPU_SH4)
 #define rtc_reg_size            sizeof(u32)
 #define RTC_BIT_INVERTED        0x40    /* bug on SH7750, SH7750S */
+#define RTC_DEF_CAPABILITIES    RTC_CAP_4_DIGIT_YEAR
 #endif
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
@@ -80,6 +83,7 @@ struct sh_rtc {
         struct rtc_device *rtc_dev;
         spinlock_t lock;
         int rearm_aie;
+        unsigned long capabilities;     /* See asm-sh/rtc.h for cap bits */
 };
 
 static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
@@ -319,14 +323,14 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 tm->tm_mday     = BCD2BIN(readb(rtc->regbase + RDAYCNT));
                 tm->tm_mon      = BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;
 
-#if defined(CONFIG_CPU_SH4)
-                yr  = readw(rtc->regbase + RYRCNT);
-                yr100 = BCD2BIN(yr >> 8);
-                yr &= 0xff;
-#else
-                yr  = readb(rtc->regbase + RYRCNT);
-                yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
-#endif
+                if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
+                        yr  = readw(rtc->regbase + RYRCNT);
+                        yr100 = BCD2BIN(yr >> 8);
+                        yr &= 0xff;
+                } else {
+                        yr  = readb(rtc->regbase + RYRCNT);
+                        yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
+                }
 
                 tm->tm_year = (yr100 * 100 + BCD2BIN(yr)) - 1900;
 
@@ -375,14 +379,14 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
         writeb(BIN2BCD(tm->tm_mday), rtc->regbase + RDAYCNT);
         writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);
 
-#ifdef CONFIG_CPU_SH3
-        year = tm->tm_year % 100;
-        writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
-#else
-        year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) |
-                BIN2BCD(tm->tm_year % 100);
-        writew(year, rtc->regbase + RYRCNT);
-#endif
+        if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
+                year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) |
+                        BIN2BCD(tm->tm_year % 100);
+                writew(year, rtc->regbase + RYRCNT);
+        } else {
+                year = tm->tm_year % 100;
+                writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
+        }
 
         /* Start RTC */
         tmp = readb(rtc->regbase + RCR2);
@@ -589,6 +593,17 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 goto err_badmap;
         }
 
+        rtc->capabilities = RTC_DEF_CAPABILITIES;
+        if (pdev->dev.platform_data) {
+                struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data;
+
+                /*
+                 * Some CPUs have special capabilities in addition to the
+                 * default set. Add those in here.
+                 */
+                rtc->capabilities |= pinfo->capabilities;
+        }
+
         platform_set_drvdata(pdev, rtc);
 
         return 0;
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index aeda526824..d427daeef5 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -53,6 +53,7 @@
 #include <linux/genhd.h>
 #include <linux/hdreg.h>
 #include <linux/interrupt.h>
+#include <linux/log2.h>
 #include <asm/ccwdev.h>
 #include <linux/workqueue.h>
 #include <asm/debug.h>
@@ -456,7 +457,7 @@ dasd_free_chunk(struct list_head *chunk_list, void *mem)
 static inline int
 dasd_check_blocksize(int bsize)
 {
-        if (bsize < 512 || bsize > 4096 || (bsize & (bsize - 1)) != 0)
+        if (bsize < 512 || bsize > 4096 || !is_power_of_2(bsize))
                 return -EMEDIUMTYPE;
         return 0;
 }
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 0fbacc8b10..f231bc21b1 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -230,7 +230,7 @@ static int xpram_make_request(struct request_queue *q, struct bio *bio)
                 }
         }
         set_bit(BIO_UPTODATE, &bio->bi_flags);
-        bio_end_io(bio, 0);
+        bio_endio(bio, 0);
         return 0;
 fail:
         bio_io_error(bio);
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 6000bdee40..0e1f35c9ed 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -667,6 +667,9 @@ raw3215_probe (struct ccw_device *cdev)
         struct raw3215_info *raw;
         int line;
 
+        /* Console is special. */
+        if (raw3215[0] && (cdev->dev.driver_data == raw3215[0]))
+                return 0;
         raw = kmalloc(sizeof(struct raw3215_info) +
                       RAW3215_INBUF_SIZE, GFP_KERNEL|GFP_DMA);
         if (raw == NULL)
diff --git a/drivers/s390/char/con3270.c b/drivers/s390/char/con3270.c
index fd3479119e..0b040557db 100644
--- a/drivers/s390/char/con3270.c
+++ b/drivers/s390/char/con3270.c
@@ -22,6 +22,7 @@
 #include <asm/ebcdic.h>
 
 #include "raw3270.h"
+#include "tty3270.h"
 #include "ctrlchar.h"
 
 #define CON3270_OUTPUT_BUFFER_SIZE 1024
@@ -507,8 +508,6 @@ con3270_write(struct console *co, const char *str, unsigned int count)
         spin_unlock_irqrestore(&cp->view.lock,flags);
 }
 
-extern struct tty_driver *tty3270_driver;
-
 static struct tty_driver *
 con3270_device(struct console *c, int *index)
 {
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index fa62e69440..25629b92de 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -93,6 +93,7 @@ static volatile enum sclp_mask_state_t {
 #define SCLP_RETRY_INTERVAL     30
 
 static void sclp_process_queue(void);
+static void __sclp_make_read_req(void);
 static int sclp_init_mask(int calculate);
 static int sclp_init(void);
 
@@ -115,7 +116,6 @@ sclp_service_call(sclp_cmdw_t command, void *sccb)
         return 0;
 }
 
-static inline void __sclp_make_read_req(void);
 
 static void
 __sclp_queue_read_req(void)
@@ -318,8 +318,7 @@ sclp_read_cb(struct sclp_req *req, void *data)
 }
 
 /* Prepare read event data request. Called while sclp_lock is locked. */
-static inline void
-__sclp_make_read_req(void)
+static void __sclp_make_read_req(void)
 {
         struct sccb_header *sccb;
 
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
index 9f244c591e..da25f8e241 100644
--- a/drivers/s390/char/tape_3590.c
+++ b/drivers/s390/char/tape_3590.c
@@ -708,16 +708,22 @@ static void tape_3590_med_state_set(struct tape_device *device,
 
         c_info = &TAPE_3590_CRYPT_INFO(device);
 
-        if (sense->masst == MSENSE_UNASSOCIATED) {
+        DBF_EVENT(6, "medium state: %x:%x\n", sense->macst, sense->masst);
+        switch (sense->macst) {
+        case 0x04:
+        case 0x05:
+        case 0x06:
                 tape_med_state_set(device, MS_UNLOADED);
                 TAPE_3590_CRYPT_INFO(device).medium_status = 0;
                 return;
-        }
-        if (sense->masst != MSENSE_ASSOCIATED_MOUNT) {
-                PRINT_ERR("Unknown medium state: %x\n", sense->masst);
+        case 0x08:
+        case 0x09:
+                tape_med_state_set(device, MS_LOADED);
+                break;
+        default:
+                tape_med_state_set(device, MS_UNKNOWN);
                 return;
         }
-        tape_med_state_set(device, MS_LOADED);
         c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
         if (sense->flags & MSENSE_CRYPT_MASK) {
                 PRINT_INFO("Medium is encrypted (%04x)\n", sense->flags);
@@ -835,15 +841,17 @@ tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
                 /* Probably result of halt ssch */
                 return TAPE_IO_PENDING;
         else if (irb->scsw.dstat == 0x85)
-                /* Device Ready -> check medium state */
-                tape_3590_schedule_work(device, TO_MSEN);
-        else if (irb->scsw.dstat & DEV_STAT_ATTENTION)
+                /* Device Ready */
+                DBF_EVENT(3, "unsol.irq! tape ready: %08x\n", device->cdev_id);
+        else if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
                 tape_3590_schedule_work(device, TO_READ_ATTMSG);
-        else {
+        } else {
                 DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
                 PRINT_WARN("Unsolicited IRQ (Device End) caught.\n");
                 tape_dump_sense(device, NULL, irb);
         }
+        /* check medium state */
+        tape_3590_schedule_work(device, TO_MSEN);
         return TAPE_IO_SUCCESS;
 }
 
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index bc33068b9c..70b1980a08 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -25,8 +25,8 @@
 #include <asm/ebcdic.h>
 #include <asm/uaccess.h>
 
-
 #include "raw3270.h"
+#include "tty3270.h"
 #include "keyboard.h"
 
 #define TTY3270_CHAR_BUF_SIZE 256
@@ -1338,8 +1338,11 @@ tty3270_getpar(struct tty3270 *tp, int ix)
 static void
 tty3270_goto_xy(struct tty3270 *tp, int cx, int cy)
 {
-        tp->cx = min_t(int, tp->view.cols - 1, max_t(int, 0, cx));
-        cy = min_t(int, tp->view.rows - 3, max_t(int, 0, cy));
+        int max_cx = max(0, cx);
+        int max_cy = max(0, cy);
+
+        tp->cx = min_t(int, tp->view.cols - 1, max_cx);
+        cy = min_t(int, tp->view.rows - 3, max_cy);
         if (cy != tp->cy) {
                 tty3270_convert_line(tp, tp->cy);
                 tp->cy = cy;
diff --git a/drivers/s390/char/tty3270.h b/drivers/s390/char/tty3270.h
new file mode 100644
index 0000000000..799da57f03
--- /dev/null
+++ b/drivers/s390/char/tty3270.h
@@ -0,0 +1,16 @@
+/*
+ *  drivers/s390/char/tty3270.h
+ *
+ *    Copyright IBM Corp. 2007
+ *
+ */
+
+#ifndef __DRIVERS_S390_CHAR_TTY3270_H
+#define __DRIVERS_S390_CHAR_TTY3270_H
+
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+
+extern struct tty_driver *tty3270_driver;
+
+#endif /* __DRIVERS_S390_CHAR_TTY3270_H */
diff --git a/drivers/s390/char/vmwatchdog.c b/drivers/s390/char/vmwatchdog.c
index 680b9b58b8..6f40facb1c 100644
--- a/drivers/s390/char/vmwatchdog.c
+++ b/drivers/s390/char/vmwatchdog.c
@@ -66,8 +66,8 @@ static int __diag288(enum vmwdt_func func, unsigned int timeout,
                 "0:     la      %0,0\n"
                 "1:\n"
                 EX_TABLE(0b,1b)
-                : "=d" (err) : "d"(__func), "d"(__timeout),
-                  "d"(__cmdp), "d"(__cmdl), "0" (-EINVAL) : "1", "cc");
+                : "+d" (err) : "d"(__func), "d"(__timeout),
+                  "d"(__cmdp), "d"(__cmdl) : "1", "cc");
         return err;
 }
 
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 3712ede167..7073daf779 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -141,15 +141,16 @@ static int memcpy_real(void *dest, unsigned long src, size_t count)
 
         if (count == 0)
                 return 0;
-        flags = __raw_local_irq_stnsm(0xf8); /* switch to real mode */
+        flags = __raw_local_irq_stnsm(0xf8UL); /* switch to real mode */
         asm volatile (
                 "0:     mvcle   %1,%2,0x0\n"
                 "1:     jo      0b\n"
                 "       lhi     %0,0x0\n"
                 "2:\n"
                 EX_TABLE(1b,2b)
-                : "+d" (rc)
-                : "d" (_dest), "d" (_src), "d" (_len1), "d" (_len2)
+                : "+d" (rc), "+d" (_dest), "+d" (_src), "+d" (_len1),
+                  "+d" (_len2), "=m" (*((long*)dest))
+                : "m" (*((long*)src))
                 : "cc", "memory");
         __raw_local_irq_ssm(flags);
 
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index b0a18f5176..5baa517c3b 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -44,8 +44,7 @@ ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
         return 0;
 }
 static int
-ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer,
-                  int buffer_size)
+ccwgroup_uevent (struct device *dev, struct kobj_uevent_env *env)
 {
         /* TODO */
         return 0;
@@ -152,16 +151,24 @@ __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
         return 0;
 }
 
-/*
- * try to add a new ccwgroup device for one driver
- * argc and argv[] are a list of bus_id's of devices
- * belonging to the driver.
+/**
+ * ccwgroup_create() - create and register a ccw group device
+ * @root: parent device for the new device
+ * @creator_id: identifier of creating driver
+ * @cdrv: ccw driver of slave devices
+ * @argc: number of slave devices
+ * @argv: bus ids of slave devices
+ *
+ * Create and register a new ccw group device as a child of @root. Slave
+ * devices are obtained from the list of bus ids given in @argv[] and must all
+ * belong to @cdrv.
+ * Returns:
+ *  %0 on success and an error code on failure.
+ * Context:
+ *  non-atomic
  */
-int
-ccwgroup_create(struct device *root,
-                unsigned int creator_id,
-                struct ccw_driver *cdrv,
-                int argc, char *argv[])
+int ccwgroup_create(struct device *root, unsigned int creator_id,
+                    struct ccw_driver *cdrv, int argc, char *argv[])
 {
         struct ccwgroup_device *gdev;
         int i;
@@ -390,8 +397,13 @@ static struct bus_type ccwgroup_bus_type = {
         .remove = ccwgroup_remove,
 };
 
-int
-ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
+/**
+ * ccwgroup_driver_register() - register a ccw group driver
+ * @cdriver: driver to be registered
+ *
+ * This function is mainly a wrapper around driver_register().
+ */
+int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
 {
         /* register our new driver with the core */
         cdriver->driver.bus = &ccwgroup_bus_type;
@@ -406,8 +418,13 @@ __ccwgroup_match_all(struct device *dev, void *data)
         return 1;
 }
 
-void
-ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
+/**
+ * ccwgroup_driver_unregister() - deregister a ccw group driver
+ * @cdriver: driver to be deregistered
+ *
+ * This function is mainly a wrapper around driver_unregister().
+ */
+void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
 {
         struct device *dev;
 
@@ -427,8 +444,16 @@ ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
         driver_unregister(&cdriver->driver);
 }
 
-int
-ccwgroup_probe_ccwdev(struct ccw_device *cdev)
+/**
+ * ccwgroup_probe_ccwdev() - probe function for slave devices
+ * @cdev: ccw device to be probed
+ *
+ * This is a dummy probe function for ccw devices that are slave devices in
+ * a ccw group device.
+ * Returns:
+ *  always %0
+ */
+int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
 {
         return 0;
 }
@@ -452,8 +477,15 @@ __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
         return NULL;
 }
 
-void
-ccwgroup_remove_ccwdev(struct ccw_device *cdev)
+/**
+ * ccwgroup_remove_ccwdev() - remove function for slave devices
+ * @cdev: ccw device to be removed
+ *
+ * This is a remove function for ccw devices that are slave devices in a ccw
+ * group device. It sets the ccw device offline and also deregisters the
+ * embedding ccw group device.
+ */
+void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
 {
         struct ccwgroup_device *gdev;
 
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 920dd71e64..42c1f4659a 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -14,7 +14,7 @@
 #include <linux/jiffies.h>
 #include <linux/wait.h>
 #include <linux/mutex.h>
-#include <asm/errno.h>
+#include <linux/errno.h>
 #include <asm/chpid.h>
 #include <asm/sclp.h>
 
@@ -55,7 +55,7 @@ static wait_queue_head_t cfg_wait_queue;
 /* Return channel_path struct for given chpid. */
 static inline struct channel_path *chpid_to_chp(struct chp_id chpid)
 {
-        return css[chpid.cssid]->chps[chpid.id];
+        return channel_subsystems[chpid.cssid]->chps[chpid.id];
 }
 
 /* Set vary state for given chpid. */
@@ -86,7 +86,7 @@ u8 chp_get_sch_opm(struct subchannel *sch)
 
         opm = 0;
         chp_id_init(&chpid);
-        for (i=0; i < 8; i++) {
+        for (i = 0; i < 8; i++) {
                 opm <<= 1;
                 chpid.id = sch->schib.pmcw.chpid[i];
                 if (chp_get_status(chpid) != 0)
@@ -118,7 +118,7 @@ static int s390_vary_chpid(struct chp_id chpid, int on)
 
         sprintf(dbf_text, on?"varyon%x.%02x":"varyoff%x.%02x", chpid.cssid,
                 chpid.id);
-        CIO_TRACE_EVENT( 2, dbf_text);
+        CIO_TRACE_EVENT(2, dbf_text);
 
         status = chp_get_status(chpid);
         if (!on && !status) {
@@ -140,9 +140,11 @@ static ssize_t chp_measurement_chars_read(struct kobject *kobj,
                                           char *buf, loff_t off, size_t count)
 {
         struct channel_path *chp;
+        struct device *device;
         unsigned int size;
 
-        chp = to_channelpath(container_of(kobj, struct device, kobj));
+        device = container_of(kobj, struct device, kobj);
+        chp = to_channelpath(device);
         if (!chp->cmg_chars)
                 return 0;
 
@@ -193,9 +195,11 @@ static ssize_t chp_measurement_read(struct kobject *kobj,
 {
         struct channel_path *chp;
         struct channel_subsystem *css;
+        struct device *device;
         unsigned int size;
 
-        chp = to_channelpath(container_of(kobj, struct device, kobj));
+        device = container_of(kobj, struct device, kobj);
+        chp = to_channelpath(device);
         css = to_css(chp->dev.parent);
 
         size = sizeof(struct cmg_entry);
@@ -353,7 +357,7 @@ static ssize_t chp_shared_show(struct device *dev,
 
 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
 
-static struct attribute * chp_attrs[] = {
+static struct attribute *chp_attrs[] = {
         &dev_attr_status.attr,
         &dev_attr_configure.attr,
         &dev_attr_type.attr,
@@ -395,7 +399,7 @@ int chp_new(struct chp_id chpid)
         /* fill in status, etc. */
         chp->chpid = chpid;
         chp->state = 1;
-        chp->dev.parent = &css[chpid.cssid]->device;
+        chp->dev.parent = &channel_subsystems[chpid.cssid]->device;
         chp->dev.release = chp_release;
         snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp%x.%02x", chpid.cssid,
                  chpid.id);
@@ -430,18 +434,18 @@ int chp_new(struct chp_id chpid)
                 device_unregister(&chp->dev);
                 goto out_free;
         }
-        mutex_lock(&css[chpid.cssid]->mutex);
-        if (css[chpid.cssid]->cm_enabled) {
+        mutex_lock(&channel_subsystems[chpid.cssid]->mutex);
+        if (channel_subsystems[chpid.cssid]->cm_enabled) {
                 ret = chp_add_cmg_attr(chp);
                 if (ret) {
                         sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
                         device_unregister(&chp->dev);
-                        mutex_unlock(&css[chpid.cssid]->mutex);
+                        mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
                         goto out_free;
                 }
         }
-        css[chpid.cssid]->chps[chpid.id] = chp;
-        mutex_unlock(&css[chpid.cssid]->mutex);
+        channel_subsystems[chpid.cssid]->chps[chpid.id] = chp;
+        mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
         return ret;
 out_free:
         kfree(chp);
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index f2708d65be..4690534515 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -619,6 +619,11 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
         sch->schib.pmcw.ena = 0;
         if ((sch->lpm & (sch->lpm - 1)) != 0)
                 sch->schib.pmcw.mp = 1; /* multipath mode */
+        /* clean up possible residual cmf stuff */
+        sch->schib.pmcw.mme = 0;
+        sch->schib.pmcw.mbfc = 0;
+        sch->schib.pmcw.mbi = 0;
+        sch->schib.mba = 0;
         return 0;
 out:
         if (!cio_is_console(schid))
diff --git a/drivers/s390/cio/cmf.c b/drivers/s390/cio/cmf.c
index 34a796913b..b960f66843 100644
--- a/drivers/s390/cio/cmf.c
+++ b/drivers/s390/cio/cmf.c
@@ -45,7 +45,8 @@
 #include "ioasm.h"
 #include "chsc.h"
 
-/* parameter to enable cmf during boot, possible uses are:
+/*
+ * parameter to enable cmf during boot, possible uses are:
  *  "s390cmf" -- enable cmf and allocate 2 MB of ram so measuring can be
  *               used on any subchannel
  *  "s390cmf=<num>" -- enable cmf and allocate enough memory to measure
@@ -73,18 +74,20 @@ enum cmb_index {
  * enum cmb_format - types of supported measurement block formats
  *
  * @CMF_BASIC:      traditional channel measurement blocks supported
- *                  by all machines that we run on
+ *                  by all machines that we run on
  * @CMF_EXTENDED:   improved format that was introduced with the z990
- *                  machine
- * @CMF_AUTODETECT: default: use extended format when running on a z990
- *                  or later machine, otherwise fall back to basic format
- **/
+ *                  machine
+ * @CMF_AUTODETECT: default: use extended format when running on a machine
+ *                  supporting extended format, otherwise fall back to
+ *                  basic format
+ */
 enum cmb_format {
         CMF_BASIC,
         CMF_EXTENDED,
         CMF_AUTODETECT = -1,
 };
-/**
+
+/*
  * format - actual format for all measurement blocks
  *
  * The format module parameter can be set to a value of 0 (zero)
@@ -105,20 +108,21 @@ module_param(format, bool, 0444);
  *              either with the help of a special pool or with kmalloc
  * @free:       free memory allocated with @alloc
  * @set:        enable or disable measurement
+ * @read:       read a measurement entry at an index
  * @readall:    read a measurement block in a common format
  * @reset:      clear the data in the associated measurement block and
  *              reset its time stamp
  * @align:      align an allocated block so that the hardware can use it
  */
 struct cmb_operations {
-        int (*alloc)  (struct ccw_device*);
-        void(*free)   (struct ccw_device*);
-        int (*set)    (struct ccw_device*, u32);
-        u64 (*read)   (struct ccw_device*, int);
-        int (*readall)(struct ccw_device*, struct cmbdata *);
-        void (*reset) (struct ccw_device*);
-        void * (*align) (void *);
-
+        int  (*alloc)  (struct ccw_device *);
+        void (*free)   (struct ccw_device *);
+        int  (*set)    (struct ccw_device *, u32);
+        u64  (*read)   (struct ccw_device *, int);
+        int  (*readall)(struct ccw_device *, struct cmbdata *);
+        void (*reset)  (struct ccw_device *);
+        void *(*align) (void *);
+/* private: */
         struct attribute_group *attr_group;
 };
 static struct cmb_operations *cmbops;
@@ -130,9 +134,11 @@ struct cmb_data {
         unsigned long long last_update;  /* when last_block was updated */
 };
 
-/* our user interface is designed in terms of nanoseconds,
+/*
+ * Our user interface is designed in terms of nanoseconds,
  * while the hardware measures total times in its own
- * unit.*/
+ * unit.
+ */
 static inline u64 time_to_nsec(u32 value)
 {
         return ((u64)value) * 128000ull;
@@ -159,12 +165,13 @@ static inline u64 time_to_avg_nsec(u32 value, u32 count)
         return ret;
 }
 
-/* activate or deactivate the channel monitor. When area is NULL,
+/*
+ * Activate or deactivate the channel monitor. When area is NULL,
  * the monitor is deactivated. The channel monitor needs to
  * be active in order to measure subchannels, which also need
- * to be enabled. */
-static inline void
-cmf_activate(void *area, unsigned int onoff)
+ * to be enabled.
+ */
+static inline void cmf_activate(void *area, unsigned int onoff)
 {
         register void * __gpr2 asm("2");
         register long __gpr1 asm("1");
@@ -175,8 +182,8 @@ cmf_activate(void *area, unsigned int onoff)
         asm("schm" : : "d" (__gpr2), "d" (__gpr1) );
 }
 
-static int
-set_schib(struct ccw_device *cdev, u32 mme, int mbfc, unsigned long address)
+static int set_schib(struct ccw_device *cdev, u32 mme, int mbfc,
+                     unsigned long address)
 {
         int ret;
         int retry;
@@ -466,6 +473,7 @@ static void cmf_generic_reset(struct ccw_device *cdev)
  *
  * @mem:        pointer to CMBs (only in basic measurement mode)
  * @list:       contains a linked list of all subchannels
+ * @num_channels: number of channels to be measured
  * @lock:       protect concurrent access to @mem and @list
  */
 struct cmb_area {
@@ -481,28 +489,36 @@ static struct cmb_area cmb_area = {
         .num_channels  = 1024,
 };
 
-
 /* ****** old style CMB handling ********/
 
-/** int maxchannels
- *
+/*
  * Basic channel measurement blocks are allocated in one contiguous
  * block of memory, which can not be moved as long as any channel
  * is active. Therefore, a maximum number of subchannels needs to
  * be defined somewhere. This is a module parameter, defaulting to
  * a resonable value of 1024, or 32 kb of memory.
  * Current kernels don't allow kmalloc with more than 128kb, so the
- * maximum is 4096
+ * maximum is 4096.
  */
 
 module_param_named(maxchannels, cmb_area.num_channels, uint, 0444);
 
 /**
  * struct cmb - basic channel measurement block
+ * @ssch_rsch_count: number of ssch and rsch
+ * @sample_count: number of samples
+ * @device_connect_time: time of device connect
+ * @function_pending_time: time of function pending
+ * @device_disconnect_time: time of device disconnect
+ * @control_unit_queuing_time: time of control unit queuing
+ * @device_active_only_time: time of device active only
+ * @reserved: unused in basic measurement mode
+ *
+ * The measurement block as used by the hardware. The fields are described
+ * further in z/Architecture Principles of Operation, chapter 17.
  *
- * cmb as used by the hardware the fields are described in z/Architecture
- * Principles of Operation, chapter 17.
- * The area to be a contiguous array and may not be reallocated or freed.
+ * The cmb area made up from these blocks must be a contiguous array and may
+ * not be reallocated or freed.
  * Only one cmb area can be present in the system.
  */
 struct cmb {
@@ -516,8 +532,9 @@ struct cmb {
         u32 reserved[2];
 };
 
-/* insert a single device into the cmb_area list
- * called with cmb_area.lock held from alloc_cmb
+/*
+ * Insert a single device into the cmb_area list.
+ * Called with cmb_area.lock held from alloc_cmb.
  */
 static int alloc_cmb_single(struct ccw_device *cdev,
                             struct cmb_data *cmb_data)
@@ -532,9 +549,11 @@ static int alloc_cmb_single(struct ccw_device *cdev,
                 goto out;
         }
 
-        /* find first unused cmb in cmb_area.mem.
-         * this is a little tricky: cmb_area.list
-         * remains sorted by ->cmb->hw_data pointers */
+        /*
+         * Find first unused cmb in cmb_area.mem.
+         * This is a little tricky: cmb_area.list
+         * remains sorted by ->cmb->hw_data pointers.
+         */
         cmb = cmb_area.mem;
         list_for_each_entry(node, &cmb_area.list, cmb_list) {
                 struct cmb_data *data;
@@ -558,8 +577,7 @@ out:
         return ret;
 }
 
-static int
-alloc_cmb (struct ccw_device *cdev)
+static int alloc_cmb(struct ccw_device *cdev)
 {
         int ret;
         struct cmb *mem;
@@ -670,7 +688,7 @@ static int set_cmb(struct ccw_device *cdev, u32 mme)
         return set_schib_wait(cdev, mme, 0, offset);
 }
 
-static u64 read_cmb (struct ccw_device *cdev, int index)
+static u64 read_cmb(struct ccw_device *cdev, int index)
 {
         struct cmb *cmb;
         u32 val;
@@ -720,7 +738,7 @@ out:
         return ret;
 }
 
-static int readall_cmb (struct ccw_device *cdev, struct cmbdata *data)
+static int readall_cmb(struct ccw_device *cdev, struct cmbdata *data)
 {
         struct cmb *cmb;
         struct cmb_data *cmb_data;
@@ -793,14 +811,25 @@ static struct cmb_operations cmbops_basic = {
         .align      = align_cmb,
         .attr_group = &cmf_attr_group,
 };
-
+
 /* ******** extended cmb handling ********/
 
 /**
  * struct cmbe - extended channel measurement block
+ * @ssch_rsch_count: number of ssch and rsch
+ * @sample_count: number of samples
+ * @device_connect_time: time of device connect
+ * @function_pending_time: time of function pending
+ * @device_disconnect_time: time of device disconnect
+ * @control_unit_queuing_time: time of control unit queuing
+ * @device_active_only_time: time of device active only
+ * @device_busy_time: time of device busy
+ * @initial_command_response_time: initial command response time
+ * @reserved: unused
  *
- * cmb as used by the hardware, may be in any 64 bit physical location,
- * the fields are described in z/Architecture Principles of Operation,
+ * The measurement block as used by the hardware. May be in any 64 bit physical
+ * location.
+ * The fields are described further in z/Architecture Principles of Operation,
  * third edition, chapter 17.
  */
 struct cmbe {
@@ -816,10 +845,12 @@ struct cmbe {
         u32 reserved[7];
 };
 
-/* kmalloc only guarantees 8 byte alignment, but we need cmbe
+/*
+ * kmalloc only guarantees 8 byte alignment, but we need cmbe
  * pointers to be naturally aligned. Make sure to allocate
- * enough space for two cmbes */
-static inline struct cmbe* cmbe_align(struct cmbe *c)
+ * enough space for two cmbes.
+ */
+static inline struct cmbe *cmbe_align(struct cmbe *c)
 {
         unsigned long addr;
         addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
@@ -827,7 +858,7 @@ static inline struct cmbe* cmbe_align(struct cmbe *c)
         return (struct cmbe*)addr;
 }
 
-static int alloc_cmbe (struct ccw_device *cdev)
+static int alloc_cmbe(struct ccw_device *cdev)
 {
         struct cmbe *cmbe;
         struct cmb_data *cmb_data;
@@ -873,7 +904,7 @@ out_free:
         return ret;
 }
 
-static void free_cmbe (struct ccw_device *cdev)
+static void free_cmbe(struct ccw_device *cdev)
 {
         struct cmb_data *cmb_data;
 
@@ -912,7 +943,7 @@ static int set_cmbe(struct ccw_device *cdev, u32 mme)
 }
 
 
-static u64 read_cmbe (struct ccw_device *cdev, int index)
+static u64 read_cmbe(struct ccw_device *cdev, int index)
 {
         struct cmbe *cmb;
         struct cmb_data *cmb_data;
@@ -970,7 +1001,7 @@ out:
         return ret;
 }
 
-static int readall_cmbe (struct ccw_device *cdev, struct cmbdata *data)
+static int readall_cmbe(struct ccw_device *cdev, struct cmbdata *data)
 {
         struct cmbe *cmb;
         struct cmb_data *cmb_data;
@@ -1047,17 +1078,16 @@ static struct cmb_operations cmbops_extended = {
         .align      = align_cmbe,
         .attr_group = &cmf_attr_group_ext,
 };
-
 
-static ssize_t
-cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
+static ssize_t cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
 {
         return sprintf(buf, "%lld\n",
                 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
 }
 
-static ssize_t
-cmb_show_avg_sample_interval(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t cmb_show_avg_sample_interval(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
 {
         struct ccw_device *cdev;
         long interval;
@@ -1079,8 +1109,9 @@ cmb_show_avg_sample_interval(struct device *dev, struct device_attribute *attr,
         return sprintf(buf, "%ld\n", interval);
 }
 
-static ssize_t
-cmb_show_avg_utilization(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t cmb_show_avg_utilization(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
         struct cmbdata data;
         u64 utilization;
@@ -1112,14 +1143,16 @@ cmb_show_avg_utilization(struct device *dev, struct device_attribute *attr, char
 }
 
 #define cmf_attr(name) \
-static ssize_t show_ ## name (struct device * dev, struct device_attribute *attr, char * buf) \
-{ return cmb_show_attr((dev), buf, cmb_ ## name); } \
-static DEVICE_ATTR(name, 0444, show_ ## name, NULL);
+static ssize_t show_##name(struct device *dev, \
+                           struct device_attribute *attr, char *buf)    \
+{ return cmb_show_attr((dev), buf, cmb_##name); } \
+static DEVICE_ATTR(name, 0444, show_##name, NULL);
 
 #define cmf_attr_avg(name) \
-static ssize_t show_avg_ ## name (struct device * dev, struct device_attribute *attr, char * buf) \
-{ return cmb_show_attr((dev), buf, cmb_ ## name); } \
-static DEVICE_ATTR(avg_ ## name, 0444, show_avg_ ## name, NULL);
+static ssize_t show_avg_##name(struct device *dev, \
+                               struct device_attribute *attr, char *buf) \
+{ return cmb_show_attr((dev), buf, cmb_##name); } \
+static DEVICE_ATTR(avg_##name, 0444, show_avg_##name, NULL);
 
 cmf_attr(ssch_rsch_count);
 cmf_attr(sample_count);
@@ -1131,7 +1164,8 @@ cmf_attr_avg(device_active_only_time);
 cmf_attr_avg(device_busy_time);
 cmf_attr_avg(initial_command_response_time);
 
-static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval, NULL);
+static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval,
+                   NULL);
 static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
 
 static struct attribute *cmf_attributes[] = {
@@ -1172,12 +1206,16 @@ static struct attribute_group cmf_attr_group_ext = {
         .attrs = cmf_attributes_ext,
 };
 
-static ssize_t cmb_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t cmb_enable_show(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
 {
         return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
 }
 
-static ssize_t cmb_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t c)
+static ssize_t cmb_enable_store(struct device *dev,
+                                struct device_attribute *attr, const char *buf,
+                                size_t c)
 {
         struct ccw_device *cdev;
         int ret;
@@ -1202,9 +1240,16 @@ static ssize_t cmb_enable_store(struct device *dev, struct device_attribute *att
 
 DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
 
-/* enable_cmf/disable_cmf: module interface for cmf (de)activation */
-int
-enable_cmf(struct ccw_device *cdev)
+/**
+ * enable_cmf() - switch on the channel measurement for a specific device
+ *  @cdev:      The ccw device to be enabled
+ *
+ *  Returns %0 for success or a negative error value.
+ *
+ *  Context:
+ *    non-atomic
+ */
+int enable_cmf(struct ccw_device *cdev)
 {
         int ret;
 
@@ -1225,8 +1270,16 @@ enable_cmf(struct ccw_device *cdev)
         return ret;
 }
 
-int
-disable_cmf(struct ccw_device *cdev)
+/**
+ * disable_cmf() - switch off the channel measurement for a specific device
+ *  @cdev:      The ccw device to be disabled
+ *
+ *  Returns %0 for success or a negative error value.
+ *
+ *  Context:
+ *    non-atomic
+ */
+int disable_cmf(struct ccw_device *cdev)
 {
         int ret;
 
@@ -1238,14 +1291,32 @@ disable_cmf(struct ccw_device *cdev)
         return ret;
 }
 
-u64
-cmf_read(struct ccw_device *cdev, int index)
+/**
+ * cmf_read() - read one value from the current channel measurement block
+ * @cdev:       the channel to be read
+ * @index:      the index of the value to be read
+ *
+ * Returns the value read or %0 if the value cannot be read.
+ *
+ *  Context:
+ *    any
+ */
+u64 cmf_read(struct ccw_device *cdev, int index)
 {
         return cmbops->read(cdev, index);
 }
 
-int
-cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
+/**
+ * cmf_readall() - read the current channel measurement block
+ * @cdev:       the channel to be read
+ * @data:       a pointer to a data block that will be filled
+ *
+ * Returns %0 on success, a negative error value otherwise.
+ *
+ *  Context:
+ *    any
+ */
+int cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
 {
         return cmbops->readall(cdev, data);
 }
@@ -1257,15 +1328,16 @@ int cmf_reenable(struct ccw_device *cdev)
         return cmbops->set(cdev, 2);
 }
 
-static int __init
-init_cmf(void)
+static int __init init_cmf(void)
 {
         char *format_string;
         char *detect_string = "parameter";
 
-        /* We cannot really autoprobe this. If the user did not give a parameter,
-           see if we are running on z990 or up, otherwise fall back to basic mode. */
-
+        /*
+         * If the user did not give a parameter, see if we are running on a
+         * machine supporting extended measurement blocks, otherwise fall back
+         * to basic mode.
+         */
         if (format == CMF_AUTODETECT) {
                 if (!css_characteristics_avail ||
                     !css_general_characteristics.ext_mb) {
@@ -1284,7 +1356,7 @@ init_cmf(void)
                 cmbops = &cmbops_basic;
                 break;
         case CMF_EXTENDED:
-                format_string = "extended";
+                format_string = "extended";
                 cmbops = &cmbops_extended;
                 break;
         default:
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 5635e656c1..5d83dd4714 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -13,6 +13,7 @@
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/list.h>
+#include <linux/reboot.h>
 
 #include "css.h"
 #include "cio.h"
@@ -27,7 +28,7 @@ int css_init_done = 0;
 static int need_reprobe = 0;
 static int max_ssid = 0;
 
-struct channel_subsystem *css[__MAX_CSSID + 1];
+struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
 
 int css_characteristics_avail = 0;
 
@@ -177,7 +178,7 @@ static int css_register_subchannel(struct subchannel *sch)
         int ret;
 
         /* Initialize the subchannel structure */
-        sch->dev.parent = &css[0]->device;
+        sch->dev.parent = &channel_subsystems[0]->device;
         sch->dev.bus = &css_bus_type;
         sch->dev.release = &css_subchannel_release;
         sch->dev.groups = subch_attr_groups;
@@ -606,30 +607,55 @@ static int __init setup_css(int nr)
 {
         u32 tod_high;
         int ret;
+        struct channel_subsystem *css;
 
-        memset(css[nr], 0, sizeof(struct channel_subsystem));
-        css[nr]->pseudo_subchannel =
-                kzalloc(sizeof(*css[nr]->pseudo_subchannel), GFP_KERNEL);
-        if (!css[nr]->pseudo_subchannel)
+        css = channel_subsystems[nr];
+        memset(css, 0, sizeof(struct channel_subsystem));
+        css->pseudo_subchannel =
+                kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
+        if (!css->pseudo_subchannel)
                 return -ENOMEM;
-        css[nr]->pseudo_subchannel->dev.parent = &css[nr]->device;
-        css[nr]->pseudo_subchannel->dev.release = css_subchannel_release;
-        sprintf(css[nr]->pseudo_subchannel->dev.bus_id, "defunct");
-        ret = cio_create_sch_lock(css[nr]->pseudo_subchannel);
+        css->pseudo_subchannel->dev.parent = &css->device;
+        css->pseudo_subchannel->dev.release = css_subchannel_release;
+        sprintf(css->pseudo_subchannel->dev.bus_id, "defunct");
+        ret = cio_create_sch_lock(css->pseudo_subchannel);
         if (ret) {
-                kfree(css[nr]->pseudo_subchannel);
+                kfree(css->pseudo_subchannel);
                 return ret;
         }
-        mutex_init(&css[nr]->mutex);
-        css[nr]->valid = 1;
-        css[nr]->cssid = nr;
-        sprintf(css[nr]->device.bus_id, "css%x", nr);
-        css[nr]->device.release = channel_subsystem_release;
+        mutex_init(&css->mutex);
+        css->valid = 1;
+        css->cssid = nr;
+        sprintf(css->device.bus_id, "css%x", nr);
+        css->device.release = channel_subsystem_release;
         tod_high = (u32) (get_clock() >> 32);
-        css_generate_pgid(css[nr], tod_high);
+        css_generate_pgid(css, tod_high);
         return 0;
 }
 
+static int css_reboot_event(struct notifier_block *this,
+                            unsigned long event,
+                            void *ptr)
+{
+        int ret, i;
+
+        ret = NOTIFY_DONE;
+        for (i = 0; i <= __MAX_CSSID; i++) {
+                struct channel_subsystem *css;
+
+                css = channel_subsystems[i];
+                if (css->cm_enabled)
+                        if (chsc_secm(css, 0))
+                                ret = NOTIFY_BAD;
+        }
+
+        return ret;
+}
+
+static struct notifier_block css_reboot_notifier = {
+        .notifier_call = css_reboot_event,
+};
+
 /*
  * Now that the driver core is running, we can setup our channel subsystem.
  * The struct subchannel's are created during probing (except for the
@@ -670,51 +696,63 @@ init_channel_subsystem (void)
         }
         /* Setup css structure. */
         for (i = 0; i <= __MAX_CSSID; i++) {
-                css[i] = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
-                if (!css[i]) {
+                struct channel_subsystem *css;
+
+                css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
+                if (!css) {
                         ret = -ENOMEM;
                         goto out_unregister;
                 }
+                channel_subsystems[i] = css;
                 ret = setup_css(i);
                 if (ret)
                         goto out_free;
-                ret = device_register(&css[i]->device);
+                ret = device_register(&css->device);
                 if (ret)
                         goto out_free_all;
                 if (css_characteristics_avail &&
                     css_chsc_characteristics.secm) {
-                        ret = device_create_file(&css[i]->device,
+                        ret = device_create_file(&css->device,
                                                  &dev_attr_cm_enable);
                         if (ret)
                                 goto out_device;
                 }
-                ret = device_register(&css[i]->pseudo_subchannel->dev);
+                ret = device_register(&css->pseudo_subchannel->dev);
                 if (ret)
                         goto out_file;
         }
+        ret = register_reboot_notifier(&css_reboot_notifier);
+        if (ret)
+                goto out_pseudo;
         css_init_done = 1;
 
         ctl_set_bit(6, 28);
 
         for_each_subchannel(__init_channel_subsystem, NULL);
         return 0;
+out_pseudo:
+        device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev);
 out_file:
-        device_remove_file(&css[i]->device, &dev_attr_cm_enable);
+        device_remove_file(&channel_subsystems[i]->device,
+                           &dev_attr_cm_enable);
 out_device:
-        device_unregister(&css[i]->device);
+        device_unregister(&channel_subsystems[i]->device);
 out_free_all:
-        kfree(css[i]->pseudo_subchannel->lock);
-        kfree(css[i]->pseudo_subchannel);
+        kfree(channel_subsystems[i]->pseudo_subchannel->lock);
+        kfree(channel_subsystems[i]->pseudo_subchannel);
 out_free:
-        kfree(css[i]);
+        kfree(channel_subsystems[i]);
 out_unregister:
         while (i > 0) {
+                struct channel_subsystem *css;
+
                 i--;
-                device_unregister(&css[i]->pseudo_subchannel->dev);
+                css = channel_subsystems[i];
+                device_unregister(&css->pseudo_subchannel->dev);
                 if (css_characteristics_avail && css_chsc_characteristics.secm)
-                        device_remove_file(&css[i]->device,
+                        device_remove_file(&css->device,
                                            &dev_attr_cm_enable);
-                device_unregister(&css[i]->device);
+                device_unregister(&css->device);
         }
 out_bus:
         bus_unregister(&css_bus_type);
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 5d65e83ca6..81215ef324 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -167,7 +167,7 @@ struct channel_subsystem {
 #define to_css(dev) container_of(dev, struct channel_subsystem, device)
 
 extern struct bus_type css_bus_type;
-extern struct channel_subsystem *css[];
+extern struct channel_subsystem *channel_subsystems[];
 
 /* Some helper functions for disconnected state. */
 int device_is_disconnected(struct subchannel *);
@@ -191,6 +191,5 @@ int sch_is_pseudo_sch(struct subchannel *);
 
 extern struct workqueue_struct *slow_path_wq;
 
-int subchannel_add_files (struct device *);
 extern struct attribute_group *subch_attr_groups[];
 #endif
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index e44d92eac8..7ee57f084a 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -21,6 +21,7 @@
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
 #include <asm/param.h>          /* HZ */
+#include <asm/cmb.h>
 
 #include "cio.h"
 #include "cio_debug.h"
@@ -78,49 +79,38 @@ static int snprint_alias(char *buf, size_t size,
 
 /* Set up environment variables for ccw device uevent. Return 0 on success,
  * non-zero otherwise. */
-static int ccw_uevent(struct device *dev, char **envp, int num_envp,
-                      char *buffer, int buffer_size)
+static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
         struct ccw_device_id *id = &(cdev->id);
-        int i = 0;
-        int len = 0;
         int ret;
         char modalias_buf[30];
 
         /* CU_TYPE= */
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                             "CU_TYPE=%04X", id->cu_type);
+        ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type);
         if (ret)
                 return ret;
 
         /* CU_MODEL= */
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                             "CU_MODEL=%02X", id->cu_model);
+        ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model);
         if (ret)
                 return ret;
 
         /* The next two can be zero, that's ok for us */
         /* DEV_TYPE= */
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                             "DEV_TYPE=%04X", id->dev_type);
+        ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type);
         if (ret)
                 return ret;
 
         /* DEV_MODEL= */
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                             "DEV_MODEL=%02X", id->dev_model);
+        ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model);
         if (ret)
                 return ret;
 
         /* MODALIAS=  */
         snprint_alias(modalias_buf, sizeof(modalias_buf), id, "");
-        ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                             "MODALIAS=%s", modalias_buf);
-        if (ret)
-                return ret;
-        envp[i] = NULL;
-        return 0;
+        ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf);
+        return ret;
 }
 
 struct bus_type ccw_bus_type;
@@ -357,8 +347,18 @@ ccw_device_remove_disconnected(struct ccw_device *cdev)
                               cdev->private->dev_id.devno);
 }
 
-int
-ccw_device_set_offline(struct ccw_device *cdev)
+/**
+ * ccw_device_set_offline() - disable a ccw device for I/O
+ * @cdev: target ccw device
+ *
+ * This function calls the driver's set_offline() function for @cdev, if
+ * given, and then disables @cdev.
+ * Returns:
+ *   %0 on success and a negative error value on failure.
+ * Context:
+ *  enabled, ccw device lock not held
+ */
+int ccw_device_set_offline(struct ccw_device *cdev)
 {
         int ret;
 
@@ -396,8 +396,19 @@ ccw_device_set_offline(struct ccw_device *cdev)
         return ret;
 }
 
-int
-ccw_device_set_online(struct ccw_device *cdev)
+/**
+ * ccw_device_set_online() - enable a ccw device for I/O
+ * @cdev: target ccw device
+ *
+ * This function first enables @cdev and then calls the driver's set_online()
+ * function for @cdev, if given. If set_online() returns an error, @cdev is
+ * disabled again.
+ * Returns:
+ *   %0 on success and a negative error value on failure.
+ * Context:
+ *  enabled, ccw device lock not held
+ */
+int ccw_device_set_online(struct ccw_device *cdev)
 {
         int ret;
 
@@ -947,8 +958,7 @@ out:
                 wake_up(&ccw_device_init_wq);
 }
 
-void
-ccw_device_call_sch_unregister(struct work_struct *work)
+static void ccw_device_call_sch_unregister(struct work_struct *work)
 {
         struct ccw_device_private *priv;
         struct ccw_device *cdev;
@@ -1101,6 +1111,7 @@ io_subchannel_probe (struct subchannel *sch)
                  * device, e.g. the console.
                  */
                 cdev = sch->dev.driver_data;
+                cdev->dev.groups = ccwdev_attr_groups;
                 device_initialize(&cdev->dev);
                 ccw_device_register(cdev);
                 /*
@@ -1326,8 +1337,19 @@ __ccwdev_check_busid(struct device *dev, void *id)
 }
 
 
-struct ccw_device *
-get_ccwdev_by_busid(struct ccw_driver *cdrv, const char *bus_id)
+/**
+ * get_ccwdev_by_busid() - obtain device from a bus id
+ * @cdrv: driver the device is owned by
+ * @bus_id: bus id of the device to be searched
+ *
+ * This function searches all devices owned by @cdrv for a device with a bus
+ * id matching @bus_id.
+ * Returns:
+ *  If a match is found, its reference count of the found device is increased
+ *  and it is returned; else %NULL is returned.
+ */
+struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,
+                                       const char *bus_id)
 {
         struct device *dev;
         struct device_driver *drv;
@@ -1401,16 +1423,34 @@ ccw_device_remove (struct device *dev)
         return 0;
 }
 
+static void ccw_device_shutdown(struct device *dev)
+{
+        struct ccw_device *cdev;
+
+        cdev = to_ccwdev(dev);
+        if (cdev->drv && cdev->drv->shutdown)
+                cdev->drv->shutdown(cdev);
+        disable_cmf(cdev);
+}
+
 struct bus_type ccw_bus_type = {
         .name   = "ccw",
         .match  = ccw_bus_match,
         .uevent = ccw_uevent,
         .probe  = ccw_device_probe,
         .remove = ccw_device_remove,
+        .shutdown = ccw_device_shutdown,
 };
 
-int
-ccw_driver_register (struct ccw_driver *cdriver)
+/**
+ * ccw_driver_register() - register a ccw driver
+ * @cdriver: driver to be registered
+ *
+ * This function is mainly a wrapper around driver_register().
+ * Returns:
+ *   %0 on success and a negative error value on failure.
+ */
+int ccw_driver_register(struct ccw_driver *cdriver)
 {
         struct device_driver *drv = &cdriver->driver;
 
@@ -1420,8 +1460,13 @@ ccw_driver_register (struct ccw_driver *cdriver)
         return driver_register(drv);
 }
 
-void
-ccw_driver_unregister (struct ccw_driver *cdriver)
+/**
+ * ccw_driver_unregister() - deregister a ccw driver
+ * @cdriver: driver to be deregistered
+ *
+ * This function is mainly a wrapper around driver_unregister().
+ */
+void ccw_driver_unregister(struct ccw_driver *cdriver)
 {
         driver_unregister(&cdriver->driver);
 }
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index b66338b765..0d40896004 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -80,7 +80,6 @@ void io_subchannel_recog_done(struct ccw_device *cdev);
 int ccw_device_cancel_halt_clear(struct ccw_device *);
 
 void ccw_device_do_unreg_rereg(struct work_struct *);
-void ccw_device_call_sch_unregister(struct work_struct *);
 void ccw_device_move_to_orphanage(struct work_struct *);
 int ccw_device_is_orphan(struct ccw_device *);
 
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index 8633dc5376..8867443b80 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -446,7 +446,8 @@ static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
         if (cdev->private->pgid[last].inf.ps.state1 ==
             SNID_STATE1_RESET)
                 /* No previous pgid found */
-                memcpy(&cdev->private->pgid[0], &css[0]->global_pgid,
+                memcpy(&cdev->private->pgid[0],
+                       &channel_subsystems[0]->global_pgid,
                        sizeof(struct pgid));
         else
                 /* Use existing pgid */
@@ -543,51 +544,6 @@ ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 }
 
 
-static void
-ccw_device_nopath_notify(struct work_struct *work)
-{
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
-        struct subchannel *sch;
-        int ret;
-        unsigned long flags;
-
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
-        spin_lock_irqsave(cdev->ccwlock, flags);
-        sch = to_subchannel(cdev->dev.parent);
-        /* Extra sanity. */
-        if (sch->lpm)
-                goto out_unlock;
-        if (sch->driver && sch->driver->notify) {
-                spin_unlock_irqrestore(cdev->ccwlock, flags);
-                ret = sch->driver->notify(&sch->dev, CIO_NO_PATH);
-                spin_lock_irqsave(cdev->ccwlock, flags);
-        } else
-                ret = 0;
-        if (!ret) {
-                if (get_device(&sch->dev)) {
-                        /* Driver doesn't want to keep device. */
-                        cio_disable_subchannel(sch);
-                        if (get_device(&cdev->dev)) {
-                                PREPARE_WORK(&cdev->private->kick_work,
-                                             ccw_device_call_sch_unregister);
-                                queue_work(ccw_device_work,
-                                           &cdev->private->kick_work);
-                        } else
-                                put_device(&sch->dev);
-                }
-        } else {
-                cio_disable_subchannel(sch);
-                ccw_device_set_timeout(cdev, 0);
-                cdev->private->flags.fake_irb = 0;
-                cdev->private->state = DEV_STATE_DISCONNECTED;
-                wake_up(&cdev->private->wait_q);
-        }
-out_unlock:
-        spin_unlock_irqrestore(cdev->ccwlock, flags);
-}
-
 void
 ccw_device_verify_done(struct ccw_device *cdev, int err)
 {
@@ -631,12 +587,9 @@ ccw_device_verify_done(struct ccw_device *cdev, int err)
         default:
                 /* Reset oper notify indication after verify error. */
                 cdev->private->flags.donotify = 0;
-                if (cdev->online) {
-                        PREPARE_WORK(&cdev->private->kick_work,
-                                     ccw_device_nopath_notify);
-                        queue_work(ccw_device_notify_work,
-                                   &cdev->private->kick_work);
-                } else
+                if (cdev->online)
+                        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
+                else
                         ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 break;
         }
@@ -690,11 +643,7 @@ ccw_device_disband_done(struct ccw_device *cdev, int err)
                 break;
         default:
                 cdev->private->flags.donotify = 0;
-                if (get_device(&cdev->dev)) {
-                        PREPARE_WORK(&cdev->private->kick_work,
-                                     ccw_device_call_sch_unregister);
-                        queue_work(ccw_device_work, &cdev->private->kick_work);
-                }
+                dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 break;
         }
@@ -765,59 +714,16 @@ ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
 }
 
 /*
- * Handle not operational event while offline.
+ * Handle not operational event in non-special state.
  */
-static void
-ccw_device_offline_notoper(struct ccw_device *cdev, enum dev_event dev_event)
+static void ccw_device_generic_notoper(struct ccw_device *cdev,
+                                       enum dev_event dev_event)
 {
         struct subchannel *sch;
 
         cdev->private->state = DEV_STATE_NOT_OPER;
         sch = to_subchannel(cdev->dev.parent);
-        if (get_device(&cdev->dev)) {
-                PREPARE_WORK(&cdev->private->kick_work,
-                             ccw_device_call_sch_unregister);
-                queue_work(ccw_device_work, &cdev->private->kick_work);
-        }
-        wake_up(&cdev->private->wait_q);
-}
-
-/*
- * Handle not operational event while online.
- */
-static void
-ccw_device_online_notoper(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        struct subchannel *sch;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        if (sch->driver->notify) {
-                spin_unlock_irq(cdev->ccwlock);
-                ret = sch->driver->notify(&sch->dev,
-                                          sch->lpm ? CIO_GONE : CIO_NO_PATH);
-                spin_lock_irq(cdev->ccwlock);
-        } else
-                ret = 0;
-        if (ret) {
-                ccw_device_set_timeout(cdev, 0);
-                cdev->private->flags.fake_irb = 0;
-                cdev->private->state = DEV_STATE_DISCONNECTED;
-                wake_up(&cdev->private->wait_q);
-                return;
-        }
-        cdev->private->state = DEV_STATE_NOT_OPER;
-        cio_disable_subchannel(sch);
-        if (sch->schib.scsw.actl != 0) {
-                // FIXME: not-oper indication to device driver ?
-                ccw_device_call_handler(cdev);
-        }
-        if (get_device(&cdev->dev)) {
-                PREPARE_WORK(&cdev->private->kick_work,
-                             ccw_device_call_sch_unregister);
-                queue_work(ccw_device_work, &cdev->private->kick_work);
-        }
-        wake_up(&cdev->private->wait_q);
+        css_schedule_eval(sch->schid);
 }
 
 /*
@@ -915,18 +821,9 @@ ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
                 return;
         }
-        if (ret == -ENODEV) {
-                struct subchannel *sch;
-
-                sch = to_subchannel(cdev->dev.parent);
-                if (!sch->lpm) {
-                        PREPARE_WORK(&cdev->private->kick_work,
-                                     ccw_device_nopath_notify);
-                        queue_work(ccw_device_notify_work,
-                                   &cdev->private->kick_work);
-                } else
-                        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
-        } else if (cdev->handler)
+        if (ret == -ENODEV)
+                dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
+        else if (cdev->handler)
                 cdev->handler(cdev, cdev->private->intparm,
                               ERR_PTR(-ETIMEDOUT));
 }
@@ -1233,7 +1130,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_SENSE_PGID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_pgid_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
@@ -1245,50 +1142,50 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_OFFLINE] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_offline_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_offline_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_VERIFY] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_verify_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
         },
         [DEV_STATE_ONLINE] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_online_timeout,
                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
         },
         [DEV_STATE_W4SENSE] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_w4sense,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
         },
         [DEV_STATE_DISBAND_PGID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_disband_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_BOXED] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_offline_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_stlck_done,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_stlck_done,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         /* states to wait for i/o completion before doing something */
         [DEV_STATE_CLEAR_VERIFY] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_clear_verify,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_TIMEOUT_KILL] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
+                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_killing_timeout,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop, //FIXME
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index 14eba854b1..7fd2dadc32 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -25,6 +25,16 @@
 #include "device.h"
 #include "chp.h"
 
+/**
+ * ccw_device_set_options_mask() - set some options and unset the rest
+ * @cdev: device for which the options are to be set
+ * @flags: options to be set
+ *
+ * All flags specified in @flags are set, all flags not specified in @flags
+ * are cleared.
+ * Returns:
+ *   %0 on success, -%EINVAL on an invalid flag combination.
+ */
 int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
 {
        /*
@@ -40,6 +50,15 @@ int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
         return 0;
 }
 
+/**
+ * ccw_device_set_options() - set some options
+ * @cdev: device for which the options are to be set
+ * @flags: options to be set
+ *
+ * All flags specified in @flags are set, the remainder is left untouched.
+ * Returns:
+ *   %0 on success, -%EINVAL if an invalid flag combination would ensue.
+ */
 int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
 {
        /*
@@ -59,6 +78,13 @@ int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
         return 0;
 }
 
+/**
+ * ccw_device_clear_options() - clear some options
+ * @cdev: device for which the options are to be cleared
+ * @flags: options to be cleared
+ *
+ * All flags specified in @flags are cleared, the remainder is left untouched.
+ */
 void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
 {
         cdev->private->options.fast &= (flags & CCWDEV_EARLY_NOTIFICATION) == 0;
@@ -67,8 +93,22 @@ void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
         cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
 }
 
-int
-ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
+/**
+ * ccw_device_clear() - terminate I/O request processing
+ * @cdev: target ccw device
+ * @intparm: interruption parameter; value is only used if no I/O is
+ *           outstanding, otherwise the intparm associated with the I/O request
+ *           is returned
+ *
+ * ccw_device_clear() calls csch on @cdev's subchannel.
+ * Returns:
+ *  %0 on success,
+ *  -%ENODEV on device not operational,
+ *  -%EINVAL on invalid device state.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
 {
         struct subchannel *sch;
         int ret;
@@ -89,10 +129,33 @@ ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
         return ret;
 }
 
-int
-ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
-                     unsigned long intparm, __u8 lpm, __u8 key,
-                     unsigned long flags)
+/**
+ * ccw_device_start_key() - start a s390 channel program with key
+ * @cdev: target ccw device
+ * @cpa: logical start address of channel program
+ * @intparm: user specific interruption parameter; will be presented back to
+ *           @cdev's interrupt handler. Allows a device driver to associate
+ *           the interrupt with a particular I/O request.
+ * @lpm: defines the channel path to be used for a specific I/O request. A
+ *       value of 0 will make cio use the opm.
+ * @key: storage key to be used for the I/O
+ * @flags: additional flags; defines the action to be performed for I/O
+ *         processing.
+ *
+ * Start a S/390 channel program. When the interrupt arrives, the
+ * IRQ handler is called, either immediately, delayed (dev-end missing,
+ * or sense required) or never (no IRQ handler registered).
+ * Returns:
+ *  %0, if the operation was successful;
+ *  -%EBUSY, if the device is busy, or status pending;
+ *  -%EACCES, if no path specified in @lpm is operational;
+ *  -%ENODEV, if the device is not operational.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
+                         unsigned long intparm, __u8 lpm, __u8 key,
+                         unsigned long flags)
 {
         struct subchannel *sch;
         int ret;
@@ -135,11 +198,38 @@ ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
         return ret;
 }
 
-
-int
-ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
-                             unsigned long intparm, __u8 lpm, __u8 key,
-                             unsigned long flags, int expires)
+/**
+ * ccw_device_start_timeout_key() - start a s390 channel program with timeout and key
+ * @cdev: target ccw device
+ * @cpa: logical start address of channel program
+ * @intparm: user specific interruption parameter; will be presented back to
+ *           @cdev's interrupt handler. Allows a device driver to associate
+ *           the interrupt with a particular I/O request.
+ * @lpm: defines the channel path to be used for a specific I/O request. A
+ *       value of 0 will make cio use the opm.
+ * @key: storage key to be used for the I/O
+ * @flags: additional flags; defines the action to be performed for I/O
+ *         processing.
+ * @expires: timeout value in jiffies
+ *
+ * Start a S/390 channel program. When the interrupt arrives, the
+ * IRQ handler is called, either immediately, delayed (dev-end missing,
+ * or sense required) or never (no IRQ handler registered).
+ * This function notifies the device driver if the channel program has not
+ * completed during the time specified by @expires. If a timeout occurs, the
+ * channel program is terminated via xsch, hsch or csch, and the device's
+ * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
+ * Returns:
+ *  %0, if the operation was successful;
+ *  -%EBUSY, if the device is busy, or status pending;
+ *  -%EACCES, if no path specified in @lpm is operational;
+ *  -%ENODEV, if the device is not operational.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
+                                 unsigned long intparm, __u8 lpm, __u8 key,
+                                 unsigned long flags, int expires)
 {
         int ret;
 
@@ -152,18 +242,67 @@ ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
         return ret;
 }
 
-int
-ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
-                 unsigned long intparm, __u8 lpm, unsigned long flags)
+/**
+ * ccw_device_start() - start a s390 channel program
+ * @cdev: target ccw device
+ * @cpa: logical start address of channel program
+ * @intparm: user specific interruption parameter; will be presented back to
+ *           @cdev's interrupt handler. Allows a device driver to associate
+ *           the interrupt with a particular I/O request.
+ * @lpm: defines the channel path to be used for a specific I/O request. A
+ *       value of 0 will make cio use the opm.
+ * @flags: additional flags; defines the action to be performed for I/O
+ *         processing.
+ *
+ * Start a S/390 channel program. When the interrupt arrives, the
+ * IRQ handler is called, either immediately, delayed (dev-end missing,
+ * or sense required) or never (no IRQ handler registered).
+ * Returns:
+ *  %0, if the operation was successful;
+ *  -%EBUSY, if the device is busy, or status pending;
+ *  -%EACCES, if no path specified in @lpm is operational;
+ *  -%ENODEV, if the device is not operational.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
+                     unsigned long intparm, __u8 lpm, unsigned long flags)
 {
         return ccw_device_start_key(cdev, cpa, intparm, lpm,
                                     PAGE_DEFAULT_KEY, flags);
 }
 
-int
-ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
-                         unsigned long intparm, __u8 lpm, unsigned long flags,
-                         int expires)
+/**
+ * ccw_device_start_timeout() - start a s390 channel program with timeout
+ * @cdev: target ccw device
+ * @cpa: logical start address of channel program
+ * @intparm: user specific interruption parameter; will be presented back to
+ *           @cdev's interrupt handler. Allows a device driver to associate
+ *           the interrupt with a particular I/O request.
+ * @lpm: defines the channel path to be used for a specific I/O request. A
+ *       value of 0 will make cio use the opm.
+ * @flags: additional flags; defines the action to be performed for I/O
+ *         processing.
+ * @expires: timeout value in jiffies
+ *
+ * Start a S/390 channel program. When the interrupt arrives, the
+ * IRQ handler is called, either immediately, delayed (dev-end missing,
+ * or sense required) or never (no IRQ handler registered).
+ * This function notifies the device driver if the channel program has not
+ * completed during the time specified by @expires. If a timeout occurs, the
+ * channel program is terminated via xsch, hsch or csch, and the device's
+ * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
+ * Returns:
+ *  %0, if the operation was successful;
+ *  -%EBUSY, if the device is busy, or status pending;
+ *  -%EACCES, if no path specified in @lpm is operational;
+ *  -%ENODEV, if the device is not operational.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
+                             unsigned long intparm, __u8 lpm,
+                             unsigned long flags, int expires)
 {
         return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
                                             PAGE_DEFAULT_KEY, flags,
@@ -171,8 +310,23 @@ ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
 }
 
 
-int
-ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
+/**
+ * ccw_device_halt() - halt I/O request processing
+ * @cdev: target ccw device
+ * @intparm: interruption parameter; value is only used if no I/O is
+ *           outstanding, otherwise the intparm associated with the I/O request
+ *           is returned
+ *
+ * ccw_device_halt() calls hsch on @cdev's subchannel.
+ * Returns:
+ *  %0 on success,
+ *  -%ENODEV on device not operational,
+ *  -%EINVAL on invalid device state,
+ *  -%EBUSY on device busy or interrupt pending.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
 {
         struct subchannel *sch;
         int ret;
@@ -193,8 +347,20 @@ ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
         return ret;
 }
 
-int
-ccw_device_resume(struct ccw_device *cdev)
+/**
+ * ccw_device_resume() - resume channel program execution
+ * @cdev: target ccw device
+ *
+ * ccw_device_resume() calls rsch on @cdev's subchannel.
+ * Returns:
+ *  %0 on success,
+ *  -%ENODEV on device not operational,
+ *  -%EINVAL on invalid device state,
+ *  -%EBUSY on device busy or interrupt pending.
+ * Context:
+ *  Interrupts disabled, ccw device lock held
+ */
+int ccw_device_resume(struct ccw_device *cdev)
 {
         struct subchannel *sch;
 
@@ -260,11 +426,21 @@ ccw_device_call_handler(struct ccw_device *cdev)
         return 1;
 }
 
-/*
- * Search for CIW command in extended sense data.
+/**
+ * ccw_device_get_ciw() - Search for CIW command in extended sense data.
+ * @cdev: ccw device to inspect
+ * @ct: command type to look for
+ *
+ * During SenseID, command information words (CIWs) describing special
+ * commands available to the device may have been stored in the extended
+ * sense data. This function searches for CIWs of a specified command
+ * type in the extended sense data.
+ * Returns:
+ *  %NULL if no extended sense data has been stored or if no CIW of the
+ *  specified command type could be found,
+ *  else a pointer to the CIW of the specified command type.
  */
-struct ciw *
-ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
+struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
 {
         int ciw_cnt;
 
@@ -276,8 +452,14 @@ ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
         return NULL;
 }
 
-__u8
-ccw_device_get_path_mask(struct ccw_device *cdev)
+/**
+ * ccw_device_get_path_mask() - get currently available paths
+ * @cdev: ccw device to be queried
+ * Returns:
+ *  %0 if no subchannel for the device is available,
+ *  else the mask of currently available paths for the ccw device's subchannel.
+ */
+__u8 ccw_device_get_path_mask(struct ccw_device *cdev)
 {
         struct subchannel *sch;
 
@@ -357,8 +539,7 @@ out_unlock:
         return ret;
 }
 
-void *
-ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
+void *ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
 {
         struct subchannel *sch;
         struct chp_id chpid;
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index d8d479876e..40a3208c7c 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -1024,9 +1024,9 @@ __qdio_outbound_processing(struct qdio_q *q)
 }
 
 static void
-qdio_outbound_processing(struct qdio_q *q)
+qdio_outbound_processing(unsigned long q)
 {
-        __qdio_outbound_processing(q);
+        __qdio_outbound_processing((struct qdio_q *) q);
 }
 
 /************************* INBOUND ROUTINES *******************************/
@@ -1449,9 +1449,10 @@ out:
 }
 
 static void
-tiqdio_inbound_processing(struct qdio_q *q)
+tiqdio_inbound_processing(unsigned long q)
 {
-        __tiqdio_inbound_processing(q, atomic_read(&spare_indicator_usecount));
+        __tiqdio_inbound_processing((struct qdio_q *) q,
+                                    atomic_read(&spare_indicator_usecount));
 }
 
 static void
@@ -1494,9 +1495,9 @@ again:
 }
 
 static void
-qdio_inbound_processing(struct qdio_q *q)
+qdio_inbound_processing(unsigned long q)
 {
-        __qdio_inbound_processing(q);
+        __qdio_inbound_processing((struct qdio_q *) q);
 }
 
 /************************* MAIN ROUTINES *******************************/
@@ -1760,12 +1761,15 @@ qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
                 q->handler=input_handler;
                 q->dev_st_chg_ind=irq_ptr->dev_st_chg_ind;
 
-                q->tasklet.data=(unsigned long)q;
                 /* q->is_thinint_q isn't valid at this time, but
-                 * irq_ptr->is_thinint_irq is */
-                q->tasklet.func=(void(*)(unsigned long))
-                        ((irq_ptr->is_thinint_irq)?&tiqdio_inbound_processing:
-                         &qdio_inbound_processing);
+                 * irq_ptr->is_thinint_irq is
+                 */
+                if (irq_ptr->is_thinint_irq)
+                        tasklet_init(&q->tasklet, tiqdio_inbound_processing,
+                                     (unsigned long) q);
+                else
+                        tasklet_init(&q->tasklet, qdio_inbound_processing,
+                                     (unsigned long) q);
 
                 /* actually this is not used for inbound queues. yet. */
                 atomic_set(&q->busy_siga_counter,0);
@@ -1836,13 +1840,10 @@ qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
                 q->last_move_ftc=0;
                 q->handler=output_handler;
 
-                q->tasklet.data=(unsigned long)q;
-                q->tasklet.func=(void(*)(unsigned long))
-                        &qdio_outbound_processing;
-                q->timer.function=(void(*)(unsigned long))
-                        &qdio_outbound_processing;
-                q->timer.data = (long)q;
-                init_timer(&q->timer);
+                tasklet_init(&q->tasklet, qdio_outbound_processing,
+                             (unsigned long) q);
+                setup_timer(&q->timer, qdio_outbound_processing,
+                            (unsigned long) q);
 
                 atomic_set(&q->busy_siga_counter,0);
                 q->timing.busy_start=0;
@@ -3726,7 +3727,7 @@ qdio_performance_stats_store(struct bus_type *bus, const char *buf, size_t count
 #endif /* CONFIG_64BIT */
                 }
         } else {
-                QDIO_PRINT_WARN("QDIO performance_stats: write 0 or 1 to this file!\n");
+                QDIO_PRINT_ERR("QDIO performance_stats: write 0 or 1 to this file!\n");
                 return -EINVAL;
         }
         return count;
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index 90bd220145..67aaff3e66 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -458,28 +458,22 @@ static int ap_bus_match(struct device *dev, struct device_driver *drv)
  * uevent function for AP devices. It sets up a single environment
  * variable DEV_TYPE which contains the hardware device type.
  */
-static int ap_uevent (struct device *dev, char **envp, int num_envp,
-                       char *buffer, int buffer_size)
+static int ap_uevent (struct device *dev, struct kobj_uevent_env *env)
 {
         struct ap_device *ap_dev = to_ap_dev(dev);
-        int retval = 0, length = 0, i = 0;
+        int retval = 0;
 
         if (!ap_dev)
                 return -ENODEV;
 
         /* Set up DEV_TYPE environment variable. */
-        retval = add_uevent_var(envp, num_envp, &i,
-                                buffer, buffer_size, &length,
-                                "DEV_TYPE=%04X", ap_dev->device_type);
+        retval = add_uevent_var(env, "DEV_TYPE=%04X", ap_dev->device_type);
         if (retval)
                 return retval;
 
         /* Add MODALIAS= */
-        retval = add_uevent_var(envp, num_envp, &i,
-                                buffer, buffer_size, &length,
-                                "MODALIAS=ap:t%02X", ap_dev->device_type);
+        retval = add_uevent_var(env, "MODALIAS=ap:t%02X", ap_dev->device_type);
 
-        envp[i] = NULL;
         return retval;
 }
 
@@ -1231,8 +1225,9 @@ static void ap_reset_domain(void)
 {
         int i;
 
-        for (i = 0; i < AP_DEVICES; i++)
-                ap_reset_queue(AP_MKQID(i, ap_domain_index));
+        if (ap_domain_index != -1)
+                for (i = 0; i < AP_DEVICES; i++)
+                        ap_reset_queue(AP_MKQID(i, ap_domain_index));
 }
 
 static void ap_reset_all(void)
diff --git a/drivers/s390/crypto/zcrypt_mono.c b/drivers/s390/crypto/zcrypt_mono.c
index 2a9349ad68..44253fdd41 100644
--- a/drivers/s390/crypto/zcrypt_mono.c
+++ b/drivers/s390/crypto/zcrypt_mono.c
@@ -45,7 +45,7 @@
 /**
  * The module initialization code.
  */
-int __init zcrypt_init(void)
+static int __init zcrypt_init(void)
 {
         int rc;
 
@@ -86,7 +86,7 @@ out:
 /**
  * The module termination code.
  */
-void __exit zcrypt_exit(void)
+static void __exit zcrypt_exit(void)
 {
         zcrypt_cex2a_exit();
         zcrypt_pcixcc_exit();
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index 64948788d3..70b9ddc8cf 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -277,7 +277,7 @@ static int XCRB_msg_to_type6CPRB_msgX(struct zcrypt_device *zdev,
         };
         struct {
                 struct type6_hdr hdr;
-                struct ica_CPRBX cprbx;
+                struct CPRBX cprbx;
         } __attribute__((packed)) *msg = ap_msg->message;
 
         int rcblen = CEIL4(xcRB->request_control_blk_length);
@@ -432,14 +432,17 @@ static int convert_type86_ica(struct zcrypt_device *zdev,
                 }
                 if (service_rc == 8 && service_rs == 770) {
                         PDEBUG("Invalid key length on PCIXCC/CEX2C\n");
-                        zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
-                        return -EAGAIN;
+                        return -EINVAL;
                 }
                 if (service_rc == 8 && service_rs == 783) {
                         PDEBUG("Extended bitlengths not enabled on PCIXCC/CEX2C\n");
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
                         return -EAGAIN;
                 }
+                if (service_rc == 12 && service_rs == 769) {
+                        PDEBUG("Invalid key on PCIXCC/CEX2C\n");
+                        return -EINVAL;
+                }
                 PRINTK("Unknown service rc/rs (PCIXCC/CEX2C): %d/%d\n",
                        service_rc, service_rs);
                 zdev->online = 0;
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.h b/drivers/s390/crypto/zcrypt_pcixcc.h
index a78ff307fd..8cb7d7a697 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.h
+++ b/drivers/s390/crypto/zcrypt_pcixcc.h
@@ -28,51 +28,6 @@
 #ifndef _ZCRYPT_PCIXCC_H_
 #define _ZCRYPT_PCIXCC_H_
 
-/**
- * CPRBX
- *        Note that all shorts and ints are big-endian.
- *        All pointer fields are 16 bytes long, and mean nothing.
- *
- *        A request CPRB is followed by a request_parameter_block.
- *
- *        The request (or reply) parameter block is organized thus:
- *          function code
- *          VUD block
- *          key block
- */
-struct CPRBX {
-        unsigned short cprb_len;        /* CPRB length        220        */
-        unsigned char  cprb_ver_id;     /* CPRB version id.   0x02       */
-        unsigned char  pad_000[3];      /* Alignment pad bytes           */
-        unsigned char  func_id[2];      /* function id        0x5432     */
-        unsigned char  cprb_flags[4];   /* Flags                         */
-        unsigned int   req_parml;       /* request parameter buffer len  */
-        unsigned int   req_datal;       /* request data buffer           */
-        unsigned int   rpl_msgbl;       /* reply  message block length   */
-        unsigned int   rpld_parml;      /* replied parameter block len   */
-        unsigned int   rpl_datal;       /* reply data block len          */
-        unsigned int   rpld_datal;      /* replied data block len        */
-        unsigned int   req_extbl;       /* request extension block len   */
-        unsigned char  pad_001[4];      /* reserved                      */
-        unsigned int   rpld_extbl;      /* replied extension block len   */
-        unsigned char  req_parmb[16];   /* request parm block 'address'  */
-        unsigned char  req_datab[16];   /* request data block 'address'  */
-        unsigned char  rpl_parmb[16];   /* reply parm block 'address'    */
-        unsigned char  rpl_datab[16];   /* reply data block 'address'    */
-        unsigned char  req_extb[16];    /* request extension block 'addr'*/
-        unsigned char  rpl_extb[16];    /* reply extension block 'addres'*/
-        unsigned short ccp_rtcode;      /* server return code            */
-        unsigned short ccp_rscode;      /* server reason code            */
-        unsigned int   mac_data_len;    /* Mac Data Length               */
-        unsigned char  logon_id[8];     /* Logon Identifier              */
-        unsigned char  mac_value[8];    /* Mac Value                     */
-        unsigned char  mac_content_flgs;/* Mac content flag byte         */
-        unsigned char  pad_002;         /* Alignment                     */
-        unsigned short domain;          /* Domain                        */
-        unsigned char  pad_003[12];     /* Domain masks                  */
-        unsigned char  pad_004[36];     /* reserved                      */
-} __attribute__((packed));
-
 int zcrypt_pcixcc_init(void);
 void zcrypt_pcixcc_exit(void);
 
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index 1c8f71a598..c0d1c0eb32 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -28,7 +28,7 @@ static void zfcp_ccw_remove(struct ccw_device *);
 static int zfcp_ccw_set_online(struct ccw_device *);
 static int zfcp_ccw_set_offline(struct ccw_device *);
 static int zfcp_ccw_notify(struct ccw_device *, int);
-static void zfcp_ccw_shutdown(struct device *);
+static void zfcp_ccw_shutdown(struct ccw_device *);
 
 static struct ccw_device_id zfcp_ccw_device_id[] = {
         {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
@@ -51,9 +51,7 @@ static struct ccw_driver zfcp_ccw_driver = {
         .set_online  = zfcp_ccw_set_online,
         .set_offline = zfcp_ccw_set_offline,
         .notify      = zfcp_ccw_notify,
-        .driver      = {
-                .shutdown = zfcp_ccw_shutdown,
-        },
+        .shutdown    = zfcp_ccw_shutdown,
 };
 
 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
@@ -277,12 +275,12 @@ zfcp_ccw_register(void)
  * Makes sure that QDIO queues are down when the system gets stopped.
  */
 static void
-zfcp_ccw_shutdown(struct device *dev)
+zfcp_ccw_shutdown(struct ccw_device *cdev)
 {
         struct zfcp_adapter *adapter;
 
         down(&zfcp_data.config_sema);
-        adapter = dev_get_drvdata(dev);
+        adapter = dev_get_drvdata(&cdev->dev);
         zfcp_erp_adapter_shutdown(adapter, 0);
         zfcp_erp_wait(adapter);
         up(&zfcp_data.config_sema);
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 5f3212440f..ffa3bf7569 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -19,8 +19,8 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <asm/debug.h>
 #include <linux/ctype.h>
+#include <asm/debug.h>
 #include "zfcp_ext.h"
 
 static u32 dbfsize = 4;
@@ -35,17 +35,17 @@ static int
 zfcp_dbf_stck(char *out_buf, const char *label, unsigned long long stck)
 {
         unsigned long long sec;
-        struct timespec xtime;
+        struct timespec dbftime;
         int len = 0;
 
         stck -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096);
         sec = stck >> 12;
         do_div(sec, 1000000);
-        xtime.tv_sec = sec;
+        dbftime.tv_sec = sec;
         stck -= (sec * 1000000) << 12;
-        xtime.tv_nsec = ((stck * 1000) >> 12);
+        dbftime.tv_nsec = ((stck * 1000) >> 12);
         len += sprintf(out_buf + len, "%-24s%011lu:%06lu\n",
-                       label, xtime.tv_sec, xtime.tv_nsec);
+                       label, dbftime.tv_sec, dbftime.tv_nsec);
 
         return len;
 }
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index d8cd75ce2d..16b4418ab2 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -54,7 +54,7 @@ static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int);
 static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *,
                                          struct zfcp_port *,
                                          struct zfcp_unit *, int);
-static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32);
+static int zfcp_erp_strategy_statechange_detected(atomic_t *, u32);
 static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *,
                                               struct zfcp_port *,
                                               struct zfcp_unit *, int);
@@ -106,8 +106,8 @@ static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *,
 static void zfcp_erp_action_ready(struct zfcp_erp_action *);
 static int  zfcp_erp_action_exists(struct zfcp_erp_action *);
 
-static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
-static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);
+static void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
+static void zfcp_erp_action_to_running(struct zfcp_erp_action *);
 
 static void zfcp_erp_memwait_handler(unsigned long);
 
@@ -952,7 +952,7 @@ zfcp_erp_memwait_handler(unsigned long data)
  *              action gets an appropriate flag and will be processed
  *              accordingly
  */
-void zfcp_erp_timeout_handler(unsigned long data)
+static void zfcp_erp_timeout_handler(unsigned long data)
 {
         struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
         struct zfcp_adapter *adapter = erp_action->adapter;
@@ -1491,7 +1491,7 @@ zfcp_erp_strategy_statechange(int action,
         return retval;
 }
 
-static inline int
+static int
 zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status)
 {
         return
@@ -2001,7 +2001,7 @@ zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
  * returns:     0 - successful setup
  *              !0 - failed setup
  */
-int
+static int
 zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
 {
         int retval;
@@ -3248,8 +3248,7 @@ static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
                 zfcp_erp_action_dismiss(&unit->erp_action);
 }
 
-static inline void
-zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
+static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
 
@@ -3258,8 +3257,7 @@ zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
 }
 
-static inline void
-zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
+static void zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
 
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index f142eafb6f..b41dfb5390 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3829,18 +3829,18 @@ static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
 
 /**
  * ipr_sata_reset - Reset the SATA port
- * @ap:         SATA port to reset
+ * @link:       SATA link to reset
  * @classes:    class of the attached device
  *
- * This function issues a SATA phy reset to the affected ATA port.
+ * This function issues a SATA phy reset to the affected ATA link.
  *
  * Return value:
  *      0 on success / non-zero on failure
  **/
-static int ipr_sata_reset(struct ata_port *ap, unsigned int *classes,
+static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
                                 unsigned long deadline)
 {
-        struct ipr_sata_port *sata_port = ap->private_data;
+        struct ipr_sata_port *sata_port = link->ap->private_data;
         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
         struct ipr_resource_entry *res;
         unsigned long lock_flags = 0;
@@ -4981,22 +4981,22 @@ static void ipr_ata_phy_reset(struct ata_port *ap)
         rc = ipr_device_reset(ioa_cfg, res);
 
         if (rc) {
-                ap->ops->port_disable(ap);
+                ata_port_disable(ap);
                 goto out_unlock;
         }
 
         switch(res->cfgte.proto) {
         case IPR_PROTO_SATA:
         case IPR_PROTO_SAS_STP:
-                ap->device[0].class = ATA_DEV_ATA;
+                ap->link.device[0].class = ATA_DEV_ATA;
                 break;
         case IPR_PROTO_SATA_ATAPI:
         case IPR_PROTO_SAS_STP_ATAPI:
-                ap->device[0].class = ATA_DEV_ATAPI;
+                ap->link.device[0].class = ATA_DEV_ATAPI;
                 break;
         default:
-                ap->device[0].class = ATA_DEV_UNKNOWN;
-                ap->ops->port_disable(ap);
+                ap->link.device[0].class = ATA_DEV_UNKNOWN;
+                ata_port_disable(ap);
                 break;
         };
 
@@ -5262,7 +5262,6 @@ static u8 ipr_ata_check_altstatus(struct ata_port *ap)
 }
 
 static struct ata_port_operations ipr_sata_ops = {
-        .port_disable = ata_port_disable,
         .check_status = ipr_ata_check_status,
         .check_altstatus = ipr_ata_check_altstatus,
         .dev_select = ata_noop_dev_select,
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 5e573efcf0..0829b55c64 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -249,17 +249,17 @@ static void sas_ata_phy_reset(struct ata_port *ap)
         switch (dev->sata_dev.command_set) {
                 case ATA_COMMAND_SET:
                         SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__);
-                        ap->device[0].class = ATA_DEV_ATA;
+                        ap->link.device[0].class = ATA_DEV_ATA;
                         break;
                 case ATAPI_COMMAND_SET:
                         SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__);
-                        ap->device[0].class = ATA_DEV_ATAPI;
+                        ap->link.device[0].class = ATA_DEV_ATAPI;
                         break;
                 default:
                         SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
                                     __FUNCTION__,
                                     dev->sata_dev.command_set);
-                        ap->device[0].class = ATA_DEV_UNKNOWN;
+                        ap->link.device[0].class = ATA_DEV_UNKNOWN;
                         break;
         }
 
@@ -317,7 +317,7 @@ static int sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
                         dev->sata_dev.serror = val;
                         break;
                 case SCR_ACTIVE:
-                        dev->sata_dev.ap->sactive = val;
+                        dev->sata_dev.ap->link.sactive = val;
                         break;
                 default:
                         return -EINVAL;
@@ -342,7 +342,7 @@ static int sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
                         *val = dev->sata_dev.serror;
                         return 0;
                 case SCR_ACTIVE:
-                        *val = dev->sata_dev.ap->sactive;
+                        *val = dev->sata_dev.ap->link.sactive;
                         return 0;
                 default:
                         return -EINVAL;
@@ -350,7 +350,6 @@ static int sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
 }
 
 static struct ata_port_operations sas_sata_ops = {
-        .port_disable           = ata_port_disable,
         .check_status           = sas_ata_check_status,
         .check_altstatus        = sas_ata_check_status,
         .dev_select             = ata_noop_dev_select,
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 34cdce6738..ede9986d34 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -277,16 +277,11 @@ static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
         return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
 }
 
-static int scsi_bus_uevent(struct device *dev, char **envp, int num_envp,
-                           char *buffer, int buffer_size)
+static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
-        int i = 0;
-        int length = 0;
 
-        add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
-                       "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
-        envp[i] = NULL;
+        add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
         return 0;
 }
 
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 053fca41b0..73440e2683 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -4,6 +4,7 @@
  * SuperH on-chip serial module support.  (SCI with no FIFO / with FIFO)
  *
  *  Copyright (C) 2002 - 2006  Paul Mundt
+ *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Jul 2007).
  *
  * based off of the old drivers/char/sh-sci.c by:
  *
@@ -301,6 +302,38 @@ static void sci_init_pins_scif(struct uart_port* port, unsigned int cflag)
         }
         sci_out(port, SCFCR, fcr_val);
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7720)
+static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
+{
+        unsigned int fcr_val = 0;
+        unsigned short data;
+
+        if (cflag & CRTSCTS) {
+                /* enable RTS/CTS */
+                if (port->mapbase == 0xa4430000) { /* SCIF0 */
+                        /* Clear PTCR bit 9-2; enable all scif pins but sck */
+                        data = ctrl_inw(PORT_PTCR);
+                        ctrl_outw((data & 0xfc03), PORT_PTCR);
+                } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
+                        /* Clear PVCR bit 9-2 */
+                        data = ctrl_inw(PORT_PVCR);
+                        ctrl_outw((data & 0xfc03), PORT_PVCR);
+                }
+                fcr_val |= SCFCR_MCE;
+        } else {
+                if (port->mapbase == 0xa4430000) { /* SCIF0 */
+                        /* Clear PTCR bit 5-2; enable only tx and rx  */
+                        data = ctrl_inw(PORT_PTCR);
+                        ctrl_outw((data & 0xffc3), PORT_PTCR);
+                } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
+                        /* Clear PVCR bit 5-2 */
+                        data = ctrl_inw(PORT_PVCR);
+                        ctrl_outw((data & 0xffc3), PORT_PVCR);
+                }
+        }
+        sci_out(port, SCFCR, fcr_val);
+}
+
 #elif defined(CONFIG_CPU_SH3)
 /* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
@@ -1276,7 +1309,7 @@ static int __init sci_console_init(void)
 console_initcall(sci_console_init);
 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
 
-#ifdef CONFIG_SH_KGDB
+#ifdef CONFIG_SH_KGDB_CONSOLE
 /*
  * FIXME: Most of this can go away.. at the moment, we rely on
  * arch/sh/kernel/setup.c to do the command line parsing for kgdb, though
@@ -1334,9 +1367,7 @@ int __init kgdb_console_setup(struct console *co, char *options)
 
         return uart_set_options(port, co, baud, parity, bits, flow);
 }
-#endif /* CONFIG_SH_KGDB */
 
-#ifdef CONFIG_SH_KGDB_CONSOLE
 static struct console kgdb_console = {
         .name           = "ttySC",
         .device         = uart_console_device,
@@ -1432,7 +1463,7 @@ static int __devinit sci_probe(struct platform_device *dev)
 
 #ifdef CONFIG_CPU_FREQ
         cpufreq_register_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
-        dev_info(&dev->dev, "sci: CPU frequency notifier registered\n");
+        dev_info(&dev->dev, "CPU frequency notifier registered\n");
 #endif
 
 #ifdef CONFIG_SH_STANDARD_BIOS
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index cf75466ebf..e89ae29645 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -10,19 +10,19 @@
  *  Modified to support SH7300(SH-Mobile) SCIF. Takashi Kusuda (Jun 2003).
  *  Modified to support H8/300 Series Yoshinori Sato (Feb 2004).
  *  Removed SH7300 support (Jul 2007).
+ *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Aug 2007).
  */
 #include <linux/serial_core.h>
 #include <asm/io.h>
 
-#if defined(__H8300H__) || defined(__H8300S__)
 #include <asm/gpio.h>
+
 #if defined(CONFIG_H83007) || defined(CONFIG_H83068)
 #include <asm/regs306x.h>
 #endif
 #if defined(CONFIG_H8S2678)
 #include <asm/regs267x.h>
 #endif
-#endif
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7706) || \
     defined(CONFIG_CPU_SUBTYPE_SH7707) || \
@@ -46,6 +46,10 @@
  */
 # define SCSCR_INIT(port) (port->mapbase == SCIF2) ? 0xF3 : 0xF0
 # define SCIF_ONLY
+#elif defined(CONFIG_CPU_SUBTYPE_SH7720)
+# define SCSCR_INIT(port)  0x0030 /* TIE=0,RIE=0,TE=1,RE=1 */
+# define SCIF_ONLY
+#define SCIF_ORER    0x0200   /* overrun error bit */
 #elif defined(CONFIG_SH_RTS7751R2D)
 # define SCSPTR2 0xFFE80020 /* 16 bit SCIF */
 # define SCIF_ORER 0x0001   /* overrun error bit */
@@ -217,7 +221,8 @@
 #define SCIF_RDF   0x0002 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
 #define SCIF_DR    0x0001 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7705)
+#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7720)
 #define SCIF_ORER    0x0200
 #define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK | SCIF_ORER)
 #define SCIF_RFDC_MASK 0x007f
@@ -254,7 +259,8 @@
 # define SCxSR_FER(port)                SCIF_FER
 # define SCxSR_PER(port)                SCIF_PER
 # define SCxSR_BRK(port)                SCIF_BRK
-#if defined(CONFIG_CPU_SUBTYPE_SH7705)
+#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7720)
 # define SCxSR_RDxF_CLEAR(port)         (sci_in(port,SCxSR)&0xfffc)
 # define SCxSR_ERROR_CLEAR(port)        (sci_in(port,SCxSR)&0xfd73)
 # define SCxSR_TDxE_CLEAR(port)         (sci_in(port,SCxSR)&0xffdf)
@@ -362,7 +368,8 @@
   CPU_SCIx_FNS(name, sh4_sci_offset, sh4_sci_size, sh4_scif_offset, sh4_scif_size)
 #define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
           CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7720)
 #define SCIF_FNS(name, scif_offset, scif_size) \
   CPU_SCIF_FNS(name, scif_offset, scif_size)
 #else
@@ -388,7 +395,8 @@
   CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
 #endif
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7705)
+#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7720)
 
 SCIF_FNS(SCSMR,  0x00, 16)
 SCIF_FNS(SCBRR,  0x04,  8)
@@ -510,7 +518,15 @@ static inline void set_sh771x_scif_pfc(struct uart_port *port)
                 return;
         }
 }
-
+#elif defined(CONFIG_CPU_SUBTYPE_SH7720)
+static inline int sci_rxd_in(struct uart_port *port)
+{
+        if (port->mapbase == 0xa4430000)
+                return sci_in(port, SCxSR) & 0x0003 ? 1 : 0;
+        else if (port->mapbase == 0xa4438000)
+                return sci_in(port, SCxSR) & 0x0003 ? 1 : 0;
+        return 1;
+}
 #elif defined(CONFIG_CPU_SUBTYPE_SH7750)  || \
       defined(CONFIG_CPU_SUBTYPE_SH7751)  || \
       defined(CONFIG_CPU_SUBTYPE_SH7751R) || \
@@ -653,6 +669,7 @@ static inline int sci_rxd_in(struct uart_port *port)
                 return ctrl_inw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
         if (port->mapbase == 0xffc60000)
                 return ctrl_inw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
+        return 1;
 }
 #endif
 
@@ -691,7 +708,8 @@ static inline int sci_rxd_in(struct uart_port *port)
 #if defined(CONFIG_CPU_SUBTYPE_SH7780) || \
     defined(CONFIG_CPU_SUBTYPE_SH7785)
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(16*bps)-1)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7720)
 #define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(32*bps)-1)
 #elif defined(__H8300H__) || defined(__H8300S__)
 #define SCBRR_VALUE(bps) (((CONFIG_CPU_CLOCK*1000/32)/bps)-1)
diff --git a/drivers/sh/Makefile b/drivers/sh/Makefile
index 8a143894e3..a96f4a8cfe 100644
--- a/drivers/sh/Makefile
+++ b/drivers/sh/Makefile
@@ -2,5 +2,5 @@
 # Makefile for the SuperH specific drivers.
 #
 
-obj-$(CONFIG_SUPERHYWAY) += superhyway/
-
+obj-$(CONFIG_SUPERHYWAY)        += superhyway/
+obj-$(CONFIG_MAPLE)             += maple/
diff --git a/drivers/sh/maple/Makefile b/drivers/sh/maple/Makefile
new file mode 100644
index 0000000000..65dfeeb610
--- /dev/null
+++ b/drivers/sh/maple/Makefile
@@ -0,0 +1,3 @@
+# Makefile for Maple Bus
+
+obj-$(CONFIG_MAPLE) := maple.o
diff --git a/drivers/sh/maple/maple.c b/drivers/sh/maple/maple.c
new file mode 100644
index 0000000000..161d1021b7
--- /dev/null
+++ b/drivers/sh/maple/maple.c
@@ -0,0 +1,735 @@
+/*
+ * Core maple bus functionality
+ *
+ *  Copyright (C) 2007 Adrian McMenamin
+ *
+ * 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
+ * for more details.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/maple.h>
+#include <linux/dma-mapping.h>
+#include <asm/cacheflush.h>
+#include <asm/dma.h>
+#include <asm/io.h>
+#include <asm/mach/dma.h>
+#include <asm/mach/sysasic.h>
+#include <asm/mach/maple.h>
+
+MODULE_AUTHOR("Yaegshi Takeshi, Paul Mundt, M.R. Brown, Adrian McMenamin");
+MODULE_DESCRIPTION("Maple bus driver for Dreamcast");
+MODULE_LICENSE("GPL v2");
+MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
+
+static void maple_dma_handler(struct work_struct *work);
+static void maple_vblank_handler(struct work_struct *work);
+
+static DECLARE_WORK(maple_dma_process, maple_dma_handler);
+static DECLARE_WORK(maple_vblank_process, maple_vblank_handler);
+
+static LIST_HEAD(maple_waitq);
+static LIST_HEAD(maple_sentq);
+
+static DEFINE_MUTEX(maple_list_lock);
+
+static struct maple_driver maple_dummy_driver;
+static struct device maple_bus;
+static int subdevice_map[MAPLE_PORTS];
+static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr;
+static unsigned long maple_pnp_time;
+static int started, scanning, liststatus;
+static struct kmem_cache *maple_queue_cache;
+
+struct maple_device_specify {
+       int port;
+       int unit;
+};
+
+/**
+ *  maple_driver_register - register a device driver
+ *  automatically makes the driver bus a maple bus
+ *  @drv: the driver to be registered
+ */
+int maple_driver_register(struct device_driver *drv)
+{
+       if (!drv)
+               return -EINVAL;
+       drv->bus = &maple_bus_type;
+       return driver_register(drv);
+}
+EXPORT_SYMBOL_GPL(maple_driver_register);
+
+/* set hardware registers to enable next round of dma */
+static void maplebus_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);
+       ctrl_outl(PHYSADDR(maple_sendbuf), MAPLE_DMAADDR);
+       ctrl_outl(1, MAPLE_ENABLE);
+}
+
+/**
+ * maple_getcond_callback - setup handling MAPLE_COMMAND_GETCOND
+ * @dev: device responding
+ * @callback: handler callback
+ * @interval: interval in jiffies between callbacks
+ * @function: the function code for the device
+ */
+void maple_getcond_callback(struct maple_device *dev,
+                           void (*callback) (struct mapleq * mq),
+                           unsigned long interval, unsigned long function)
+{
+       dev->callback = callback;
+       dev->interval = interval;
+       dev->function = cpu_to_be32(function);
+       dev->when = jiffies;
+}
+EXPORT_SYMBOL_GPL(maple_getcond_callback);
+
+static int maple_dma_done(void)
+{
+       return (ctrl_inl(MAPLE_STATE) & 1) == 0;
+}
+
+static void maple_release_device(struct device *dev)
+{
+       if (dev->type) {
+               kfree(dev->type->name);
+               kfree(dev->type);
+       }
+}
+
+/**
+ * maple_add_packet - add a single instruction to the queue
+ * @mq: instruction to add to waiting queue
+ */
+void maple_add_packet(struct mapleq *mq)
+{
+       mutex_lock(&maple_list_lock);
+       list_add(&mq->list, &maple_waitq);
+       mutex_unlock(&maple_list_lock);
+}
+EXPORT_SYMBOL_GPL(maple_add_packet);
+
+static struct mapleq *maple_allocq(struct maple_device *dev)
+{
+       struct mapleq *mq;
+
+       mq = kmalloc(sizeof(*mq), GFP_KERNEL);
+       if (!mq)
+               return NULL;
+
+       mq->dev = dev;
+       mq->recvbufdcsp = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL);
+       mq->recvbuf = (void *) P2SEGADDR(mq->recvbufdcsp);
+       if (!mq->recvbuf) {
+               kfree(mq);
+               return NULL;
+       }
+
+       return mq;
+}
+
+static struct maple_device *maple_alloc_dev(int port, int unit)
+{
+       struct maple_device *dev;
+
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+       if (!dev)
+               return NULL;
+
+       dev->port = port;
+       dev->unit = unit;
+       dev->mq = maple_allocq(dev);
+
+       if (!dev->mq) {
+               kfree(dev);
+               return NULL;
+       }
+
+       return dev;
+}
+
+static void maple_free_dev(struct maple_device *mdev)
+{
+       if (!mdev)
+               return;
+       if (mdev->mq) {
+               kmem_cache_free(maple_queue_cache, mdev->mq->recvbufdcsp);
+               kfree(mdev->mq);
+       }
+       kfree(mdev);
+}
+
+/* process the command queue into a maple command block
+ * terminating command has bit 32 of first long set to 0
+ */
+static void maple_build_block(struct mapleq *mq)
+{
+       int port, unit, from, to, len;
+       unsigned long *lsendbuf = mq->sendbuf;
+
+       port = mq->dev->port & 3;
+       unit = mq->dev->unit;
+       len = mq->length;
+       from = port << 6;
+       to = (port << 6) | (unit > 0 ? (1 << (unit - 1)) & 0x1f : 0x20);
+
+       *maple_lastptr &= 0x7fffffff;
+       maple_lastptr = maple_sendptr;
+
+       *maple_sendptr++ = (port << 16) | len | 0x80000000;
+       *maple_sendptr++ = PHYSADDR(mq->recvbuf);
+       *maple_sendptr++ =
+           mq->command | (to << 8) | (from << 16) | (len << 24);
+
+       while (len-- > 0)
+               *maple_sendptr++ = *lsendbuf++;
+}
+
+/* build up command queue */
+static void maple_send(void)
+{
+       int i;
+       int maple_packets;
+       struct mapleq *mq, *nmq;
+
+       if (!list_empty(&maple_sentq))
+               return;
+       if (list_empty(&maple_waitq) || !maple_dma_done())
+               return;
+       maple_packets = 0;
+       maple_sendptr = maple_lastptr = maple_sendbuf;
+       list_for_each_entry_safe(mq, nmq, &maple_waitq, list) {
+               maple_build_block(mq);
+               list_move(&mq->list, &maple_sentq);
+               if (maple_packets++ > MAPLE_MAXPACKETS)
+                       break;
+       }
+       if (maple_packets > 0) {
+               for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++)
+                       dma_cache_sync(0, maple_sendbuf + i * PAGE_SIZE,
+                                      PAGE_SIZE, DMA_BIDIRECTIONAL);
+       }
+}
+
+static int attach_matching_maple_driver(struct device_driver *driver,
+                                       void *devptr)
+{
+       struct maple_driver *maple_drv;
+       struct maple_device *mdev;
+
+       mdev = devptr;
+       maple_drv = to_maple_driver(driver);
+       if (mdev->devinfo.function & be32_to_cpu(maple_drv->function)) {
+               if (maple_drv->connect(mdev) == 0) {
+                       mdev->driver = maple_drv;
+                       return 1;
+               }
+       }
+       return 0;
+}
+
+static void maple_detach_driver(struct maple_device *mdev)
+{
+       if (!mdev)
+               return;
+       if (mdev->driver) {
+               if (mdev->driver->disconnect)
+                       mdev->driver->disconnect(mdev);
+       }
+       mdev->driver = NULL;
+       if (mdev->registered) {
+               maple_release_device(&mdev->dev);
+               device_unregister(&mdev->dev);
+       }
+       mdev->registered = 0;
+       maple_free_dev(mdev);
+}
+
+/* process initial MAPLE_COMMAND_DEVINFO for each device or port */
+static void maple_attach_driver(struct maple_device *dev)
+{
+       char *p;
+
+       char *recvbuf;
+       unsigned long function;
+       int matched, retval;
+
+       recvbuf = dev->mq->recvbuf;
+       memcpy(&dev->devinfo, recvbuf + 4, sizeof(dev->devinfo));
+       memcpy(dev->product_name, dev->devinfo.product_name, 30);
+       memcpy(dev->product_licence, dev->devinfo.product_licence, 60);
+       dev->product_name[30] = '\0';
+       dev->product_licence[60] = '\0';
+
+       for (p = dev->product_name + 29; dev->product_name <= p; p--)
+               if (*p == ' ')
+                       *p = '\0';
+               else
+                       break;
+
+       for (p = dev->product_licence + 59; dev->product_licence <= p; p--)
+               if (*p == ' ')
+                       *p = '\0';
+               else
+                       break;
+
+       function = be32_to_cpu(dev->devinfo.function);
+
+       if (function > 0x200) {
+               /* Do this silently - as not a real device */
+               function = 0;
+               dev->driver = &maple_dummy_driver;
+               sprintf(dev->dev.bus_id, "%d:0.port", dev->port);
+       } else {
+               printk(KERN_INFO
+                      "Maple bus at (%d, %d): Connected function 0x%lX\n",
+                      dev->port, dev->unit, function);
+
+               matched =
+                   bus_for_each_drv(&maple_bus_type, NULL, dev,
+                                    attach_matching_maple_driver);
+
+               if (matched == 0) {
+                       /* Driver does not exist yet */
+                       printk(KERN_INFO
+                              "No maple driver found for this device\n");
+                       dev->driver = &maple_dummy_driver;
+               }
+
+               sprintf(dev->dev.bus_id, "%d:0%d.%lX", dev->port,
+                       dev->unit, function);
+       }
+       dev->function = function;
+       dev->dev.bus = &maple_bus_type;
+       dev->dev.parent = &maple_bus;
+       dev->dev.release = &maple_release_device;
+       retval = device_register(&dev->dev);
+       if (retval) {
+               printk(KERN_INFO
+                      "Maple bus: Attempt to register device (%x, %x) failed.\n",
+                      dev->port, dev->unit);
+               maple_free_dev(dev);
+       }
+       dev->registered = 1;
+}
+
+/*
+ * if device has been registered for the given
+ * 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)
+{
+       struct maple_device_specify *ds;
+       struct maple_device *mdev;
+
+       ds = portptr;
+       mdev = to_maple_dev(device);
+       if (mdev->port == ds->port && mdev->unit == ds->unit)
+               return 1;
+       return 0;
+}
+
+static int setup_maple_commands(struct device *device, void *ignored)
+{
+       struct maple_device *maple_dev = to_maple_dev(device);
+
+       if ((maple_dev->interval > 0)
+           && time_after(jiffies, maple_dev->when)) {
+               maple_dev->when = jiffies + maple_dev->interval;
+               maple_dev->mq->command = MAPLE_COMMAND_GETCOND;
+               maple_dev->mq->sendbuf = &maple_dev->function;
+               maple_dev->mq->length = 1;
+               maple_add_packet(maple_dev->mq);
+               liststatus++;
+       } else {
+               if (time_after(jiffies, maple_pnp_time)) {
+                       maple_dev->mq->command = MAPLE_COMMAND_DEVINFO;
+                       maple_dev->mq->length = 0;
+                       maple_add_packet(maple_dev->mq);
+                       liststatus++;
+               }
+       }
+
+       return 0;
+}
+
+/* VBLANK bottom half - implemented via workqueue */
+static void maple_vblank_handler(struct work_struct *work)
+{
+       if (!maple_dma_done())
+               return;
+       if (!list_empty(&maple_sentq))
+               return;
+       ctrl_outl(0, MAPLE_ENABLE);
+       liststatus = 0;
+       bus_for_each_dev(&maple_bus_type, NULL, NULL,
+                        setup_maple_commands);
+       if (time_after(jiffies, maple_pnp_time))
+               maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL;
+       if (liststatus && list_empty(&maple_sentq)) {
+               INIT_LIST_HEAD(&maple_sentq);
+               maple_send();
+       }
+       maplebus_dma_reset();
+}
+
+/* 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;
+       struct maple_device *mdev_add;
+       struct maple_device_specify ds;
+
+       for (k = 0; k < 5; k++) {
+               ds.port = mdev->port;
+               ds.unit = k + 1;
+               retval =
+                   bus_for_each_dev(&maple_bus_type, NULL, &ds,
+                                    detach_maple_device);
+               if (retval) {
+                       submask = submask >> 1;
+                       continue;
+               }
+               devcheck = submask & 0x01;
+               if (devcheck) {
+                       mdev_add = maple_alloc_dev(mdev->port, k + 1);
+                       if (!mdev_add)
+                               return;
+                       mdev_add->mq->command = MAPLE_COMMAND_DEVINFO;
+                       mdev_add->mq->length = 0;
+                       maple_add_packet(mdev_add->mq);
+                       scanning = 1;
+               }
+               submask = submask >> 1;
+       }
+}
+
+/* mark a device as removed */
+static void maple_clean_submap(struct maple_device *mdev)
+{
+       int killbit;
+
+       killbit = (mdev->unit > 0 ? (1 << (mdev->unit - 1)) & 0x1f : 0x20);
+       killbit = ~killbit;
+       killbit &= 0xFF;
+       subdevice_map[mdev->port] = subdevice_map[mdev->port] & killbit;
+}
+
+/* handle empty port or hotplug removal */
+static void maple_response_none(struct maple_device *mdev,
+                               struct mapleq *mq)
+{
+       if (mdev->unit != 0) {
+               list_del(&mq->list);
+               maple_clean_submap(mdev);
+               printk(KERN_INFO
+                      "Maple bus device detaching at (%d, %d)\n",
+                      mdev->port, mdev->unit);
+               maple_detach_driver(mdev);
+               return;
+       }
+       if (!started) {
+               printk(KERN_INFO "No maple devices attached to port %d\n",
+                      mdev->port);
+               return;
+       }
+       maple_clean_submap(mdev);
+}
+
+/* preprocess hotplugs or scans */
+static void maple_response_devinfo(struct maple_device *mdev,
+                                  char *recvbuf)
+{
+       char submask;
+       if ((!started) || (scanning == 2)) {
+               maple_attach_driver(mdev);
+               return;
+       }
+       if (mdev->unit == 0) {
+               submask = recvbuf[2] & 0x1F;
+               if (submask ^ subdevice_map[mdev->port]) {
+                       maple_map_subunits(mdev, submask);
+                       subdevice_map[mdev->port] = submask;
+               }
+       }
+}
+
+/* maple dma end bottom half - implemented via workqueue */
+static void maple_dma_handler(struct work_struct *work)
+{
+       struct mapleq *mq, *nmq;
+       struct maple_device *dev;
+       char *recvbuf;
+       enum maple_code code;
+
+       if (!maple_dma_done())
+               return;
+       ctrl_outl(0, MAPLE_ENABLE);
+       if (!list_empty(&maple_sentq)) {
+               list_for_each_entry_safe(mq, nmq, &maple_sentq, list) {
+                       recvbuf = mq->recvbuf;
+                       code = recvbuf[0];
+                       dev = mq->dev;
+                       switch (code) {
+                       case MAPLE_RESPONSE_NONE:
+                               maple_response_none(dev, mq);
+                               break;
+
+                       case MAPLE_RESPONSE_DEVINFO:
+                               maple_response_devinfo(dev, recvbuf);
+                               break;
+
+                       case MAPLE_RESPONSE_DATATRF:
+                               if (dev->callback)
+                                       dev->callback(mq);
+                               break;
+
+                       case MAPLE_RESPONSE_FILEERR:
+                       case MAPLE_RESPONSE_AGAIN:
+                       case MAPLE_RESPONSE_BADCMD:
+                       case MAPLE_RESPONSE_BADFUNC:
+                               printk(KERN_DEBUG
+                                      "Maple non-fatal error 0x%X\n",
+                                      code);
+                               break;
+
+                       case MAPLE_RESPONSE_ALLINFO:
+                               printk(KERN_DEBUG
+                                      "Maple - extended device information not supported\n");
+                               break;
+
+                       case MAPLE_RESPONSE_OK:
+                               break;
+
+                       default:
+                               break;
+                       }
+               }
+               INIT_LIST_HEAD(&maple_sentq);
+               if (scanning == 1) {
+                       maple_send();
+                       scanning = 2;
+               } else
+                       scanning = 0;
+
+               if (started == 0)
+                       started = 1;
+       }
+       maplebus_dma_reset();
+}
+
+static irqreturn_t maplebus_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)
+{
+       schedule_work(&maple_vblank_process);
+       return IRQ_HANDLED;
+}
+
+static struct irqaction maple_dma_irq = {
+       .name = "maple bus DMA handler",
+       .handler = maplebus_dma_interrupt,
+       .flags = IRQF_SHARED,
+};
+
+static struct irqaction maple_vblank_irq = {
+       .name = "maple bus VBLANK handler",
+       .handler = maplebus_vblank_interrupt,
+       .flags = IRQF_SHARED,
+};
+
+static int maple_set_dma_interrupt_handler(void)
+{
+       return setup_irq(HW_EVENT_MAPLE_DMA, &maple_dma_irq);
+}
+
+static int maple_set_vblank_interrupt_handler(void)
+{
+       return setup_irq(HW_EVENT_VSYNC, &maple_vblank_irq);
+}
+
+static int maple_get_dma_buffer(void)
+{
+       maple_sendbuf =
+           (void *) __get_free_pages(GFP_KERNEL | __GFP_ZERO,
+                                     MAPLE_DMA_PAGES);
+       if (!maple_sendbuf)
+               return -ENOMEM;
+       return 0;
+}
+
+static int match_maple_bus_driver(struct device *devptr,
+                                 struct device_driver *drvptr)
+{
+       struct maple_driver *maple_drv;
+       struct maple_device *maple_dev;
+
+       maple_drv = container_of(drvptr, struct maple_driver, drv);
+       maple_dev = container_of(devptr, struct maple_device, dev);
+       /* Trap empty port case */
+       if (maple_dev->devinfo.function == 0xFFFFFFFF)
+               return 0;
+       else if (maple_dev->devinfo.function &
+                be32_to_cpu(maple_drv->function))
+               return 1;
+       return 0;
+}
+
+static int maple_bus_uevent(struct device *dev, char **envp,
+                           int num_envp, char *buffer, int buffer_size)
+{
+       return 0;
+}
+
+static void maple_bus_release(struct device *dev)
+{
+}
+
+static struct maple_driver maple_dummy_driver = {
+       .drv = {
+               .name = "maple_dummy_driver",
+               .bus =  &maple_bus_type,
+       },
+};
+
+struct bus_type maple_bus_type = {
+       .name =         "maple",
+       .match =        match_maple_bus_driver,
+       .uevent =       maple_bus_uevent,
+};
+EXPORT_SYMBOL_GPL(maple_bus_type);
+
+static struct device maple_bus = {
+       .bus_id = "maple",
+       .release = maple_bus_release,
+};
+
+static int __init maple_bus_init(void)
+{
+       int retval, i;
+       struct maple_device *mdev[MAPLE_PORTS];
+       ctrl_outl(0, MAPLE_STATE);
+
+       retval = device_register(&maple_bus);
+       if (retval)
+               goto cleanup;
+
+       retval = bus_register(&maple_bus_type);
+       if (retval)
+               goto cleanup_device;
+
+       retval = driver_register(&maple_dummy_driver.drv);
+
+       if (retval)
+               goto cleanup_bus;
+
+       /* allocate memory for maple bus dma */
+       retval = maple_get_dma_buffer();
+       if (retval) {
+               printk(KERN_INFO
+                      "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
+                      "Maple bus: Failed to grab maple 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");
+               goto cleanup_irq;
+       }
+
+       maple_queue_cache =
+           kmem_cache_create("maple_queue_cache", 0x400, 0,
+                             SLAB_HWCACHE_ALIGN, NULL);
+
+       if (!maple_queue_cache)
+               goto cleanup_bothirqs;
+
+       /* setup maple ports */
+       for (i = 0; i < MAPLE_PORTS; i++) {
+               mdev[i] = maple_alloc_dev(i, 0);
+               if (!mdev[i]) {
+                       while (i-- > 0)
+                               maple_free_dev(mdev[i]);
+                       goto cleanup_cache;
+               }
+               mdev[i]->registered = 0;
+               mdev[i]->mq->command = MAPLE_COMMAND_DEVINFO;
+               mdev[i]->mq->length = 0;
+               maple_attach_driver(mdev[i]);
+               maple_add_packet(mdev[i]->mq);
+               subdevice_map[i] = 0;
+       }
+
+       /* setup maplebus hardware */
+       maplebus_dma_reset();
+
+       /* initial detection */
+       maple_send();
+
+       maple_pnp_time = jiffies;
+
+       printk(KERN_INFO "Maple bus core now registered.\n");
+
+       return 0;
+
+cleanup_cache:
+       kmem_cache_destroy(maple_queue_cache);
+
+cleanup_bothirqs:
+       free_irq(HW_EVENT_VSYNC, 0);
+
+cleanup_irq:
+       free_irq(HW_EVENT_MAPLE_DMA, 0);
+
+cleanup_dma:
+       free_pages((unsigned long) maple_sendbuf, MAPLE_DMA_PAGES);
+
+cleanup_basic:
+       driver_unregister(&maple_dummy_driver.drv);
+
+cleanup_bus:
+       bus_unregister(&maple_bus_type);
+
+cleanup_device:
+       device_unregister(&maple_bus);
+
+cleanup:
+       printk(KERN_INFO "Maple bus registration failed\n");
+       return retval;
+}
+subsys_initcall(maple_bus_init);
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index e84d215979..bcb8dd5fb0 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -67,14 +67,11 @@ static int spi_match_device(struct device *dev, struct device_driver *drv)
         return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
 }
 
-static int spi_uevent(struct device *dev, char **envp, int num_envp,
-                char *buffer, int buffer_size)
+static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         const struct spi_device         *spi = to_spi_device(dev);
 
-        envp[0] = buffer;
-        snprintf(buffer, buffer_size, "MODALIAS=%s", spi->modalias);
-        envp[1] = NULL;
+        add_uevent_var(env, "MODALIAS=%s", spi->modalias);
         return 0;
 }
 
diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
index 74d5182db4..cfd13eb866 100644
--- a/drivers/ssb/main.c
+++ b/drivers/ssb/main.c
@@ -11,6 +11,7 @@
 #include "ssb_private.h"
 
 #include <linux/delay.h>
+#include <linux/io.h>
 #include <linux/ssb/ssb.h>
 #include <linux/ssb/ssb_regs.h>
 #include <linux/dma-mapping.h>
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index ac49b15fa7..516a6400db 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -28,27 +28,7 @@ obj-$(CONFIG_USB_MICROTEK)	+= image/
 
 obj-$(CONFIG_USB_SERIAL)        += serial/
 
-obj-$(CONFIG_USB_ADUTUX)        += misc/
-obj-$(CONFIG_USB_APPLEDISPLAY)  += misc/
-obj-$(CONFIG_USB_AUERSWALD)     += misc/
-obj-$(CONFIG_USB_BERRY_CHARGE)  += misc/
-obj-$(CONFIG_USB_CYPRESS_CY7C63)+= misc/
-obj-$(CONFIG_USB_CYTHERM)       += misc/
-obj-$(CONFIG_USB_EMI26)         += misc/
-obj-$(CONFIG_USB_EMI62)         += misc/
-obj-$(CONFIG_USB_FTDI_ELAN)     += misc/
-obj-$(CONFIG_USB_IDMOUSE)       += misc/
-obj-$(CONFIG_USB_LCD)           += misc/
-obj-$(CONFIG_USB_LD)            += misc/
-obj-$(CONFIG_USB_LED)           += misc/
-obj-$(CONFIG_USB_LEGOTOWER)     += misc/
-obj-$(CONFIG_USB_PHIDGETSERVO)  += misc/
-obj-$(CONFIG_USB_RIO500)        += misc/
-obj-$(CONFIG_USB_SISUSBVGA)     += misc/
-obj-$(CONFIG_USB_TEST)          += misc/
-obj-$(CONFIG_USB_TRANCEVIBRATOR)+= misc/
-obj-$(CONFIG_USB_USS720)        += misc/
-obj-$(CONFIG_USB_IOWARRIOR)     += misc/
+obj-$(CONFIG_USB)               += misc/
 
 obj-$(CONFIG_USB_ATM)           += atm/
 obj-$(CONFIG_USB_SPEEDTOUCH)    += atm/
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index a73e714288..a51eeedc18 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -482,7 +482,9 @@ static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
         int rbuflen = ((rsize - 1) / stride + 1) * CMD_PACKET_SIZE;
 
         if (wbuflen > PAGE_SIZE || rbuflen > PAGE_SIZE) {
-                dbg("too big transfer requested");
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "requested transfer size too large (%d, %d)\n",
+                                wbuflen, rbuflen);
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -493,8 +495,9 @@ static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
         init_completion(&instance->rcv_done);
         ret = usb_submit_urb(instance->rcv_urb, GFP_KERNEL);
         if (ret < 0) {
-                dbg("submitting read urb for cm %#x failed", cm);
-                ret = ret;
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "submit of read urb for cm %#x failed (%d)\n",
+                                cm, ret);
                 goto fail;
         }
 
@@ -510,27 +513,29 @@ static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
         init_completion(&instance->snd_done);
         ret = usb_submit_urb(instance->snd_urb, GFP_KERNEL);
         if (ret < 0) {
-                dbg("submitting write urb for cm %#x failed", cm);
-                ret = ret;
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "submit of write urb for cm %#x failed (%d)\n",
+                                cm, ret);
                 goto fail;
         }
 
         ret = cxacru_start_wait_urb(instance->snd_urb, &instance->snd_done, NULL);
         if (ret < 0) {
-                dbg("sending cm %#x failed", cm);
-                ret = ret;
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "send of cm %#x failed (%d)\n", cm, ret);
                 goto fail;
         }
 
         ret = cxacru_start_wait_urb(instance->rcv_urb, &instance->rcv_done, &actlen);
         if (ret < 0) {
-                dbg("receiving cm %#x failed", cm);
-                ret = ret;
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "receive of cm %#x failed (%d)\n", cm, ret);
                 goto fail;
         }
         if (actlen % CMD_PACKET_SIZE || !actlen) {
-                dbg("response is not a positive multiple of %d: %#x",
-                                CMD_PACKET_SIZE, actlen);
+                if (printk_ratelimit())
+                        usb_err(instance->usbatm, "invalid response length to cm %#x: %d\n",
+                                cm, actlen);
                 ret = -EIO;
                 goto fail;
         }
@@ -538,12 +543,16 @@ static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
         /* check the return status and copy the data to the output buffer, if needed */
         for (offb = offd = 0; offd < rsize && offb < actlen; offb += CMD_PACKET_SIZE) {
                 if (rbuf[offb] != cm) {
-                        dbg("wrong cm %#x in response", rbuf[offb]);
+                        if (printk_ratelimit())
+                                usb_err(instance->usbatm, "wrong cm %#x in response to cm %#x\n",
+                                        rbuf[offb], cm);
                         ret = -EIO;
                         goto fail;
                 }
                 if (rbuf[offb + 1] != CM_STATUS_SUCCESS) {
-                        dbg("response failed: %#x", rbuf[offb + 1]);
+                        if (printk_ratelimit())
+                                usb_err(instance->usbatm, "response to cm %#x failed: %#x\n",
+                                        cm, rbuf[offb + 1]);
                         ret = -EIO;
                         goto fail;
                 }
@@ -582,14 +591,18 @@ static int cxacru_cm_get_array(struct cxacru_data *instance, enum cxacru_cm_requ
         for (offb = 0; offb < len; ) {
                 int l = le32_to_cpu(buf[offb++]);
                 if (l > stride || l > (len - offb) / 2) {
-                        dbg("wrong data length %#x in response", l);
+                        if (printk_ratelimit())
+                                usb_err(instance->usbatm, "invalid data length from cm %#x: %d\n",
+                                        cm, l);
                         ret = -EIO;
                         goto cleanup;
                 }
                 while (l--) {
                         offd = le32_to_cpu(buf[offb++]);
                         if (offd >= size) {
-                                dbg("wrong index %#x in response", offd);
+                                if (printk_ratelimit())
+                                        usb_err(instance->usbatm, "wrong index #%x in response to cm #%x\n",
+                                                offd, cm);
                                 ret = -EIO;
                                 goto cleanup;
                         }
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index eb0615abff..8b132c4a50 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -251,7 +251,6 @@ static int speedtch_upload_firmware(struct speedtch_instance_data *instance,
 {
         unsigned char *buffer;
         struct usbatm_data *usbatm = instance->usbatm;
-        struct usb_interface *intf;
         struct usb_device *usb_dev = usbatm->usb_dev;
         int actual_length;
         int ret = 0;
@@ -265,7 +264,7 @@ static int speedtch_upload_firmware(struct speedtch_instance_data *instance,
                 goto out;
         }
 
-        if (!(intf = usb_ifnum_to_if(usb_dev, 2))) {
+        if (!usb_ifnum_to_if(usb_dev, 2)) {
                 ret = -ENODEV;
                 usb_dbg(usbatm, "%s: interface not found!\n", __func__);
                 goto out_free;
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 29807d048b..389c5b164e 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -2,7 +2,8 @@
  * Copyright (c) 2003, 2004
  *      Damien Bergamini <damien.bergamini@free.fr>. All rights reserved.
  *
- * Copyright (c) 2005 Matthieu Castet <castet.matthieu@free.fr>
+ * Copyright (c) 2005-2007 Matthieu Castet <castet.matthieu@free.fr>
+ * Copyright (c) 2005-2007 Stanislaw Gruszka <stf_xl@wp.pl>
  *
  * This software is available to you under a choice of one of two
  * licenses. You may choose to be licensed under the terms of the GNU
@@ -107,18 +108,51 @@
 #define uea_info(usb_dev, format,args...) \
         dev_info(&(usb_dev)->dev ,"[ueagle-atm] " format, ##args)
 
-struct uea_cmvs {
+struct intr_pkt;
+
+/* cmv's from firmware */
+struct uea_cmvs_v1 {
         u32 address;
         u16 offset;
         u32 data;
 } __attribute__ ((packed));
 
+struct uea_cmvs_v2 {
+        u32 group;
+        u32 address;
+        u32 offset;
+        u32 data;
+} __attribute__ ((packed));
+
+/* information about currently processed cmv */
+struct cmv_dsc_e1 {
+        u8 function;
+        u16 idx;
+        u32 address;
+        u16 offset;
+};
+
+struct cmv_dsc_e4 {
+        u16 function;
+        u16 offset;
+        u16 address;
+        u16 group;
+};
+
+union cmv_dsc {
+        struct cmv_dsc_e1 e1;
+        struct cmv_dsc_e4 e4;
+};
+
 struct uea_softc {
         struct usb_device *usb_dev;
         struct usbatm_data *usbatm;
 
         int modem_index;
         unsigned int driver_info;
+        int annex;
+#define ANNEXA 0
+#define ANNEXB 1
 
         int booting;
         int reset;
@@ -127,20 +161,23 @@ struct uea_softc {
 
         struct task_struct *kthread;
         u32 data;
-        wait_queue_head_t cmv_ack_wait;
+        u32 data1;
+
         int cmv_ack;
+        union cmv_dsc cmv_dsc;
 
         struct work_struct task;
+        struct workqueue_struct *work_q;
         u16 pageno;
         u16 ovl;
 
         const struct firmware *dsp_firm;
         struct urb *urb_int;
 
-        u8 cmv_function;
-        u16 cmv_idx;
-        u32 cmv_address;
-        u16 cmv_offset;
+        void (*dispatch_cmv) (struct uea_softc *, struct intr_pkt *);
+        void (*schedule_load_page) (struct uea_softc *, struct intr_pkt *);
+        int (*stat) (struct uea_softc *);
+        int (*send_cmvs) (struct uea_softc *);
 
         /* keep in sync with eaglectl */
         struct uea_stats {
@@ -174,10 +211,34 @@ struct uea_softc {
 #define ELSA_PID_PSTFIRM        0x3350
 #define ELSA_PID_PREFIRM        0x3351
 
+#define ELSA_PID_A_PREFIRM      0x3352
+#define ELSA_PID_A_PSTFIRM      0x3353
+#define ELSA_PID_B_PREFIRM      0x3362
+#define ELSA_PID_B_PSTFIRM      0x3363
+
 /*
- * Sagem USB IDs
+ * Devolo IDs : pots if (pid & 0x10)
  */
-#define EAGLE_VID               0x1110
+#define DEVOLO_VID                      0x1039
+#define DEVOLO_EAGLE_I_A_PID_PSTFIRM    0x2110
+#define DEVOLO_EAGLE_I_A_PID_PREFIRM    0x2111
+
+#define DEVOLO_EAGLE_I_B_PID_PSTFIRM    0x2100
+#define DEVOLO_EAGLE_I_B_PID_PREFIRM    0x2101
+
+#define DEVOLO_EAGLE_II_A_PID_PSTFIRM   0x2130
+#define DEVOLO_EAGLE_II_A_PID_PREFIRM   0x2131
+
+#define DEVOLO_EAGLE_II_B_PID_PSTFIRM   0x2120
+#define DEVOLO_EAGLE_II_B_PID_PREFIRM   0x2121
+
+/*
+ * Reference design USB IDs
+ */
+#define ANALOG_VID              0x1110
+#define ADI930_PID_PREFIRM      0x9001
+#define ADI930_PID_PSTFIRM      0x9000
+
 #define EAGLE_I_PID_PREFIRM     0x9010  /* Eagle I */
 #define EAGLE_I_PID_PSTFIRM     0x900F  /* Eagle I */
 
@@ -187,12 +248,12 @@ struct uea_softc {
 #define EAGLE_II_PID_PREFIRM    0x9022  /* Eagle II */
 #define EAGLE_II_PID_PSTFIRM    0x9021  /* Eagle II */
 
-/*
- *  Eagle III Pid
- */
 #define EAGLE_III_PID_PREFIRM   0x9032  /* Eagle III */
 #define EAGLE_III_PID_PSTFIRM   0x9031  /* Eagle III */
 
+#define EAGLE_IV_PID_PREFIRM    0x9042  /* Eagle IV */
+#define EAGLE_IV_PID_PSTFIRM    0x9041  /* Eagle IV */
+
 /*
  * USR USB IDs
  */
@@ -208,11 +269,15 @@ struct uea_softc {
 
 #define PREFIRM 0
 #define PSTFIRM (1<<7)
+#define AUTO_ANNEX_A (1<<8)
+#define AUTO_ANNEX_B (1<<9)
+
 enum {
         ADI930 = 0,
         EAGLE_I,
         EAGLE_II,
-        EAGLE_III
+        EAGLE_III,
+        EAGLE_IV
 };
 
 /* macros for both struct usb_device_id and struct uea_softc */
@@ -221,15 +286,18 @@ enum {
 #define UEA_CHIP_VERSION(x) \
         ((x)->driver_info & 0xf)
 
-#define IS_ISDN(usb_dev) \
-        (le16_to_cpu((usb_dev)->descriptor.bcdDevice) & 0x80)
+#define IS_ISDN(x) \
+        ((x)->annex & ANNEXB)
 
 #define INS_TO_USBDEV(ins) ins->usb_dev
 
 #define GET_STATUS(data) \
         ((data >> 8) & 0xf)
+
 #define IS_OPERATIONAL(sc) \
-        (GET_STATUS(sc->stats.phy.state) == 2)
+        ((UEA_CHIP_VERSION(sc) != EAGLE_IV) ? \
+        (GET_STATUS(sc->stats.phy.state) == 2) : \
+        (sc->stats.phy.state == 7))
 
 /*
  * Set of macros to handle unaligned data in the firmware blob.
@@ -259,7 +327,8 @@ enum {
 #define UEA_INTR_PIPE           0x04
 #define UEA_ISO_DATA_PIPE       0x08
 
-#define UEA_SET_BLOCK           0x0001
+#define UEA_E1_SET_BLOCK        0x0001
+#define UEA_E4_SET_BLOCK        0x002c
 #define UEA_SET_MODE            0x0003
 #define UEA_SET_2183_DATA       0x0004
 #define UEA_SET_TIMEOUT         0x0011
@@ -275,71 +344,179 @@ enum {
 #define UEA_MPTX_MAILBOX        (0x3fd6 | 0x4000)
 #define UEA_MPRX_MAILBOX        (0x3fdf | 0x4000)
 
-/* structure describing a block within a DSP page */
-struct block_info {
+/* block information in eagle4 dsp firmware  */
+struct block_index {
+        __le32 PageOffset;
+        __le32 NotLastBlock;
+        __le32 dummy;
+        __le32 PageSize;
+        __le32 PageAddress;
+        __le16 dummy1;
+        __le16 PageNumber;
+} __attribute__ ((packed));
+
+#define E4_IS_BOOT_PAGE(PageSize) ((le32_to_cpu(PageSize)) & 0x80000000)
+#define E4_PAGE_BYTES(PageSize) ((le32_to_cpu(PageSize) & 0x7fffffff) * 4)
+
+#define E4_L1_STRING_HEADER 0x10
+#define E4_MAX_PAGE_NUMBER 0x58
+#define E4_NO_SWAPPAGE_HEADERS 0x31
+
+/* l1_code is eagle4 dsp firmware format */
+struct l1_code {
+        u8 string_header[E4_L1_STRING_HEADER];
+        u8 page_number_to_block_index[E4_MAX_PAGE_NUMBER];
+        struct block_index page_header[E4_NO_SWAPPAGE_HEADERS];
+        u8 code [0];
+} __attribute__ ((packed));
+
+/* structures describing a block within a DSP page */
+struct block_info_e1 {
         __le16 wHdr;
-#define UEA_BIHDR 0xabcd
         __le16 wAddress;
         __le16 wSize;
         __le16 wOvlOffset;
         __le16 wOvl;            /* overlay */
         __le16 wLast;
 } __attribute__ ((packed));
-#define BLOCK_INFO_SIZE 12
+#define E1_BLOCK_INFO_SIZE 12
+
+struct block_info_e4 {
+        __be16 wHdr;
+        __u8 bBootPage;
+        __u8 bPageNumber;
+        __be32 dwSize;
+        __be32 dwAddress;
+        __be16 wReserved;
+} __attribute__ ((packed));
+#define E4_BLOCK_INFO_SIZE 14
 
-/* structure representing a CMV (Configuration and Management Variable) */
-struct cmv {
-        __le16 wPreamble;
-#define PREAMBLE 0x535c
-        __u8 bDirection;
-#define MODEMTOHOST 0x01
-#define HOSTTOMODEM 0x10
-        __u8 bFunction;
-#define FUNCTION_TYPE(f)    ((f) >> 4)
-#define MEMACCESS       0x1
-#define ADSLDIRECTIVE   0x7
+#define UEA_BIHDR 0xabcd
+#define UEA_RESERVED 0xffff
+
+/* constants describing cmv type */
+#define E1_PREAMBLE 0x535c
+#define E1_MODEMTOHOST 0x01
+#define E1_HOSTTOMODEM 0x10
+
+#define E1_MEMACCESS 0x1
+#define E1_ADSLDIRECTIVE 0x7
+#define E1_FUNCTION_TYPE(f) ((f) >> 4)
+#define E1_FUNCTION_SUBTYPE(f) ((f) & 0x0f)
+
+#define E4_MEMACCESS 0
+#define E4_ADSLDIRECTIVE 0xf
+#define E4_FUNCTION_TYPE(f) ((f) >> 8)
+#define E4_FUNCTION_SIZE(f) ((f) & 0x0f)
+#define E4_FUNCTION_SUBTYPE(f) (((f) >> 4) & 0x0f)
 
-#define FUNCTION_SUBTYPE(f) ((f) & 0x0f)
 /* for MEMACCESS */
-#define REQUESTREAD     0x0
-#define REQUESTWRITE    0x1
-#define REPLYREAD       0x2
-#define REPLYWRITE      0x3
+#define E1_REQUESTREAD  0x0
+#define E1_REQUESTWRITE 0x1
+#define E1_REPLYREAD    0x2
+#define E1_REPLYWRITE   0x3
+
+#define E4_REQUESTREAD  0x0
+#define E4_REQUESTWRITE 0x4
+#define E4_REPLYREAD    (E4_REQUESTREAD | 1)
+#define E4_REPLYWRITE   (E4_REQUESTWRITE | 1)
+
 /* for ADSLDIRECTIVE */
-#define KERNELREADY     0x0
-#define MODEMREADY      0x1
+#define E1_KERNELREADY 0x0
+#define E1_MODEMREADY  0x1
 
-#define MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf))
-        __le16 wIndex;
-        __le32 dwSymbolicAddress;
-#define MAKESA(a, b, c, d)                                              \
+#define E4_KERNELREADY 0x0
+#define E4_MODEMREADY  0x1
+
+#define E1_MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf))
+#define E4_MAKEFUNCTION(t, st, s) (((t) & 0xf) << 8 | ((st) & 0xf) << 4 | ((s) & 0xf))
+
+#define E1_MAKESA(a, b, c, d)                                           \
         (((c) & 0xff) << 24 |                                           \
          ((d) & 0xff) << 16 |                                           \
          ((a) & 0xff) << 8  |                                           \
          ((b) & 0xff))
-#define GETSA1(a) ((a >> 8) & 0xff)
-#define GETSA2(a) (a & 0xff)
-#define GETSA3(a) ((a >> 24) & 0xff)
-#define GETSA4(a) ((a >> 16) & 0xff)
-
-#define SA_CNTL MAKESA('C', 'N', 'T', 'L')
-#define SA_DIAG MAKESA('D', 'I', 'A', 'G')
-#define SA_INFO MAKESA('I', 'N', 'F', 'O')
-#define SA_OPTN MAKESA('O', 'P', 'T', 'N')
-#define SA_RATE MAKESA('R', 'A', 'T', 'E')
-#define SA_STAT MAKESA('S', 'T', 'A', 'T')
+
+#define E1_GETSA1(a) ((a >> 8) & 0xff)
+#define E1_GETSA2(a) (a & 0xff)
+#define E1_GETSA3(a) ((a >> 24) & 0xff)
+#define E1_GETSA4(a) ((a >> 16) & 0xff)
+
+#define E1_SA_CNTL E1_MAKESA('C', 'N', 'T', 'L')
+#define E1_SA_DIAG E1_MAKESA('D', 'I', 'A', 'G')
+#define E1_SA_INFO E1_MAKESA('I', 'N', 'F', 'O')
+#define E1_SA_OPTN E1_MAKESA('O', 'P', 'T', 'N')
+#define E1_SA_RATE E1_MAKESA('R', 'A', 'T', 'E')
+#define E1_SA_STAT E1_MAKESA('S', 'T', 'A', 'T')
+
+#define E4_SA_CNTL 1
+#define E4_SA_STAT 2
+#define E4_SA_INFO 3
+#define E4_SA_TEST 4
+#define E4_SA_OPTN 5
+#define E4_SA_RATE 6
+#define E4_SA_DIAG 7
+#define E4_SA_CNFG 8
+
+/* structures representing a CMV (Configuration and Management Variable) */
+struct cmv_e1 {
+        __le16 wPreamble;
+        __u8 bDirection;
+        __u8 bFunction;
+        __le16 wIndex;
+        __le32 dwSymbolicAddress;
         __le16 wOffsetAddress;
         __le32 dwData;
 } __attribute__ ((packed));
-#define CMV_SIZE 16
 
-/* structure representing swap information */
-struct swap_info {
+struct cmv_e4 {
+        __be16 wGroup;
+        __be16 wFunction;
+        __be16 wOffset;
+        __be16 wAddress;
+        __be32 dwData [6];
+} __attribute__ ((packed));
+
+/* structures representing swap information */
+struct swap_info_e1 {
         __u8 bSwapPageNo;
         __u8 bOvl;              /* overlay */
 } __attribute__ ((packed));
 
-/* structure representing interrupt data */
+struct swap_info_e4 {
+        __u8 bSwapPageNo;
+} __attribute__ ((packed));
+
+/* structures representing interrupt data */
+#define e1_bSwapPageNo  u.e1.s1.swapinfo.bSwapPageNo
+#define e1_bOvl         u.e1.s1.swapinfo.bOvl
+#define e4_bSwapPageNo  u.e4.s1.swapinfo.bSwapPageNo
+
+#define INT_LOADSWAPPAGE 0x0001
+#define INT_INCOMINGCMV  0x0002
+
+union intr_data_e1 {
+        struct {
+                struct swap_info_e1 swapinfo;
+                __le16 wDataSize;
+        } __attribute__ ((packed)) s1;
+        struct {
+                struct cmv_e1 cmv;
+                __le16 wDataSize;
+        } __attribute__ ((packed)) s2;
+} __attribute__ ((packed));
+
+union intr_data_e4 {
+        struct {
+                struct swap_info_e4 swapinfo;
+                __le16 wDataSize;
+        } __attribute__ ((packed)) s1;
+        struct {
+                struct cmv_e4 cmv;
+                __le16 wDataSize;
+        } __attribute__ ((packed)) s2;
+} __attribute__ ((packed));
+
 struct intr_pkt {
         __u8 bType;
         __u8 bNotification;
@@ -347,43 +524,48 @@ struct intr_pkt {
         __le16 wIndex;
         __le16 wLength;
         __le16 wInterrupt;
-#define INT_LOADSWAPPAGE 0x0001
-#define INT_INCOMINGCMV  0x0002
         union {
-                struct {
-                        struct swap_info swapinfo;
-                        __le16 wDataSize;
-                } __attribute__ ((packed)) s1;
-
-                struct {
-                        struct cmv cmv;
-                        __le16 wDataSize;
-                } __attribute__ ((packed)) s2;
-        } __attribute__ ((packed)) u;
-#define bSwapPageNo     u.s1.swapinfo.bSwapPageNo
-#define bOvl            u.s1.swapinfo.bOvl
+                union intr_data_e1 e1;
+                union intr_data_e4 e4;
+        } u;
 } __attribute__ ((packed));
-#define INTR_PKT_SIZE 28
+
+#define E1_INTR_PKT_SIZE 28
+#define E4_INTR_PKT_SIZE 64
 
 static struct usb_driver uea_driver;
 static DEFINE_MUTEX(uea_mutex);
-static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III"};
+static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III", "Eagle IV"};
 
 static int modem_index;
 static unsigned int debug;
-static int use_iso[NB_MODEM] = {[0 ... (NB_MODEM - 1)] = 1};
+static unsigned int altsetting[NB_MODEM] = {[0 ... (NB_MODEM - 1)] = FASTEST_ISO_INTF};
 static int sync_wait[NB_MODEM];
 static char *cmv_file[NB_MODEM];
+static int annex[NB_MODEM];
 
 module_param(debug, uint, 0644);
 MODULE_PARM_DESC(debug, "module debug level (0=off,1=on,2=verbose)");
-module_param_array(use_iso, bool, NULL, 0644);
-MODULE_PARM_DESC(use_iso, "use isochronous usb pipe for incoming traffic");
+module_param_array(altsetting, uint, NULL, 0644);
+MODULE_PARM_DESC(altsetting, "alternate setting for incoming traffic: 0=bulk, "
+                             "1=isoc slowest, ... , 8=isoc fastest (default)");
 module_param_array(sync_wait, bool, NULL, 0644);
 MODULE_PARM_DESC(sync_wait, "wait the synchronisation before starting ATM");
 module_param_array(cmv_file, charp, NULL, 0644);
 MODULE_PARM_DESC(cmv_file,
                 "file name with configuration and management variables");
+module_param_array(annex, uint, NULL, 0644);
+MODULE_PARM_DESC(annex,
+                 "manually set annex a/b (0=auto, 1=annex a, 2=annex b)");
+
+#define uea_wait(sc, cond, timeo) \
+({ \
+        int _r = wait_event_interruptible_timeout(sc->sync_q, \
+                        (cond) || kthread_should_stop(), timeo); \
+        if (kthread_should_stop()) \
+                _r = -ENODEV; \
+        _r; \
+})
 
 #define UPDATE_ATM_STAT(type, val) \
         do { \
@@ -519,6 +701,9 @@ static int uea_load_firmware(struct usb_device *usb, unsigned int ver)
         case EAGLE_III:
                 fw_name = FW_DIR "eagleIII.fw";
                 break;
+        case EAGLE_IV:
+                fw_name = FW_DIR "eagleIV.fw";
+                break;
         }
 
         ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, usb, uea_upload_pre_firmware);
@@ -537,7 +722,7 @@ static int uea_load_firmware(struct usb_device *usb, unsigned int ver)
 /*
  * Make sure that the DSP code provided is safe to use.
  */
-static int check_dsp(u8 *dsp, unsigned int len)
+static int check_dsp_e1(u8 *dsp, unsigned int len)
 {
         u8 pagecount, blockcount;
         u16 blocksize;
@@ -588,6 +773,51 @@ static int check_dsp(u8 *dsp, unsigned int len)
         return 0;
 }
 
+static int check_dsp_e4(u8 *dsp, int len)
+{
+        int i;
+        struct l1_code *p = (struct l1_code *) dsp;
+        unsigned int sum = p->code - dsp;
+
+        if (len < sum)
+                return 1;
+
+        if (strcmp("STRATIPHY ANEXA", p->string_header) != 0 &&
+            strcmp("STRATIPHY ANEXB", p->string_header) != 0)
+                return 1;
+
+        for (i = 0; i < E4_MAX_PAGE_NUMBER; i++) {
+                struct block_index *blockidx;
+                u8 blockno = p->page_number_to_block_index[i];
+                if (blockno >= E4_NO_SWAPPAGE_HEADERS)
+                        continue;
+
+                do {
+                        u64 l;
+
+                        if (blockno >= E4_NO_SWAPPAGE_HEADERS)
+                                return 1;
+
+                        blockidx = &p->page_header[blockno++];
+                        if ((u8 *)(blockidx + 1) - dsp  >= len)
+                                return 1;
+
+                        if (le16_to_cpu(blockidx->PageNumber) != i)
+                                return 1;
+
+                        l = E4_PAGE_BYTES(blockidx->PageSize);
+                        sum += l;
+                        l += le32_to_cpu(blockidx->PageOffset);
+                        if (l > len)
+                                return 1;
+
+                /* zero is zero regardless endianes */
+                } while (blockidx->NotLastBlock);
+        }
+
+        return (sum == len) ? 0 : 1;
+}
+
 /*
  * send data to the idma pipe
  * */
@@ -624,13 +854,18 @@ static int request_dsp(struct uea_softc *sc)
         int ret;
         char *dsp_name;
 
-        if (UEA_CHIP_VERSION(sc) == ADI930) {
-                if (IS_ISDN(sc->usb_dev))
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV) {
+                if (IS_ISDN(sc))
+                        dsp_name = FW_DIR "DSP4i.bin";
+                else
+                        dsp_name = FW_DIR "DSP4p.bin";
+        } else if (UEA_CHIP_VERSION(sc) == ADI930) {
+                if (IS_ISDN(sc))
                         dsp_name = FW_DIR "DSP9i.bin";
                 else
                         dsp_name = FW_DIR "DSP9p.bin";
         } else {
-                if (IS_ISDN(sc->usb_dev))
+                if (IS_ISDN(sc))
                         dsp_name = FW_DIR "DSPei.bin";
                 else
                         dsp_name = FW_DIR "DSPep.bin";
@@ -640,11 +875,16 @@ static int request_dsp(struct uea_softc *sc)
         if (ret < 0) {
                 uea_err(INS_TO_USBDEV(sc),
                        "requesting firmware %s failed with error %d\n",
-                       dsp_name, ret);
+                        dsp_name, ret);
                 return ret;
         }
 
-        if (check_dsp(sc->dsp_firm->data, sc->dsp_firm->size)) {
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV)
+                ret = check_dsp_e4(sc->dsp_firm->data, sc->dsp_firm->size);
+        else
+                ret = check_dsp_e1(sc->dsp_firm->data, sc->dsp_firm->size);
+
+        if (ret) {
                 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n",
                        dsp_name);
                 release_firmware(sc->dsp_firm);
@@ -658,12 +898,12 @@ static int request_dsp(struct uea_softc *sc)
 /*
  * The uea_load_page() function must be called within a process context
  */
-static void uea_load_page(struct work_struct *work)
+static void uea_load_page_e1(struct work_struct *work)
 {
         struct uea_softc *sc = container_of(work, struct uea_softc, task);
         u16 pageno = sc->pageno;
         u16 ovl = sc->ovl;
-        struct block_info bi;
+        struct block_info_e1 bi;
 
         u8 *p;
         u8 pagecount, blockcount;
@@ -716,7 +956,7 @@ static void uea_load_page(struct work_struct *work)
                 bi.wLast = cpu_to_le16((i == blockcount - 1) ? 1 : 0);
 
                 /* send block info through the IDMA pipe */
-                if (uea_idma_write(sc, &bi, BLOCK_INFO_SIZE))
+                if (uea_idma_write(sc, &bi, E1_BLOCK_INFO_SIZE))
                         goto bad2;
 
                 /* send block data through the IDMA pipe */
@@ -735,17 +975,114 @@ bad1:
         uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n", pageno);
 }
 
+static void __uea_load_page_e4(struct uea_softc *sc, u8 pageno, int boot)
+{
+        struct block_info_e4 bi;
+        struct block_index *blockidx;
+        struct l1_code *p = (struct l1_code *) sc->dsp_firm->data;
+        u8 blockno = p->page_number_to_block_index[pageno];
+
+        bi.wHdr = cpu_to_be16(UEA_BIHDR);
+        bi.bBootPage = boot;
+        bi.bPageNumber = pageno;
+        bi.wReserved = cpu_to_be16(UEA_RESERVED);
+
+        do {
+                u8 *blockoffset;
+                unsigned int blocksize;
+
+                blockidx = &p->page_header[blockno];
+                blocksize = E4_PAGE_BYTES(blockidx->PageSize);
+                blockoffset = sc->dsp_firm->data + le32_to_cpu(blockidx->PageOffset);
+
+                bi.dwSize = cpu_to_be32(blocksize);
+                bi.dwAddress = swab32(blockidx->PageAddress);
+
+                uea_dbg(INS_TO_USBDEV(sc),
+                       "sending block %u for DSP page %u size %u adress %x\n",
+                       blockno, pageno, blocksize, le32_to_cpu(blockidx->PageAddress));
+
+                /* send block info through the IDMA pipe */
+                if (uea_idma_write(sc, &bi, E4_BLOCK_INFO_SIZE))
+                        goto bad;
+
+                /* send block data through the IDMA pipe */
+                if (uea_idma_write(sc, blockoffset, blocksize))
+                        goto bad;
+
+                blockno++;
+        } while (blockidx->NotLastBlock);
+
+        return;
+
+bad:
+        uea_err(INS_TO_USBDEV(sc), "sending DSP block %u failed\n", blockno);
+        return;
+}
+
+static void uea_load_page_e4(struct work_struct *work)
+{
+        struct uea_softc *sc = container_of(work, struct uea_softc, task);
+        u8 pageno = sc->pageno;
+        int i;
+        struct block_info_e4 bi;
+        struct l1_code *p;
+
+        uea_dbg(INS_TO_USBDEV(sc), "sending DSP page %u\n", pageno);
+
+        /* reload firmware when reboot start and it's loaded already */
+        if (pageno == 0 && sc->dsp_firm) {
+                release_firmware(sc->dsp_firm);
+                sc->dsp_firm = NULL;
+        }
+
+        if (sc->dsp_firm == NULL && request_dsp(sc) < 0)
+                return;
+
+        p = (struct l1_code *) sc->dsp_firm->data;
+        if (pageno >= p->page_header[0].PageNumber) {
+                uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n", pageno);
+                return;
+        }
+
+        if (pageno != 0) {
+                __uea_load_page_e4(sc, pageno, 0);
+                return;
+        }
+
+        uea_dbg(INS_TO_USBDEV(sc),
+               "sending Main DSP page %u\n", p->page_header[0].PageNumber);
+
+        for (i = 0; i < le16_to_cpu(p->page_header[0].PageNumber); i++) {
+                if (E4_IS_BOOT_PAGE(p->page_header[i].PageSize))
+                        __uea_load_page_e4(sc, i, 1);
+        }
+
+        uea_dbg(INS_TO_USBDEV(sc),"sending start bi\n");
+
+        bi.wHdr = cpu_to_be16(UEA_BIHDR);
+        bi.bBootPage = 0;
+        bi.bPageNumber = 0xff;
+        bi.wReserved = cpu_to_be16(UEA_RESERVED);
+        bi.dwSize = cpu_to_be32(E4_PAGE_BYTES(p->page_header[0].PageSize));
+        bi.dwAddress = swab32(p->page_header[0].PageAddress);
+
+        /* send block info through the IDMA pipe */
+        if (uea_idma_write(sc, &bi, E4_BLOCK_INFO_SIZE))
+                uea_err(INS_TO_USBDEV(sc), "sending DSP start bi failed\n");
+}
+
 static inline void wake_up_cmv_ack(struct uea_softc *sc)
 {
         BUG_ON(sc->cmv_ack);
         sc->cmv_ack = 1;
-        wake_up(&sc->cmv_ack_wait);
+        wake_up(&sc->sync_q);
 }
 
 static inline int wait_cmv_ack(struct uea_softc *sc)
 {
-        int ret = wait_event_interruptible_timeout(sc->cmv_ack_wait,
-                                                   sc->cmv_ack, ACK_TIMEOUT);
+        int ret = uea_wait(sc, sc->cmv_ack , ACK_TIMEOUT);
+
         sc->cmv_ack = 0;
 
         uea_dbg(INS_TO_USBDEV(sc), "wait_event_timeout : %d ms\n",
@@ -792,33 +1129,68 @@ static int uea_request(struct uea_softc *sc,
         return 0;
 }
 
-static int uea_cmv(struct uea_softc *sc,
+static int uea_cmv_e1(struct uea_softc *sc,
                 u8 function, u32 address, u16 offset, u32 data)
 {
-        struct cmv cmv;
+        struct cmv_e1 cmv;
         int ret;
 
         uea_enters(INS_TO_USBDEV(sc));
         uea_vdbg(INS_TO_USBDEV(sc), "Function : %d-%d, Address : %c%c%c%c, "
                         "offset : 0x%04x, data : 0x%08x\n",
-                        FUNCTION_TYPE(function), FUNCTION_SUBTYPE(function),
-                        GETSA1(address), GETSA2(address), GETSA3(address),
-                        GETSA4(address), offset, data);
+                        E1_FUNCTION_TYPE(function), E1_FUNCTION_SUBTYPE(function),
+                        E1_GETSA1(address), E1_GETSA2(address), E1_GETSA3(address),
+                        E1_GETSA4(address), offset, data);
+
         /* we send a request, but we expect a reply */
-        sc->cmv_function = function | 0x2;
-        sc->cmv_idx++;
-        sc->cmv_address = address;
-        sc->cmv_offset = offset;
+        sc->cmv_dsc.e1.function = function | 0x2;
+        sc->cmv_dsc.e1.idx++;
+        sc->cmv_dsc.e1.address = address;
+        sc->cmv_dsc.e1.offset = offset;
 
-        cmv.wPreamble = cpu_to_le16(PREAMBLE);
-        cmv.bDirection = HOSTTOMODEM;
+        cmv.wPreamble = cpu_to_le16(E1_PREAMBLE);
+        cmv.bDirection = E1_HOSTTOMODEM;
         cmv.bFunction = function;
-        cmv.wIndex = cpu_to_le16(sc->cmv_idx);
+        cmv.wIndex = cpu_to_le16(sc->cmv_dsc.e1.idx);
         put_unaligned(cpu_to_le32(address), &cmv.dwSymbolicAddress);
         cmv.wOffsetAddress = cpu_to_le16(offset);
         put_unaligned(cpu_to_le32(data >> 16 | data << 16), &cmv.dwData);
 
-        ret = uea_request(sc, UEA_SET_BLOCK, UEA_MPTX_START, CMV_SIZE, &cmv);
+        ret = uea_request(sc, UEA_E1_SET_BLOCK, UEA_MPTX_START, sizeof(cmv), &cmv);
+        if (ret < 0)
+                return ret;
+        ret = wait_cmv_ack(sc);
+        uea_leaves(INS_TO_USBDEV(sc));
+        return ret;
+}
+
+static int uea_cmv_e4(struct uea_softc *sc,
+                u16 function, u16 group, u16 address, u16 offset, u32 data)
+{
+        struct cmv_e4 cmv;
+        int ret;
+
+        uea_enters(INS_TO_USBDEV(sc));
+        memset(&cmv, 0, sizeof(cmv));
+
+        uea_vdbg(INS_TO_USBDEV(sc), "Function : %d-%d, Group : 0x%04x, "
+                 "Address : 0x%04x, offset : 0x%04x, data : 0x%08x\n",
+                 E4_FUNCTION_TYPE(function), E4_FUNCTION_SUBTYPE(function),
+                 group, address, offset, data);
+
+        /* we send a request, but we expect a reply */
+        sc->cmv_dsc.e4.function = function | (0x1 << 4);
+        sc->cmv_dsc.e4.offset = offset;
+        sc->cmv_dsc.e4.address = address;
+        sc->cmv_dsc.e4.group = group;
+
+        cmv.wFunction = cpu_to_be16(function);
+        cmv.wGroup = cpu_to_be16(group);
+        cmv.wAddress = cpu_to_be16(address);
+        cmv.wOffset = cpu_to_be16(offset);
+        cmv.dwData[0] = cpu_to_be32(data);
+
+        ret = uea_request(sc, UEA_E4_SET_BLOCK, UEA_MPTX_START, sizeof(cmv), &cmv);
         if (ret < 0)
                 return ret;
         ret = wait_cmv_ack(sc);
@@ -826,10 +1198,10 @@ static int uea_cmv(struct uea_softc *sc,
         return ret;
 }
 
-static inline int uea_read_cmv(struct uea_softc *sc,
+static inline int uea_read_cmv_e1(struct uea_softc *sc,
                 u32 address, u16 offset, u32 *data)
 {
-        int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTREAD),
+        int ret = uea_cmv_e1(sc, E1_MAKEFUNCTION(E1_MEMACCESS, E1_REQUESTREAD),
                           address, offset, 0);
         if (ret < 0)
                 uea_err(INS_TO_USBDEV(sc),
@@ -840,10 +1212,27 @@ static inline int uea_read_cmv(struct uea_softc *sc,
         return ret;
 }
 
-static inline int uea_write_cmv(struct uea_softc *sc,
+static inline int uea_read_cmv_e4(struct uea_softc *sc,
+                u8 size, u16 group, u16 address, u16 offset, u32 *data)
+{
+        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, E4_REQUESTREAD, size),
+                          group, address, offset, 0);
+        if (ret < 0)
+                uea_err(INS_TO_USBDEV(sc),
+                        "reading cmv failed with error %d\n", ret);
+        else {
+                *data = sc->data;
+                /* size is in 16-bit word quantities */
+                if (size > 2)
+                        *(data + 1) = sc->data1;
+        }
+        return ret;
+}
+
+static inline int uea_write_cmv_e1(struct uea_softc *sc,
                 u32 address, u16 offset, u32 data)
 {
-        int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTWRITE),
+        int ret = uea_cmv_e1(sc, E1_MAKEFUNCTION(E1_MEMACCESS, E1_REQUESTWRITE),
                           address, offset, data);
         if (ret < 0)
                 uea_err(INS_TO_USBDEV(sc),
@@ -852,12 +1241,48 @@ static inline int uea_write_cmv(struct uea_softc *sc,
         return ret;
 }
 
+static inline int uea_write_cmv_e4(struct uea_softc *sc,
+                u8 size, u16 group, u16 address, u16 offset, u32 data)
+{
+        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, E4_REQUESTWRITE, size),
+                          group, address, offset, data);
+        if (ret < 0)
+                uea_err(INS_TO_USBDEV(sc),
+                        "writing cmv failed with error %d\n", ret);
+
+        return ret;
+}
+
+static void uea_set_bulk_timeout(struct uea_softc *sc, u32 dsrate)
+{
+        int ret;
+        u16 timeout;
+
+        /* in bulk mode the modem have problem with high rate
+         * changing internal timing could improve things, but the
+         * value is misterious.
+         * ADI930 don't support it (-EPIPE error).
+         */
+
+        if (UEA_CHIP_VERSION(sc) == ADI930 ||
+            altsetting[sc->modem_index] > 0 ||
+            sc->stats.phy.dsrate == dsrate)
+                return;
+
+        /* Original timming (1Mbit/s) from ADI (used in windows driver) */
+        timeout = (dsrate <= 1024*1024) ? 0 : 1;
+        ret = uea_request(sc, UEA_SET_TIMEOUT, timeout, 0, NULL);
+        uea_info(INS_TO_USBDEV(sc), "setting new timeout %d%s\n",
+                 timeout,  ret < 0 ? " failed" : "");
+
+}
+
 /*
  * Monitor the modem and update the stat
  * return 0 if everything is ok
  * return < 0 if an error occurs (-EAGAIN reboot needed)
  */
-static int uea_stat(struct uea_softc *sc)
+static int uea_stat_e1(struct uea_softc *sc)
 {
         u32 data;
         int ret;
@@ -865,7 +1290,7 @@ static int uea_stat(struct uea_softc *sc)
         uea_enters(INS_TO_USBDEV(sc));
         data = sc->stats.phy.state;
 
-        ret = uea_read_cmv(sc, SA_STAT, 0, &sc->stats.phy.state);
+        ret = uea_read_cmv_e1(sc, E1_SA_STAT, 0, &sc->stats.phy.state);
         if (ret < 0)
                 return ret;
 
@@ -885,7 +1310,7 @@ static int uea_stat(struct uea_softc *sc)
 
         case 3:         /* fail ... */
                 uea_info(INS_TO_USBDEV(sc), "modem synchronization failed"
-                                " (may be try other cmv/dsp)\n");
+                                        " (may be try other cmv/dsp)\n");
                 return -EAGAIN;
 
         case 4 ... 6:   /* test state */
@@ -923,7 +1348,7 @@ static int uea_stat(struct uea_softc *sc)
         /* wake up processes waiting for synchronization */
         wake_up(&sc->sync_q);
 
-        ret = uea_read_cmv(sc, SA_DIAG, 2, &sc->stats.phy.flags);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 2, &sc->stats.phy.flags);
         if (ret < 0)
                 return ret;
         sc->stats.phy.mflags |= sc->stats.phy.flags;
@@ -937,105 +1362,223 @@ static int uea_stat(struct uea_softc *sc)
                 return 0;
         }
 
-        ret = uea_read_cmv(sc, SA_RATE, 0, &data);
+        ret = uea_read_cmv_e1(sc, E1_SA_RATE, 0, &data);
         if (ret < 0)
                 return ret;
 
-        /* in bulk mode the modem have problem with high rate
-         * changing internal timing could improve things, but the
-         * value is misterious.
-         * ADI930 don't support it (-EPIPE error).
-         */
-        if (UEA_CHIP_VERSION(sc) != ADI930
-                    && !use_iso[sc->modem_index]
-                    && sc->stats.phy.dsrate != (data >> 16) * 32) {
-                /* Original timming from ADI(used in windows driver)
-                 * 0x20ffff>>16 * 32 = 32 * 32 = 1Mbits
-                 */
-                u16 timeout = (data <= 0x20ffff) ? 0 : 1;
-                ret = uea_request(sc, UEA_SET_TIMEOUT, timeout, 0, NULL);
-                uea_info(INS_TO_USBDEV(sc),
-                                "setting new timeout %d%s\n", timeout,
-                                ret < 0?" failed":"");
-        }
+        uea_set_bulk_timeout(sc, (data >> 16) * 32);
         sc->stats.phy.dsrate = (data >> 16) * 32;
         sc->stats.phy.usrate = (data & 0xffff) * 32;
         UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424);
 
-        ret = uea_read_cmv(sc, SA_DIAG, 23, &data);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 23, &data);
         if (ret < 0)
                 return ret;
         sc->stats.phy.dsattenuation = (data & 0xff) / 2;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 47, &data);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 47, &data);
         if (ret < 0)
                 return ret;
         sc->stats.phy.usattenuation = (data & 0xff) / 2;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 25, &sc->stats.phy.dsmargin);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 25, &sc->stats.phy.dsmargin);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 49, &sc->stats.phy.usmargin);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 49, &sc->stats.phy.usmargin);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 51, &sc->stats.phy.rxflow);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 51, &sc->stats.phy.rxflow);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 52, &sc->stats.phy.txflow);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 52, &sc->stats.phy.txflow);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 54, &sc->stats.phy.dsunc);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 54, &sc->stats.phy.dsunc);
         if (ret < 0)
                 return ret;
 
         /* only for atu-c */
-        ret = uea_read_cmv(sc, SA_DIAG, 58, &sc->stats.phy.usunc);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 58, &sc->stats.phy.usunc);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_DIAG, 53, &sc->stats.phy.dscorr);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 53, &sc->stats.phy.dscorr);
         if (ret < 0)
                 return ret;
 
         /* only for atu-c */
-        ret = uea_read_cmv(sc, SA_DIAG, 57, &sc->stats.phy.uscorr);
+        ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 57, &sc->stats.phy.uscorr);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_INFO, 8, &sc->stats.phy.vidco);
+        ret = uea_read_cmv_e1(sc, E1_SA_INFO, 8, &sc->stats.phy.vidco);
         if (ret < 0)
                 return ret;
 
-        ret = uea_read_cmv(sc, SA_INFO, 13, &sc->stats.phy.vidcpe);
+        ret = uea_read_cmv_e1(sc, E1_SA_INFO, 13, &sc->stats.phy.vidcpe);
         if (ret < 0)
                 return ret;
 
         return 0;
 }
 
-static int request_cmvs(struct uea_softc *sc,
-                 struct uea_cmvs **cmvs, const struct firmware **fw)
+static int uea_stat_e4(struct uea_softc *sc)
 {
-        int ret, size;
-        u8 *data;
+        u32 data;
+        u32 tmp_arr[2];
+        int ret;
+
+        uea_enters(INS_TO_USBDEV(sc));
+        data = sc->stats.phy.state;
+
+        /* XXX only need to be done before operationnal... */
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_STAT, 0, 0, &sc->stats.phy.state);
+        if (ret < 0)
+                return ret;
+
+        switch (sc->stats.phy.state) {
+                case 0x0:       /* not yet synchronized */
+                case 0x1:
+                case 0x3:
+                case 0x4:
+                        uea_dbg(INS_TO_USBDEV(sc), "modem not yet synchronized\n");
+                        return 0;
+                case 0x5:       /* initialization */
+                case 0x6:
+                case 0x9:
+                case 0xa:
+                        uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n");
+                        return 0;
+                case 0x2:       /* fail ... */
+                        uea_info(INS_TO_USBDEV(sc), "modem synchronization failed"
+                                        " (may be try other cmv/dsp)\n");
+                        return -EAGAIN;
+                case 0x7:       /* operational */
+                        break;
+                default:
+                        uea_warn(INS_TO_USBDEV(sc), "unknown state: %x\n", sc->stats.phy.state);
+                        return 0;
+        }
+
+        if (data != 7) {
+                uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_OFF, 0, NULL);
+                uea_info(INS_TO_USBDEV(sc), "modem operational\n");
+
+                /* release the dsp firmware as it is not needed until
+                 * the next failure
+                 */
+                if (sc->dsp_firm) {
+                        release_firmware(sc->dsp_firm);
+                        sc->dsp_firm = NULL;
+                }
+        }
+
+        /* always update it as atm layer could not be init when we switch to
+         * operational state
+         */
+        UPDATE_ATM_STAT(signal, ATM_PHY_SIG_FOUND);
+
+        /* wake up processes waiting for synchronization */
+        wake_up(&sc->sync_q);
+
+        /* TODO improve this state machine :
+         * we need some CMV info : what they do and their unit
+         * we should find the equivalent of eagle3- CMV
+         */
+        /* check flags */
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_DIAG, 0, 0, &sc->stats.phy.flags);
+        if (ret < 0)
+                return ret;
+        sc->stats.phy.mflags |= sc->stats.phy.flags;
+
+        /* in case of a flags ( for example delineation LOSS (& 0x10)),
+         * we check the status again in order to detect the failure earlier
+         */
+        if (sc->stats.phy.flags) {
+                uea_dbg(INS_TO_USBDEV(sc), "Stat flag = 0x%x\n",
+                       sc->stats.phy.flags);
+                if (sc->stats.phy.flags & 1) //delineation LOSS
+                        return -EAGAIN;
+                if (sc->stats.phy.flags & 0x4000) //Reset Flag
+                        return -EAGAIN;
+                return 0;
+        }
+
+        /* rate data may be in upper or lower half of 64 bit word, strange */
+        ret = uea_read_cmv_e4(sc, 4, E4_SA_RATE, 0, 0, tmp_arr);
+        if (ret < 0)
+                return ret;
+        data = (tmp_arr[0]) ? tmp_arr[0] : tmp_arr[1];
+        sc->stats.phy.usrate = data / 1000;
+
+        ret = uea_read_cmv_e4(sc, 4, E4_SA_RATE, 1, 0, tmp_arr);
+        if (ret < 0)
+                return ret;
+        data = (tmp_arr[0]) ? tmp_arr[0] : tmp_arr[1];
+        uea_set_bulk_timeout(sc, data / 1000);
+        sc->stats.phy.dsrate = data / 1000;
+        UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424);
+
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 68, 1, &data);
+        if (ret < 0)
+                return ret;
+        sc->stats.phy.dsattenuation = data / 10;
+
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 69, 1, &data);
+        if (ret < 0)
+                return ret;
+        sc->stats.phy.usattenuation = data / 10;
+
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 68, 3, &data);
+        if (ret < 0)
+                return ret;
+        sc->stats.phy.dsmargin = data / 2;
+
+        ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 69, 3, &data);
+        if (ret < 0)
+                return ret;
+        sc->stats.phy.usmargin = data / 10;
+
+        return 0;
+}
+
+static void cmvs_file_name(struct uea_softc *sc, char *const cmv_name, int ver)
+{
+        char file_arr[] = "CMVxy.bin";
         char *file;
-        char cmv_name[FIRMWARE_NAME_MAX]; /* 30 bytes stack variable */
 
+        /* set proper name corresponding modem version and line type */
         if (cmv_file[sc->modem_index] == NULL) {
                 if (UEA_CHIP_VERSION(sc) == ADI930)
-                        file = (IS_ISDN(sc->usb_dev)) ? "CMV9i.bin" : "CMV9p.bin";
+                        file_arr[3] = '9';
+                else if (UEA_CHIP_VERSION(sc) == EAGLE_IV)
+                        file_arr[3] = '4';
                 else
-                        file = (IS_ISDN(sc->usb_dev)) ? "CMVei.bin" : "CMVep.bin";
+                        file_arr[3] = 'e';
+
+                file_arr[4] = IS_ISDN(sc) ? 'i' : 'p';
+                file = file_arr;
         } else
                 file = cmv_file[sc->modem_index];
 
         strcpy(cmv_name, FW_DIR);
-        strlcat(cmv_name, file, sizeof(cmv_name));
+        strlcat(cmv_name, file, FIRMWARE_NAME_MAX);
+        if (ver == 2)
+                strlcat(cmv_name, ".v2", FIRMWARE_NAME_MAX);
+}
+
+static int request_cmvs_old(struct uea_softc *sc,
+                 void **cmvs, const struct firmware **fw)
+{
+        int ret, size;
+        u8 *data;
+        char cmv_name[FIRMWARE_NAME_MAX]; /* 30 bytes stack variable */
 
+        cmvs_file_name(sc, cmv_name, 1);
         ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev);
         if (ret < 0) {
                 uea_err(INS_TO_USBDEV(sc),
@@ -1045,16 +1588,197 @@ static int request_cmvs(struct uea_softc *sc,
         }
 
         data = (u8 *) (*fw)->data;
-        size = *data * sizeof(struct uea_cmvs) + 1;
-        if (size != (*fw)->size) {
-                uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n",
-                       cmv_name);
-                release_firmware(*fw);
-                return -EILSEQ;
+        size = (*fw)->size;
+        if (size < 1)
+                goto err_fw_corrupted;
+
+        if (size != *data * sizeof(struct uea_cmvs_v1) + 1)
+                goto err_fw_corrupted;
+
+        *cmvs = (void *)(data + 1);
+        return *data;
+
+err_fw_corrupted:
+        uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", cmv_name);
+        release_firmware(*fw);
+        return -EILSEQ;
+}
+
+static int request_cmvs(struct uea_softc *sc,
+                 void **cmvs, const struct firmware **fw, int *ver)
+{
+        int ret, size;
+        u32 crc;
+        u8 *data;
+        char cmv_name[FIRMWARE_NAME_MAX]; /* 30 bytes stack variable */
+
+        cmvs_file_name(sc, cmv_name, 2);
+        ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev);
+        if (ret < 0) {
+                /* if caller can handle old version, try to provide it */
+                if (*ver == 1) {
+                        uea_warn(INS_TO_USBDEV(sc), "requesting firmware %s failed, "
+                                "try to get older cmvs\n", cmv_name);
+                        return request_cmvs_old(sc, cmvs, fw);
+                }
+                uea_err(INS_TO_USBDEV(sc),
+                       "requesting firmware %s failed with error %d\n",
+                       cmv_name, ret);
+                return ret;
+        }
+
+        size = (*fw)->size;
+        data = (u8 *) (*fw)->data;
+        if (size < 4 || strncmp(data, "cmv2", 4) != 0) {
+                if (*ver == 1) {
+                        uea_warn(INS_TO_USBDEV(sc), "firmware %s is corrupted, "
+                                "try to get older cmvs\n", cmv_name);
+                        release_firmware(*fw);
+                        return request_cmvs_old(sc, cmvs, fw);
+                }
+                goto err_fw_corrupted;
         }
 
-        *cmvs = (struct uea_cmvs *)(data + 1);
+        *ver = 2;
+
+        data += 4;
+        size -= 4;
+        if (size < 5)
+                goto err_fw_corrupted;
+
+        crc = FW_GET_LONG(data);
+        data += 4;
+        size -= 4;
+        if (crc32_be(0, data, size) != crc)
+                goto err_fw_corrupted;
+
+        if (size != *data * sizeof(struct uea_cmvs_v2) + 1)
+                goto err_fw_corrupted;
+
+        *cmvs = (void *) (data + 1);
         return *data;
+
+err_fw_corrupted:
+        uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", cmv_name);
+        release_firmware(*fw);
+        return -EILSEQ;
+}
+
+static int uea_send_cmvs_e1(struct uea_softc *sc)
+{
+        int i, ret, len;
+        void *cmvs_ptr;
+        const struct firmware *cmvs_fw;
+        int ver = 1; // we can handle v1 cmv firmware version;
+
+        /* Enter in R-IDLE (cmv) until instructed otherwise */
+        ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 1);
+        if (ret < 0)
+                return ret;
+
+        /* Dump firmware version */
+        ret = uea_read_cmv_e1(sc, E1_SA_INFO, 10, &sc->stats.phy.firmid);
+        if (ret < 0)
+                return ret;
+        uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",
+                        sc->stats.phy.firmid);
+
+        /* get options */
+        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
+        if (ret < 0)
+                return ret;
+
+        /* send options */
+        if (ver == 1) {
+                struct uea_cmvs_v1 *cmvs_v1 = cmvs_ptr;
+
+                uea_warn(INS_TO_USBDEV(sc), "use deprecated cmvs version, "
+                        "please update your firmware\n");
+
+                for (i = 0; i < len; i++) {
+                        ret = uea_write_cmv_e1(sc, FW_GET_LONG(&cmvs_v1[i].address),
+                                                FW_GET_WORD(&cmvs_v1[i].offset),
+                                                FW_GET_LONG(&cmvs_v1[i].data));
+                        if (ret < 0)
+                                goto out;
+                }
+        } else if (ver == 2) {
+                struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr;
+
+                for (i = 0; i < len; i++) {
+                        ret = uea_write_cmv_e1(sc, FW_GET_LONG(&cmvs_v2[i].address),
+                                                (u16) FW_GET_LONG(&cmvs_v2[i].offset),
+                                                FW_GET_LONG(&cmvs_v2[i].data));
+                        if (ret < 0)
+                                goto out;
+                }
+        } else {
+                /* This realy should not happen */
+                uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver);
+                goto out;
+        }
+
+        /* Enter in R-ACT-REQ */
+        ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 2);
+        uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");
+        uea_info(INS_TO_USBDEV(sc), "modem started, waiting synchronization...\n");
+out:
+        release_firmware(cmvs_fw);
+        return ret;
+}
+
+static int uea_send_cmvs_e4(struct uea_softc *sc)
+{
+        int i, ret, len;
+        void *cmvs_ptr;
+        const struct firmware *cmvs_fw;
+        int ver = 2; // we can only handle v2 cmv firmware version;
+
+        /* Enter in R-IDLE (cmv) until instructed otherwise */
+        ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 1);
+        if (ret < 0)
+                return ret;
+
+        /* Dump firmware version */
+        /* XXX don't read the 3th byte as it is always 6 */
+        ret = uea_read_cmv_e4(sc, 2, E4_SA_INFO, 55, 0, &sc->stats.phy.firmid);
+        if (ret < 0)
+                return ret;
+        uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",
+                        sc->stats.phy.firmid);
+
+
+        /* get options */
+        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
+        if (ret < 0)
+                return ret;
+
+        /* send options */
+        if (ver == 2) {
+                struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr;
+
+                for (i = 0; i < len; i++) {
+                        ret = uea_write_cmv_e4(sc, 1,
+                                                FW_GET_LONG(&cmvs_v2[i].group),
+                                                FW_GET_LONG(&cmvs_v2[i].address),
+                                                FW_GET_LONG(&cmvs_v2[i].offset),
+                                                FW_GET_LONG(&cmvs_v2[i].data));
+                        if (ret < 0)
+                                goto out;
+                }
+        } else {
+                /* This realy should not happen */
+                uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver);
+                goto out;
+        }
+
+        /* Enter in R-ACT-REQ */
+        ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 2);
+        uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");
+        uea_info(INS_TO_USBDEV(sc), "modem started, waiting synchronization...\n");
+out:
+        release_firmware(cmvs_fw);
+        return ret;
 }
 
 /* Start boot post firmware modem:
@@ -1066,9 +1790,7 @@ static int request_cmvs(struct uea_softc *sc,
 static int uea_start_reset(struct uea_softc *sc)
 {
         u16 zero = 0;   /* ;-) */
-        int i, len, ret;
-        struct uea_cmvs *cmvs;
-        const struct firmware *cmvs_fw;
+        int ret;
 
         uea_enters(INS_TO_USBDEV(sc));
         uea_info(INS_TO_USBDEV(sc), "(re)booting started\n");
@@ -1093,25 +1815,36 @@ static int uea_start_reset(struct uea_softc *sc)
         uea_request(sc, UEA_SET_MODE, UEA_START_RESET, 0, NULL);
 
         /* original driver use 200ms, but windows driver use 100ms */
-        msleep(100);
+        ret = uea_wait(sc, 0, msecs_to_jiffies(100));
+        if (ret < 0)
+                return ret;
 
         /* leave reset mode */
         uea_request(sc, UEA_SET_MODE, UEA_END_RESET, 0, NULL);
 
-        /* clear tx and rx mailboxes */
-        uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero);
-        uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero);
-        uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero);
+        if (UEA_CHIP_VERSION(sc) != EAGLE_IV) {
+                /* clear tx and rx mailboxes */
+                uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero);
+                uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero);
+                uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero);
+        }
+
+        ret = uea_wait(sc, 0, msecs_to_jiffies(1000));
+        if (ret < 0)
+                return ret;
+
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV)
+                sc->cmv_dsc.e4.function = E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, E4_MODEMREADY, 1);
+        else
+                sc->cmv_dsc.e1.function = E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, E1_MODEMREADY);
 
-        msleep(1000);
-        sc->cmv_function = MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY);
         /* demask interrupt */
         sc->booting = 0;
 
         /* start loading DSP */
         sc->pageno = 0;
         sc->ovl = 0;
-        schedule_work(&sc->task);
+        queue_work(sc->work_q, &sc->task);
 
         /* wait for modem ready CMV */
         ret = wait_cmv_ack(sc);
@@ -1120,38 +1853,10 @@ static int uea_start_reset(struct uea_softc *sc)
 
         uea_vdbg(INS_TO_USBDEV(sc), "Ready CMV received\n");
 
-        /* Enter in R-IDLE (cmv) until instructed otherwise */
-        ret = uea_write_cmv(sc, SA_CNTL, 0, 1);
-        if (ret < 0)
-                return ret;
-
-        /* Dump firmware version */
-        ret = uea_read_cmv(sc, SA_INFO, 10, &sc->stats.phy.firmid);
+        ret = sc->send_cmvs(sc);
         if (ret < 0)
                 return ret;
-        uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",
-                        sc->stats.phy.firmid);
 
-        /* get options */
-        ret = len = request_cmvs(sc, &cmvs, &cmvs_fw);
-        if (ret < 0)
-                return ret;
-
-        /* send options */
-        for (i = 0; i < len; i++) {
-                ret = uea_write_cmv(sc, FW_GET_LONG(&cmvs[i].address),
-                                        FW_GET_WORD(&cmvs[i].offset),
-                                        FW_GET_LONG(&cmvs[i].data));
-                if (ret < 0)
-                        goto out;
-        }
-        /* Enter in R-ACT-REQ */
-        ret = uea_write_cmv(sc, SA_CNTL, 0, 2);
-        uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");
-        uea_info(INS_TO_USBDEV(sc), "Modem started, "
-                "waiting synchronization\n");
-out:
-        release_firmware(cmvs_fw);
         sc->reset = 0;
         uea_leaves(INS_TO_USBDEV(sc));
         return ret;
@@ -1174,12 +1879,10 @@ static int uea_kthread(void *data)
                 if (ret < 0 || sc->reset)
                         ret = uea_start_reset(sc);
                 if (!ret)
-                        ret = uea_stat(sc);
+                        ret = sc->stat(sc);
                 if (ret != -EAGAIN)
-                        msleep_interruptible(1000);
-                if (try_to_freeze())
-                        uea_err(INS_TO_USBDEV(sc), "suspend/resume not supported, "
-                                "please unplug/replug your modem\n");
+                        uea_wait(sc, 0, msecs_to_jiffies(1000));
+                try_to_freeze();
         }
         uea_leaves(INS_TO_USBDEV(sc));
         return ret;
@@ -1234,7 +1937,6 @@ static int load_XILINX_firmware(struct uea_softc *sc)
         if (ret < 0)
                 uea_err(sc->usb_dev, "elsa de-assert failed with error %d\n", ret);
 
-
 err1:
         release_firmware(fw_entry);
 err0:
@@ -1243,40 +1945,41 @@ err0:
 }
 
 /* The modem send us an ack. First with check if it right */
-static void uea_dispatch_cmv(struct uea_softc *sc, struct cmv* cmv)
+static void uea_dispatch_cmv_e1(struct uea_softc *sc, struct intr_pkt *intr)
 {
+        struct cmv_dsc_e1 *dsc = &sc->cmv_dsc.e1;
+        struct cmv_e1 *cmv = &intr->u.e1.s2.cmv;
+
         uea_enters(INS_TO_USBDEV(sc));
-        if (le16_to_cpu(cmv->wPreamble) != PREAMBLE)
+        if (le16_to_cpu(cmv->wPreamble) != E1_PREAMBLE)
                 goto bad1;
 
-        if (cmv->bDirection != MODEMTOHOST)
+        if (cmv->bDirection != E1_MODEMTOHOST)
                 goto bad1;
 
         /* FIXME : ADI930 reply wrong preambule (func = 2, sub = 2) to
          * the first MEMACESS cmv. Ignore it...
          */
-        if (cmv->bFunction != sc->cmv_function) {
+        if (cmv->bFunction != dsc->function) {
                 if (UEA_CHIP_VERSION(sc) == ADI930
-                                && cmv->bFunction ==  MAKEFUNCTION(2, 2)) {
-                        cmv->wIndex = cpu_to_le16(sc->cmv_idx);
-                        put_unaligned(cpu_to_le32(sc->cmv_address), &cmv->dwSymbolicAddress);
-                        cmv->wOffsetAddress = cpu_to_le16(sc->cmv_offset);
-                }
-                else
+                                && cmv->bFunction ==  E1_MAKEFUNCTION(2, 2)) {
+                        cmv->wIndex = cpu_to_le16(dsc->idx);
+                        put_unaligned(cpu_to_le32(dsc->address), &cmv->dwSymbolicAddress);
+                        cmv->wOffsetAddress = cpu_to_le16(dsc->offset);
+                } else
                         goto bad2;
         }
 
-        if (cmv->bFunction == MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY)) {
+        if (cmv->bFunction == E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, E1_MODEMREADY)) {
                 wake_up_cmv_ack(sc);
                 uea_leaves(INS_TO_USBDEV(sc));
                 return;
         }
 
         /* in case of MEMACCESS */
-        if (le16_to_cpu(cmv->wIndex) != sc->cmv_idx ||
-            le32_to_cpu(get_unaligned(&cmv->dwSymbolicAddress)) !=
-            sc->cmv_address
-            || le16_to_cpu(cmv->wOffsetAddress) != sc->cmv_offset)
+        if (le16_to_cpu(cmv->wIndex) != dsc->idx ||
+            le32_to_cpu(get_unaligned(&cmv->dwSymbolicAddress)) != dsc->address ||
+            le16_to_cpu(cmv->wOffsetAddress) != dsc->offset)
                 goto bad2;
 
         sc->data = le32_to_cpu(get_unaligned(&cmv->dwData));
@@ -1289,8 +1992,8 @@ static void uea_dispatch_cmv(struct uea_softc *sc, struct cmv* cmv)
 bad2:
         uea_err(INS_TO_USBDEV(sc), "unexpected cmv received,"
                         "Function : %d, Subfunction : %d\n",
-                        FUNCTION_TYPE(cmv->bFunction),
-                        FUNCTION_SUBTYPE(cmv->bFunction));
+                        E1_FUNCTION_TYPE(cmv->bFunction),
+                        E1_FUNCTION_SUBTYPE(cmv->bFunction));
         uea_leaves(INS_TO_USBDEV(sc));
         return;
 
@@ -1301,6 +2004,61 @@ bad1:
         uea_leaves(INS_TO_USBDEV(sc));
 }
 
+/* The modem send us an ack. First with check if it right */
+static void uea_dispatch_cmv_e4(struct uea_softc *sc, struct intr_pkt *intr)
+{
+        struct cmv_dsc_e4 *dsc = &sc->cmv_dsc.e4;
+        struct cmv_e4 *cmv = &intr->u.e4.s2.cmv;
+
+        uea_enters(INS_TO_USBDEV(sc));
+        uea_dbg(INS_TO_USBDEV(sc), "cmv %x %x %x %x %x %x\n",
+                be16_to_cpu(cmv->wGroup), be16_to_cpu(cmv->wFunction),
+                be16_to_cpu(cmv->wOffset), be16_to_cpu(cmv->wAddress),
+                be32_to_cpu(cmv->dwData[0]), be32_to_cpu(cmv->dwData[1]));
+
+        if (be16_to_cpu(cmv->wFunction) != dsc->function)
+                goto bad2;
+
+        if (be16_to_cpu(cmv->wFunction) == E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, E4_MODEMREADY, 1)) {
+                wake_up_cmv_ack(sc);
+                uea_leaves(INS_TO_USBDEV(sc));
+                return;
+        }
+
+        /* in case of MEMACCESS */
+        if (be16_to_cpu(cmv->wOffset) != dsc->offset ||
+            be16_to_cpu(cmv->wGroup) != dsc->group ||
+            be16_to_cpu(cmv->wAddress) != dsc->address)
+                goto bad2;
+
+        sc->data = be32_to_cpu(cmv->dwData[0]);
+        sc->data1 = be32_to_cpu(cmv->dwData[1]);
+        wake_up_cmv_ack(sc);
+        uea_leaves(INS_TO_USBDEV(sc));
+        return;
+
+bad2:
+        uea_err(INS_TO_USBDEV(sc), "unexpected cmv received,"
+                        "Function : %d, Subfunction : %d\n",
+                        E4_FUNCTION_TYPE(cmv->wFunction),
+                        E4_FUNCTION_SUBTYPE(cmv->wFunction));
+        uea_leaves(INS_TO_USBDEV(sc));
+        return;
+}
+
+static void uea_schedule_load_page_e1(struct uea_softc *sc, struct intr_pkt *intr)
+{
+        sc->pageno = intr->e1_bSwapPageNo;
+        sc->ovl = intr->e1_bOvl >> 4 | intr->e1_bOvl << 4;
+        queue_work(sc->work_q, &sc->task);
+}
+
+static void uea_schedule_load_page_e4(struct uea_softc *sc, struct intr_pkt *intr)
+{
+        sc->pageno = intr->e4_bSwapPageNo;
+        queue_work(sc->work_q, &sc->task);
+}
+
 /*
  * interrupt handler
  */
@@ -1326,13 +2084,11 @@ static void uea_intr(struct urb *urb)
 
         switch (le16_to_cpu(intr->wInterrupt)) {
         case INT_LOADSWAPPAGE:
-                sc->pageno = intr->bSwapPageNo;
-                sc->ovl = intr->bOvl >> 4 | intr->bOvl << 4;
-                schedule_work(&sc->task);
+                sc->schedule_load_page(sc, intr);
                 break;
 
         case INT_INCOMINGCMV:
-                uea_dispatch_cmv(sc, &intr->u.s2.cmv);
+                sc->dispatch_cmv(sc, intr);
                 break;
 
         default:
@@ -1349,35 +2105,55 @@ resubmit:
  */
 static int uea_boot(struct uea_softc *sc)
 {
-        int ret;
+        int ret, size;
         struct intr_pkt *intr;
 
         uea_enters(INS_TO_USBDEV(sc));
 
-        INIT_WORK(&sc->task, uea_load_page);
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV) {
+                size = E4_INTR_PKT_SIZE;
+                sc->dispatch_cmv = uea_dispatch_cmv_e4;
+                sc->schedule_load_page = uea_schedule_load_page_e4;
+                sc->stat = uea_stat_e4;
+                sc->send_cmvs = uea_send_cmvs_e4;
+                INIT_WORK(&sc->task, uea_load_page_e4);
+        } else {
+                size = E1_INTR_PKT_SIZE;
+                sc->dispatch_cmv = uea_dispatch_cmv_e1;
+                sc->schedule_load_page = uea_schedule_load_page_e1;
+                sc->stat = uea_stat_e1;
+                sc->send_cmvs = uea_send_cmvs_e1;
+                INIT_WORK(&sc->task, uea_load_page_e1);
+        }
+
         init_waitqueue_head(&sc->sync_q);
-        init_waitqueue_head(&sc->cmv_ack_wait);
+
+        sc->work_q = create_workqueue("ueagle-dsp");
+        if (!sc->work_q) {
+                uea_err(INS_TO_USBDEV(sc), "cannot allocate workqueue\n");
+                uea_leaves(INS_TO_USBDEV(sc));
+                return -ENOMEM;
+        }
 
         if (UEA_CHIP_VERSION(sc) == ADI930)
                 load_XILINX_firmware(sc);
 
-        intr = kmalloc(INTR_PKT_SIZE, GFP_KERNEL);
+        intr = kmalloc(size, GFP_KERNEL);
         if (!intr) {
                 uea_err(INS_TO_USBDEV(sc),
                        "cannot allocate interrupt package\n");
-                uea_leaves(INS_TO_USBDEV(sc));
-                return -ENOMEM;
+                goto err0;
         }
 
         sc->urb_int = usb_alloc_urb(0, GFP_KERNEL);
         if (!sc->urb_int) {
                 uea_err(INS_TO_USBDEV(sc), "cannot allocate interrupt URB\n");
-                goto err;
+                goto err1;
         }
 
         usb_fill_int_urb(sc->urb_int, sc->usb_dev,
                          usb_rcvintpipe(sc->usb_dev, UEA_INTR_PIPE),
-                         intr, INTR_PKT_SIZE, uea_intr, sc,
+                         intr, size, uea_intr, sc,
                          sc->usb_dev->actconfig->interface[0]->altsetting[0].
                          endpoint[0].desc.bInterval);
 
@@ -1385,7 +2161,7 @@ static int uea_boot(struct uea_softc *sc)
         if (ret < 0) {
                 uea_err(INS_TO_USBDEV(sc),
                        "urb submition failed with error %d\n", ret);
-                goto err;
+                goto err1;
         }
 
         sc->kthread = kthread_run(uea_kthread, sc, "ueagle-atm");
@@ -1399,10 +2175,12 @@ static int uea_boot(struct uea_softc *sc)
 
 err2:
         usb_kill_urb(sc->urb_int);
-err:
+err1:
         usb_free_urb(sc->urb_int);
         sc->urb_int = NULL;
         kfree(intr);
+err0:
+        destroy_workqueue(sc->work_q);
         uea_leaves(INS_TO_USBDEV(sc));
         return -ENOMEM;
 }
@@ -1417,15 +2195,15 @@ static void uea_stop(struct uea_softc *sc)
         ret = kthread_stop(sc->kthread);
         uea_dbg(INS_TO_USBDEV(sc), "kthread finish with status %d\n", ret);
 
-        /* stop any pending boot process */
-        flush_scheduled_work();
-
         uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL);
 
         usb_kill_urb(sc->urb_int);
         kfree(sc->urb_int->transfer_buffer);
         usb_free_urb(sc->urb_int);
 
+        /* stop any pending boot process, when no one can schedule work */
+        destroy_workqueue(sc->work_q);
+
         if (sc->dsp_firm)
                 release_firmware(sc->dsp_firm);
         uea_leaves(INS_TO_USBDEV(sc));
@@ -1487,6 +2265,7 @@ static ssize_t read_human_status(struct device *dev, struct device_attribute *at
                 char *buf)
 {
         int ret = -ENODEV;
+        int modem_state;
         struct uea_softc *sc;
 
         mutex_lock(&uea_mutex);
@@ -1494,7 +2273,34 @@ static ssize_t read_human_status(struct device *dev, struct device_attribute *at
         if (!sc)
                 goto out;
 
-        switch (GET_STATUS(sc->stats.phy.state)) {
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV) {
+                switch (sc->stats.phy.state) {
+                case 0x0:       /* not yet synchronized */
+                case 0x1:
+                case 0x3:
+                case 0x4:
+                        modem_state = 0;
+                        break;
+                case 0x5:       /* initialization */
+                case 0x6:
+                case 0x9:
+                case 0xa:
+                        modem_state = 1;
+                        break;
+                case 0x7:       /* operational */
+                        modem_state = 2;
+                        break;
+                case 0x2:       /* fail ... */
+                        modem_state = 3;
+                        break;
+                default:        /* unknown */
+                        modem_state = 4;
+                        break;
+                }
+        } else
+                modem_state = GET_STATUS(sc->stats.phy.state);
+
+        switch (modem_state) {
         case 0:
                 ret = sprintf(buf, "Modem is booting\n");
                 break;
@@ -1504,9 +2310,12 @@ static ssize_t read_human_status(struct device *dev, struct device_attribute *at
         case 2:
                 ret = sprintf(buf, "Modem is operational\n");
                 break;
-        default:
+        case 3:
                 ret = sprintf(buf, "Modem synchronization failed\n");
                 break;
+        default:
+                ret = sprintf(buf, "Modem state is unknown\n");
+                break;
         }
 out:
         mutex_unlock(&uea_mutex);
@@ -1520,18 +2329,26 @@ static ssize_t read_delin(struct device *dev, struct device_attribute *attr,
 {
         int ret = -ENODEV;
         struct uea_softc *sc;
+        char *delin = "GOOD";
 
         mutex_lock(&uea_mutex);
         sc = dev_to_uea(dev);
         if (!sc)
                 goto out;
 
-        if (sc->stats.phy.flags & 0x0C00)
-                ret = sprintf(buf, "ERROR\n");
-        else if (sc->stats.phy.flags & 0x0030)
-                ret = sprintf(buf, "LOSS\n");
-        else
-                ret = sprintf(buf, "GOOD\n");
+        if (UEA_CHIP_VERSION(sc) == EAGLE_IV) {
+                if (sc->stats.phy.flags & 0x4000)
+                        delin = "RESET";
+                else if (sc->stats.phy.flags & 0x0001)
+                        delin = "LOSS";
+        } else {
+                if (sc->stats.phy.flags & 0x0C00)
+                        delin = "ERROR";
+                else if (sc->stats.phy.flags & 0x0030)
+                        delin = "LOSS";
+        }
+
+        ret = sprintf(buf, "%s\n", delin);
 out:
         mutex_unlock(&uea_mutex);
         return ret;
@@ -1662,6 +2479,7 @@ static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf,
         struct usb_device *usb = interface_to_usbdev(intf);
         struct uea_softc *sc;
         int ret, ifnum = intf->altsetting->desc.bInterfaceNumber;
+        unsigned int alt;
 
         uea_enters(usb);
 
@@ -1696,22 +2514,29 @@ static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf,
         sc->modem_index = (modem_index < NB_MODEM) ? modem_index++ : 0;
         sc->driver_info = id->driver_info;
 
-        /* ADI930 don't support iso */
-        if (UEA_CHIP_VERSION(id) != ADI930 && use_iso[sc->modem_index]) {
-                int i;
-
-                /* try set fastest alternate for inbound traffic interface */
-                for (i = FASTEST_ISO_INTF; i > 0; i--)
-                        if (usb_set_interface(usb, UEA_DS_IFACE_NO, i) == 0)
-                                break;
+        /* first try to use module parameter */
+        if (annex[sc->modem_index] == 1)
+                sc->annex = ANNEXA;
+        else if (annex[sc->modem_index] == 2)
+                sc->annex = ANNEXB;
+        /* try to autodetect annex */
+        else if (sc->driver_info & AUTO_ANNEX_A)
+                sc->annex = ANNEXA;
+        else if (sc->driver_info & AUTO_ANNEX_B)
+                sc->annex = ANNEXB;
+        else
+                sc->annex = (le16_to_cpu(sc->usb_dev->descriptor.bcdDevice) & 0x80)?ANNEXB:ANNEXA;
 
-                if (i > 0) {
-                        uea_dbg(usb, "set alternate %d for 2 interface\n", i);
+        alt = altsetting[sc->modem_index];
+        /* ADI930 don't support iso */
+        if (UEA_CHIP_VERSION(id) != ADI930 && alt > 0) {
+                if (alt <= 8 && usb_set_interface(usb, UEA_DS_IFACE_NO, alt) == 0) {
+                        uea_dbg(usb, "set alternate %u for 2 interface\n", alt);
                         uea_info(usb, "using iso mode\n");
                         usbatm->flags |= UDSL_USE_ISOC | UDSL_IGNORE_EILSEQ;
                 } else {
-                        uea_err(usb, "setting any alternate failed for "
-                                        "2 interface, using bulk mode\n");
+                        uea_err(usb, "setting alternate %u failed for "
+                                        "2 interface, using bulk mode\n", alt);
                 }
         }
 
@@ -1757,10 +2582,11 @@ static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id)
         struct usb_device *usb = interface_to_usbdev(intf);
 
         uea_enters(usb);
-        uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) : %s %s\n",
-               le16_to_cpu(usb->descriptor.idVendor),
-               le16_to_cpu(usb->descriptor.idProduct),
-               chip_name[UEA_CHIP_VERSION(id)], IS_ISDN(usb)?"isdn":"pots");
+        uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) Rev (%#X): %s\n",
+                le16_to_cpu(usb->descriptor.idVendor),
+                le16_to_cpu(usb->descriptor.idProduct),
+                le16_to_cpu(usb->descriptor.bcdDevice),
+                chip_name[UEA_CHIP_VERSION(id)]);
 
         usb_reset_device(usb);
 
@@ -1793,24 +2619,40 @@ static void uea_disconnect(struct usb_interface *intf)
  * List of supported VID/PID
  */
 static const struct usb_device_id uea_ids[] = {
+        {USB_DEVICE(ANALOG_VID, ADI930_PID_PREFIRM),    .driver_info = ADI930 | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, ADI930_PID_PSTFIRM),    .driver_info = ADI930 | PSTFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PREFIRM),   .driver_info = EAGLE_I | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PSTFIRM),   .driver_info = EAGLE_I | PSTFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PREFIRM),  .driver_info = EAGLE_II | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PSTFIRM),  .driver_info = EAGLE_II | PSTFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PREFIRM), .driver_info = EAGLE_III | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PSTFIRM), .driver_info = EAGLE_III | PSTFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PREFIRM),  .driver_info = EAGLE_IV | PREFIRM},
+        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PSTFIRM),  .driver_info = EAGLE_IV | PSTFIRM},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_A},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
+        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_B},
         {USB_DEVICE(ELSA_VID,   ELSA_PID_PREFIRM),      .driver_info = ADI930 | PREFIRM},
         {USB_DEVICE(ELSA_VID,   ELSA_PID_PSTFIRM),      .driver_info = ADI930 | PSTFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_I_PID_PREFIRM),   .driver_info = EAGLE_I | PREFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_I_PID_PSTFIRM),   .driver_info = EAGLE_I | PSTFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_II_PID_PREFIRM),  .driver_info = EAGLE_II | PREFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_II_PID_PSTFIRM),  .driver_info = EAGLE_II | PSTFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_IIC_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_IIC_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_III_PID_PREFIRM), .driver_info = EAGLE_III | PREFIRM},
-        {USB_DEVICE(EAGLE_VID,  EAGLE_III_PID_PSTFIRM), .driver_info = EAGLE_III | PSTFIRM},
+        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PREFIRM),    .driver_info = ADI930 | PREFIRM},
+        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PSTFIRM),    .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_A},
+        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PREFIRM),    .driver_info = ADI930 | PREFIRM},
+        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PSTFIRM),    .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_B},
         {USB_DEVICE(USR_VID,    MILLER_A_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
-        {USB_DEVICE(USR_VID,    MILLER_A_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM},
+        {USB_DEVICE(USR_VID,    MILLER_A_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_A},
         {USB_DEVICE(USR_VID,    MILLER_B_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
-        {USB_DEVICE(USR_VID,    MILLER_B_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM},
+        {USB_DEVICE(USR_VID,    MILLER_B_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_B},
         {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
-        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM},
+        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
         {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
-        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM},
+        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
         {}
 };
 
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 5192cd9356..ad632f2d6f 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -28,6 +28,7 @@
  *      v0.12 - add hpoj.sourceforge.net ioctls (David Paschal)
  *      v0.13 - alloc space for statusbuf (<status> not on stack);
  *              use usb_buffer_alloc() for read buf & write buf;
+ *      none  - Maintained in Linux kernel after v0.13
  */
 
 /*
@@ -69,7 +70,6 @@
 #define USBLP_DEVICE_ID_SIZE    1024
 
 /* ioctls: */
-#define LPGETSTATUS             0x060b          /* same as in drivers/char/lp.c */
 #define IOCNR_GET_DEVICE_ID             1
 #define IOCNR_GET_PROTOCOLS             2
 #define IOCNR_SET_PROTOCOL              3
@@ -115,7 +115,7 @@ MFG:HEWLETT-PACKARD;MDL:DESKJET 970C;CMD:MLC,PCL,PML;CLASS:PRINTER;DESCRIPTION:H
 #define USBLP_MINORS            16
 #define USBLP_MINOR_BASE        0
 
-#define USBLP_WRITE_TIMEOUT     (5000)                  /* 5 seconds */
+#define USBLP_CTL_TIMEOUT       5000                    /* 5 seconds */
 
 #define USBLP_FIRST_PROTOCOL    1
 #define USBLP_LAST_PROTOCOL     3
@@ -159,10 +159,12 @@ struct usblp {
         int                     wstatus;        /* bytes written or error */
         int                     rstatus;        /* bytes ready or error */
         unsigned int            quirks;                 /* quirks flags */
+        unsigned int            flags;                  /* mode flags */
         unsigned char           used;                   /* True if open */
         unsigned char           present;                /* True if not disconnected */
         unsigned char           bidir;                  /* interface is bidirectional */
         unsigned char           sleeping;               /* interface is suspended */
+        unsigned char           no_paper;               /* Paper Out happened */
         unsigned char           *device_id_string;      /* IEEE 1284 DEVICE ID string (ptr) */
                                                         /* first 2 bytes are (big-endian) length */
 };
@@ -259,7 +261,7 @@ static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, i
 
         retval = usb_control_msg(usblp->dev,
                 dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
-                request, type | dir | recip, value, index, buf, len, USBLP_WRITE_TIMEOUT);
+                request, type | dir | recip, value, index, buf, len, USBLP_CTL_TIMEOUT);
         dbg("usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d idx: %d len: %#x result: %d",
                 request, !!dir, recip, value, index, len, retval);
         return retval < 0 ? retval : 0;
@@ -325,13 +327,11 @@ static void usblp_bulk_write(struct urb *urb)
                 usblp->wstatus = status;
         else
                 usblp->wstatus = urb->actual_length;
+        usblp->no_paper = 0;
         usblp->wcomplete = 1;
         wake_up(&usblp->wwait);
         spin_unlock(&usblp->lock);
 
-        /* XXX Use usb_setup_bulk_urb when available. Talk to Marcel. */
-        kfree(urb->transfer_buffer);
-        urb->transfer_buffer = NULL;    /* Not refcounted, so to be safe... */
         usb_free_urb(urb);
 }
 
@@ -346,16 +346,17 @@ static int usblp_check_status(struct usblp *usblp, int err)
         unsigned char status, newerr = 0;
         int error;
 
-        error = usblp_read_status (usblp, usblp->statusbuf);
-        if (error < 0) {
+        mutex_lock(&usblp->mut);
+        if ((error = usblp_read_status(usblp, usblp->statusbuf)) < 0) {
+                mutex_unlock(&usblp->mut);
                 if (printk_ratelimit())
                         printk(KERN_ERR
                                 "usblp%d: error %d reading printer status\n",
                                 usblp->minor, error);
                 return 0;
         }
-
         status = *usblp->statusbuf;
+        mutex_unlock(&usblp->mut);
 
         if (~status & LP_PERRORP)
                 newerr = 3;
@@ -411,18 +412,10 @@ static int usblp_open(struct inode *inode, struct file *file)
                 goto out;
 
         /*
-         * TODO: need to implement LP_ABORTOPEN + O_NONBLOCK as in drivers/char/lp.c ???
-         * This is #if 0-ed because we *don't* want to fail an open
-         * just because the printer is off-line.
+         * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:
+         *  - We do not want persistent state which close(2) does not clear
+         *  - It is not used anyway, according to CUPS people
          */
-#if 0
-        if ((retval = usblp_check_status(usblp, 0))) {
-                retval = retval > 1 ? -EIO : -ENOSPC;
-                goto out;
-        }
-#else
-        retval = 0;
-#endif
 
         retval = usb_autopm_get_interface(intf);
         if (retval < 0)
@@ -463,6 +456,8 @@ static int usblp_release(struct inode *inode, struct file *file)
 {
         struct usblp *usblp = file->private_data;
 
+        usblp->flags &= ~LP_ABORT;
+
         mutex_lock (&usblp_mutex);
         usblp->used = 0;
         if (usblp->present) {
@@ -485,8 +480,8 @@ static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait
         poll_wait(file, &usblp->rwait, wait);
         poll_wait(file, &usblp->wwait, wait);
         spin_lock_irqsave(&usblp->lock, flags);
-        ret = ((!usblp->bidir || !usblp->rcomplete) ? 0 : POLLIN  | POLLRDNORM)
-                               | (!usblp->wcomplete ? 0 : POLLOUT | POLLWRNORM);
+        ret = ((usblp->bidir && usblp->rcomplete) ? POLLIN  | POLLRDNORM : 0) |
+           ((usblp->no_paper || usblp->wcomplete) ? POLLOUT | POLLWRNORM : 0);
         spin_unlock_irqrestore(&usblp->lock, flags);
         return ret;
 }
@@ -675,6 +670,13 @@ static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                         retval = -EFAULT;
                                 break;
 
+                        case LPABORT:
+                                if (arg)
+                                        usblp->flags |= LP_ABORT;
+                                else
+                                        usblp->flags &= ~LP_ABORT;
+                                break;
+
                         default:
                                 retval = -ENOTTY;
                 }
@@ -684,10 +686,30 @@ done:
         return retval;
 }
 
+static struct urb *usblp_new_writeurb(struct usblp *usblp, int transfer_length)
+{
+        struct urb *urb;
+        char *writebuf;
+
+        if ((writebuf = kmalloc(transfer_length, GFP_KERNEL)) == NULL)
+                return NULL;
+        if ((urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL) {
+                kfree(writebuf);
+                return NULL;
+        }
+
+        usb_fill_bulk_urb(urb, usblp->dev,
+                usb_sndbulkpipe(usblp->dev,
+                 usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
+                writebuf, transfer_length, usblp_bulk_write, usblp);
+        urb->transfer_flags |= URB_FREE_BUFFER;
+
+        return urb;
+}
+
 static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
         struct usblp *usblp = file->private_data;
-        char *writebuf;
         struct urb *writeurb;
         int rv;
         int transfer_length;
@@ -708,17 +730,11 @@ static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t
                         transfer_length = USBLP_BUF_SIZE;
 
                 rv = -ENOMEM;
-                if ((writebuf = kmalloc(USBLP_BUF_SIZE, GFP_KERNEL)) == NULL)
-                        goto raise_buf;
-                if ((writeurb = usb_alloc_urb(0, GFP_KERNEL)) == NULL)
+                if ((writeurb = usblp_new_writeurb(usblp, transfer_length)) == NULL)
                         goto raise_urb;
-                usb_fill_bulk_urb(writeurb, usblp->dev,
-                        usb_sndbulkpipe(usblp->dev,
-                          usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
-                        writebuf, transfer_length, usblp_bulk_write, usblp);
                 usb_anchor_urb(writeurb, &usblp->urbs);
 
-                if (copy_from_user(writebuf,
+                if (copy_from_user(writeurb->transfer_buffer,
                                    buffer + writecount, transfer_length)) {
                         rv = -EFAULT;
                         goto raise_badaddr;
@@ -730,6 +746,7 @@ static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t
                 if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {
                         usblp->wstatus = 0;
                         spin_lock_irq(&usblp->lock);
+                        usblp->no_paper = 0;
                         usblp->wcomplete = 1;
                         wake_up(&usblp->wwait);
                         spin_unlock_irq(&usblp->lock);
@@ -747,12 +764,17 @@ static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t
                                 /* Presume that it's going to complete well. */
                                 writecount += transfer_length;
                         }
+                        if (rv == -ENOSPC) {
+                                spin_lock_irq(&usblp->lock);
+                                usblp->no_paper = 1;    /* Mark for poll(2) */
+                                spin_unlock_irq(&usblp->lock);
+                                writecount += transfer_length;
+                        }
                         /* Leave URB dangling, to be cleaned on close. */
                         goto collect_error;
                 }
 
                 if (usblp->wstatus < 0) {
-                        usblp_check_status(usblp, 0);
                         rv = -EIO;
                         goto collect_error;
                 }
@@ -771,8 +793,6 @@ raise_badaddr:
         usb_unanchor_urb(writeurb);
         usb_free_urb(writeurb);
 raise_urb:
-        kfree(writebuf);
-raise_buf:
 raise_wait:
 collect_error:          /* Out of raise sequence */
         mutex_unlock(&usblp->wmut);
@@ -838,32 +858,36 @@ done:
  * when O_NONBLOCK is set. So, applications setting O_NONBLOCK must use
  * select(2) or poll(2) to wait for the buffer to drain before closing.
  * Alternatively, set blocking mode with fcntl and issue a zero-size write.
- *
- * Old v0.13 code had a non-functional timeout for wait_event(). Someone forgot
- * to check the return code for timeout expiration, so it had no effect.
- * Apparently, it was intended to check for error conditons, such as out
- * of paper. It is going to return when we settle things with CUPS. XXX
  */
 static int usblp_wwait(struct usblp *usblp, int nonblock)
 {
         DECLARE_WAITQUEUE(waita, current);
         int rc;
+        int err = 0;
 
         add_wait_queue(&usblp->wwait, &waita);
         for (;;) {
+                set_current_state(TASK_INTERRUPTIBLE);
                 if (mutex_lock_interruptible(&usblp->mut)) {
                         rc = -EINTR;
                         break;
                 }
-                set_current_state(TASK_INTERRUPTIBLE);
-                if ((rc = usblp_wtest(usblp, nonblock)) < 0) {
-                        mutex_unlock(&usblp->mut);
-                        break;
-                }
+                rc = usblp_wtest(usblp, nonblock);
                 mutex_unlock(&usblp->mut);
-                if (rc == 0)
+                if (rc <= 0)
                         break;
-                schedule();
+
+                if (usblp->flags & LP_ABORT) {
+                        if (schedule_timeout(msecs_to_jiffies(5000)) == 0) {
+                                err = usblp_check_status(usblp, err);
+                                if (err == 1) { /* Paper out */
+                                        rc = -ENOSPC;
+                                        break;
+                                }
+                        }
+                } else {
+                        schedule();
+                }
         }
         set_current_state(TASK_RUNNING);
         remove_wait_queue(&usblp->wwait, &waita);
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index cb69aa1e02..1a8edcee7f 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -507,18 +507,30 @@ void usb_destroy_configuration(struct usb_device *dev)
 }
 
 
-// hub-only!! ... and only in reset path, or usb_new_device()
-// (used by real hubs and virtual root hubs)
+/*
+ * Get the USB config descriptors, cache and parse'em
+ *
+ * hub-only!! ... and only in reset path, or usb_new_device()
+ * (used by real hubs and virtual root hubs)
+ *
+ * NOTE: if this is a WUSB device and is not authorized, we skip the
+ *       whole thing. A non-authorized USB device has no
+ *       configurations.
+ */
 int usb_get_configuration(struct usb_device *dev)
 {
         struct device *ddev = &dev->dev;
         int ncfg = dev->descriptor.bNumConfigurations;
-        int result = -ENOMEM;
+        int result = 0;
         unsigned int cfgno, length;
         unsigned char *buffer;
         unsigned char *bigbuffer;
         struct usb_config_descriptor *desc;
 
+        cfgno = 0;
+        if (dev->authorized == 0)       /* Not really an error */
+                goto out_not_authorized;
+        result = -ENOMEM;
         if (ncfg > USB_MAXCONFIG) {
                 dev_warn(ddev, "too many configurations: %d, "
                     "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG);
@@ -545,14 +557,15 @@ int usb_get_configuration(struct usb_device *dev)
                 goto err2;
         desc = (struct usb_config_descriptor *)buffer;
 
-        for (cfgno = 0; cfgno < ncfg; cfgno++) {
+        result = 0;
+        for (; cfgno < ncfg; cfgno++) {
                 /* We grab just the first descriptor so we know how long
                  * the whole configuration is */
                 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
                     buffer, USB_DT_CONFIG_SIZE);
                 if (result < 0) {
                         dev_err(ddev, "unable to read config index %d "
-                            "descriptor/%s\n", cfgno, "start");
+                            "descriptor/%s: %d\n", cfgno, "start", result);
                         dev_err(ddev, "chopping to %d config(s)\n", cfgno);
                         dev->descriptor.bNumConfigurations = cfgno;
                         break;
@@ -599,6 +612,7 @@ int usb_get_configuration(struct usb_device *dev)
 
 err:
         kfree(buffer);
+out_not_authorized:
         dev->descriptor.bNumConfigurations = cfgno;
 err2:
         if (result == -ENOMEM)
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 927a181120..f013b4012c 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -71,6 +71,7 @@ struct async {
         void __user *userbuffer;
         void __user *userurb;
         struct urb *urb;
+        int status;
         u32 secid;
 };
 
@@ -289,10 +290,8 @@ static void snoop_urb(struct urb *urb, void __user *userurb)
         if (!usbfs_snoop)
                 return;
 
-        if (urb->pipe & USB_DIR_IN)
-                dev_info(&urb->dev->dev, "direction=IN\n");
-        else
-                dev_info(&urb->dev->dev, "direction=OUT\n");
+        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",
                  urb->transfer_buffer_length);
@@ -312,9 +311,10 @@ static void async_completed(struct urb *urb)
         spin_lock(&ps->lock);
         list_move_tail(&as->asynclist, &ps->async_completed);
         spin_unlock(&ps->lock);
+        as->status = urb->status;
         if (as->signr) {
                 sinfo.si_signo = as->signr;
-                sinfo.si_errno = as->urb->status;
+                sinfo.si_errno = as->status;
                 sinfo.si_code = SI_ASYNCIO;
                 sinfo.si_addr = as->userurb;
                 kill_pid_info_as_uid(as->signr, &sinfo, as->pid, as->uid,
@@ -910,6 +910,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
         struct usb_ctrlrequest *dr = NULL;
         unsigned int u, totlen, isofrmlen;
         int ret, ifnum = -1;
+        int is_in;
 
         if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP|USBDEVFS_URB_SHORT_NOT_OK|
                            URB_NO_FSBR|URB_ZERO_PACKET))
@@ -924,16 +925,18 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 if ((ret = checkintf(ps, ifnum)))
                         return ret;
         }
-        if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0)
-                ep = ps->dev->ep_in [uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
-        else
-                ep = ps->dev->ep_out [uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
+        if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0) {
+                is_in = 1;
+                ep = ps->dev->ep_in[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
+        } else {
+                is_in = 0;
+                ep = ps->dev->ep_out[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
+        }
         if (!ep)
                 return -ENOENT;
         switch(uurb->type) {
         case USBDEVFS_URB_TYPE_CONTROL:
-                if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-                                != USB_ENDPOINT_XFER_CONTROL)
+                if (!usb_endpoint_xfer_control(&ep->desc))
                         return -EINVAL;
                 /* min 8 byte setup packet, max 8 byte setup plus an arbitrary data stage */
                 if (uurb->buffer_length < 8 || uurb->buffer_length > (8 + MAX_USBFS_BUFFER_SIZE))
@@ -952,23 +955,32 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         kfree(dr);
                         return ret;
                 }
-                uurb->endpoint = (uurb->endpoint & ~USB_ENDPOINT_DIR_MASK) | (dr->bRequestType & USB_ENDPOINT_DIR_MASK);
                 uurb->number_of_packets = 0;
                 uurb->buffer_length = le16_to_cpup(&dr->wLength);
                 uurb->buffer += 8;
-                if (!access_ok((uurb->endpoint & USB_DIR_IN) ?  VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length)) {
+                if ((dr->bRequestType & USB_DIR_IN) && uurb->buffer_length) {
+                        is_in = 1;
+                        uurb->endpoint |= USB_DIR_IN;
+                } else {
+                        is_in = 0;
+                        uurb->endpoint &= ~USB_DIR_IN;
+                }
+                if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
+                                uurb->buffer, uurb->buffer_length)) {
                         kfree(dr);
                         return -EFAULT;
                 }
                 snoop(&ps->dev->dev, "control urb: bRequest=%02x "
                         "bRrequestType=%02x wValue=%04x "
                         "wIndex=%04x wLength=%04x\n",
-                        dr->bRequest, dr->bRequestType, dr->wValue,
-                        dr->wIndex, dr->wLength);
+                        dr->bRequest, dr->bRequestType,
+                        __le16_to_cpup(&dr->wValue),
+                        __le16_to_cpup(&dr->wIndex),
+                        __le16_to_cpup(&dr->wLength));
                 break;
 
         case USBDEVFS_URB_TYPE_BULK:
-                switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+                switch (usb_endpoint_type(&ep->desc)) {
                 case USB_ENDPOINT_XFER_CONTROL:
                 case USB_ENDPOINT_XFER_ISOC:
                         return -EINVAL;
@@ -977,7 +989,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 uurb->number_of_packets = 0;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length))
+                if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
+                                uurb->buffer, uurb->buffer_length))
                         return -EFAULT;
                 snoop(&ps->dev->dev, "bulk urb\n");
                 break;
@@ -986,8 +999,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 /* arbitrary limit */
                 if (uurb->number_of_packets < 1 || uurb->number_of_packets > 128)
                         return -EINVAL;
-                if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-                                != USB_ENDPOINT_XFER_ISOC)
+                if (!usb_endpoint_xfer_isoc(&ep->desc))
                         return -EINVAL;
                 isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) * uurb->number_of_packets;
                 if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
@@ -1014,12 +1026,12 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
 
         case USBDEVFS_URB_TYPE_INTERRUPT:
                 uurb->number_of_packets = 0;
-                if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-                                != USB_ENDPOINT_XFER_INT)
+                if (!usb_endpoint_xfer_int(&ep->desc))
                         return -EINVAL;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length))
+                if (!access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
+                                uurb->buffer, uurb->buffer_length))
                         return -EFAULT;
                 snoop(&ps->dev->dev, "interrupt urb\n");
                 break;
@@ -1039,8 +1051,11 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 return -ENOMEM;
         }
         as->urb->dev = ps->dev;
-        as->urb->pipe = (uurb->type << 30) | __create_pipe(ps->dev, uurb->endpoint & 0xf) | (uurb->endpoint & USB_DIR_IN);
-        as->urb->transfer_flags = uurb->flags;
+        as->urb->pipe = (uurb->type << 30) |
+                        __create_pipe(ps->dev, uurb->endpoint & 0xf) |
+                        (uurb->endpoint & USB_DIR_IN);
+        as->urb->transfer_flags = uurb->flags |
+                        (is_in ? URB_DIR_IN : URB_DIR_OUT);
         as->urb->transfer_buffer_length = uurb->buffer_length;
         as->urb->setup_packet = (unsigned char*)dr;
         as->urb->start_frame = uurb->start_frame;
@@ -1070,13 +1085,13 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
         as->uid = current->uid;
         as->euid = current->euid;
         security_task_getsecid(current, &as->secid);
-        if (!(uurb->endpoint & USB_DIR_IN)) {
-                if (copy_from_user(as->urb->transfer_buffer, uurb->buffer, as->urb->transfer_buffer_length)) {
+        if (!is_in) {
+                if (copy_from_user(as->urb->transfer_buffer, uurb->buffer,
+                                as->urb->transfer_buffer_length)) {
                         free_async(as);
                         return -EFAULT;
                 }
         }
-        snoop(&as->urb->dev->dev, "submit urb\n");
         snoop_urb(as->urb, as->userurb);
         async_newpending(as);
         if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
@@ -1119,14 +1134,14 @@ static int processcompl(struct async *as, void __user * __user *arg)
         if (as->userbuffer)
                 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length))
                         return -EFAULT;
-        if (put_user(urb->status, &userurb->status))
+        if (put_user(as->status, &userurb->status))
                 return -EFAULT;
         if (put_user(urb->actual_length, &userurb->actual_length))
                 return -EFAULT;
         if (put_user(urb->error_count, &userurb->error_count))
                 return -EFAULT;
 
-        if (usb_pipeisoc(urb->pipe)) {
+        if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
                 for (i = 0; i < urb->number_of_packets; i++) {
                         if (put_user(urb->iso_frame_desc[i].actual_length,
                                      &userurb->iso_frame_desc[i].actual_length))
@@ -1233,14 +1248,14 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
         if (as->userbuffer)
                 if (copy_to_user(as->userbuffer, urb->transfer_buffer, urb->transfer_buffer_length))
                         return -EFAULT;
-        if (put_user(urb->status, &userurb->status))
+        if (put_user(as->status, &userurb->status))
                 return -EFAULT;
         if (put_user(urb->actual_length, &userurb->actual_length))
                 return -EFAULT;
         if (put_user(urb->error_count, &userurb->error_count))
                 return -EFAULT;
 
-        if (usb_pipeisoc(urb->pipe)) {
+        if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
                 for (i = 0; i < urb->number_of_packets; i++) {
                         if (put_user(urb->iso_frame_desc[i].actual_length,
                                      &userurb->iso_frame_desc[i].actual_length))
@@ -1576,6 +1591,7 @@ static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wai
 }
 
 const struct file_operations usbdev_file_operations = {
+        .owner =        THIS_MODULE,
         .llseek =       usbdev_lseek,
         .read =         usbdev_read,
         .poll =         usbdev_poll,
@@ -1625,10 +1641,7 @@ static struct notifier_block usbdev_nb = {
 };
 #endif
 
-static struct cdev usb_device_cdev = {
-        .kobj   = {.name = "usb_device", },
-        .owner  = THIS_MODULE,
-};
+static struct cdev usb_device_cdev;
 
 int __init usb_devio_init(void)
 {
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 63b1243a91..8586817698 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -202,6 +202,11 @@ static int usb_probe_interface(struct device *dev)
         intf = to_usb_interface(dev);
         udev = interface_to_usbdev(intf);
 
+        if (udev->authorized == 0) {
+                dev_err(&intf->dev, "Device is not authorized for usage\n");
+                return -ENODEV;
+        }
+
         id = usb_match_id(intf, driver->id_table);
         if (!id)
                 id = usb_match_dynamic_id(intf, driver);
@@ -576,12 +581,9 @@ static int usb_device_match(struct device *dev, struct device_driver *drv)
 }
 
 #ifdef  CONFIG_HOTPLUG
-static int usb_uevent(struct device *dev, char **envp, int num_envp,
-                      char *buffer, int buffer_size)
+static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct usb_device *usb_dev;
-        int i = 0;
-        int length = 0;
 
         if (!dev)
                 return -ENODEV;
@@ -610,51 +612,39 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp,
          * all the device descriptors we don't tell them about.  Or
          * act as usermode drivers.
          */
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "DEVICE=/proc/bus/usb/%03d/%03d",
+        if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
                            usb_dev->bus->busnum, usb_dev->devnum))
                 return -ENOMEM;
 #endif
 
         /* per-device configurations are common */
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PRODUCT=%x/%x/%x",
+        if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
                            le16_to_cpu(usb_dev->descriptor.idVendor),
                            le16_to_cpu(usb_dev->descriptor.idProduct),
                            le16_to_cpu(usb_dev->descriptor.bcdDevice)))
                 return -ENOMEM;
 
         /* class-based driver binding models */
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "TYPE=%d/%d/%d",
+        if (add_uevent_var(env, "TYPE=%d/%d/%d",
                            usb_dev->descriptor.bDeviceClass,
                            usb_dev->descriptor.bDeviceSubClass,
                            usb_dev->descriptor.bDeviceProtocol))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "BUSNUM=%03d",
+        if (add_uevent_var(env, "BUSNUM=%03d",
                            usb_dev->bus->busnum))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "DEVNUM=%03d",
+        if (add_uevent_var(env, "DEVNUM=%03d",
                            usb_dev->devnum))
                 return -ENOMEM;
 
-        envp[i] = NULL;
         return 0;
 }
 
 #else
 
-static int usb_uevent(struct device *dev, char **envp,
-                      int num_envp, char *buffer, int buffer_size)
+static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
@@ -945,11 +935,11 @@ done:
 #ifdef  CONFIG_USB_SUSPEND
 
 /* Internal routine to check whether we may autosuspend a device. */
-static int autosuspend_check(struct usb_device *udev)
+static int autosuspend_check(struct usb_device *udev, int reschedule)
 {
         int                     i;
         struct usb_interface    *intf;
-        unsigned long           suspend_time;
+        unsigned long           suspend_time, j;
 
         /* For autosuspend, fail fast if anything is in use or autosuspend
          * is disabled.  Also fail if any interfaces require remote wakeup
@@ -991,20 +981,20 @@ static int autosuspend_check(struct usb_device *udev)
         }
 
         /* If everything is okay but the device hasn't been idle for long
-         * enough, queue a delayed autosuspend request.
+         * enough, queue a delayed autosuspend request.  If the device
+         * _has_ been idle for long enough and the reschedule flag is set,
+         * likewise queue a delayed (1 second) autosuspend request.
          */
-        if (time_after(suspend_time, jiffies)) {
+        j = jiffies;
+        if (time_before(j, suspend_time))
+                reschedule = 1;
+        else
+                suspend_time = j + HZ;
+        if (reschedule) {
                 if (!timer_pending(&udev->autosuspend.timer)) {
-
-                        /* The value of jiffies may change between the
-                         * time_after() comparison above and the subtraction
-                         * below.  That's okay; the system behaves sanely
-                         * when a timer is registered for the present moment
-                         * or for the past.
-                         */
                         queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
-                                round_jiffies_relative(suspend_time - jiffies));
-                        }
+                                round_jiffies_relative(suspend_time - j));
+                }
                 return -EAGAIN;
         }
         return 0;
@@ -1012,7 +1002,7 @@ static int autosuspend_check(struct usb_device *udev)
 
 #else
 
-static inline int autosuspend_check(struct usb_device *udev)
+static inline int autosuspend_check(struct usb_device *udev, int reschedule)
 {
         return 0;
 }
@@ -1069,7 +1059,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
         udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
 
         if (udev->auto_pm) {
-                status = autosuspend_check(udev);
+                status = autosuspend_check(udev, 0);
                 if (status < 0)
                         goto done;
         }
@@ -1083,15 +1073,8 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
                                 break;
                 }
         }
-        if (status == 0) {
-
-                /* Non-root devices don't need to do anything for FREEZE
-                 * or PRETHAW. */
-                if (udev->parent && (msg.event == PM_EVENT_FREEZE ||
-                                msg.event == PM_EVENT_PRETHAW))
-                        goto done;
+        if (status == 0)
                 status = usb_suspend_device(udev, msg);
-        }
 
         /* If the suspend failed, resume interfaces that did get suspended */
         if (status != 0) {
@@ -1102,12 +1085,24 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 
                 /* Try another autosuspend when the interfaces aren't busy */
                 if (udev->auto_pm)
-                        autosuspend_check(udev);
+                        autosuspend_check(udev, status == -EBUSY);
 
-        /* If the suspend succeeded, propagate it up the tree */
+        /* If the suspend succeeded then prevent any more URB submissions,
+         * flush any outstanding URBs, and propagate the suspend up the tree.
+         */
         } else {
                 cancel_delayed_work(&udev->autosuspend);
-                if (parent)
+                udev->can_submit = 0;
+                for (i = 0; i < 16; ++i) {
+                        usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
+                        usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
+                }
+
+                /* If this is just a FREEZE or a PRETHAW, udev might
+                 * not really be suspended.  Only true suspends get
+                 * propagated up the device tree.
+                 */
+                if (parent && udev->state == USB_STATE_SUSPENDED)
                         usb_autosuspend_device(parent);
         }
 
@@ -1156,6 +1151,7 @@ static int usb_resume_both(struct usb_device *udev)
                 status = -ENODEV;
                 goto done;
         }
+        udev->can_submit = 1;
 
         /* Propagate the resume up the tree, if necessary */
         if (udev->state == USB_STATE_SUSPENDED) {
@@ -1529,9 +1525,21 @@ int usb_external_resume_device(struct usb_device *udev)
 
 static int usb_suspend(struct device *dev, pm_message_t message)
 {
+        struct usb_device       *udev;
+
         if (!is_usb_device(dev))        /* Ignore PM for interfaces */
                 return 0;
-        return usb_external_suspend_device(to_usb_device(dev), message);
+        udev = to_usb_device(dev);
+
+        /* If udev is already suspended, we can skip this suspend and
+         * we should also skip the upcoming system resume. */
+        if (udev->state == USB_STATE_SUSPENDED) {
+                udev->skip_sys_resume = 1;
+                return 0;
+        }
+
+        udev->skip_sys_resume = 0;
+        return usb_external_suspend_device(udev, message);
 }
 
 static int usb_resume(struct device *dev)
@@ -1542,13 +1550,14 @@ static int usb_resume(struct device *dev)
                 return 0;
         udev = to_usb_device(dev);
 
-        /* If autoresume is disabled then we also want to prevent resume
-         * during system wakeup.  However, a "persistent-device" reset-resume
-         * after power loss counts as a wakeup event.  So allow a
-         * reset-resume to occur if remote wakeup is enabled. */
-        if (udev->autoresume_disabled) {
+        /* If udev->skip_sys_resume is set then udev was already suspended
+         * when the system suspend started, so we don't want to resume
+         * udev during this system wakeup.  However a reset-resume counts
+         * as a wakeup event, so allow a reset-resume to occur if remote
+         * wakeup is enabled. */
+        if (udev->skip_sys_resume) {
                 if (!(udev->reset_resume && udev->do_remote_wakeup))
-                        return -EPERM;
+                        return -EHOSTUNREACH;
         }
         return usb_external_resume_device(udev);
 }
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index e0ec7045e8..7dc123d6b2 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -267,7 +267,6 @@ static void ep_device_release(struct device *dev)
 {
         struct ep_device *ep_dev = to_ep_device(dev);
 
-        dev_dbg(dev, "%s called for %s\n", __FUNCTION__, dev->bus_id);
         endpoint_free_minor(ep_dev);
         kfree(ep_dev);
 }
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index b2fc2b1152..c1cb94e9f2 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -40,7 +40,7 @@ static int is_activesync(struct usb_interface_descriptor *desc)
                 && desc->bInterfaceProtocol == 1;
 }
 
-static int choose_configuration(struct usb_device *udev)
+int usb_choose_configuration(struct usb_device *udev)
 {
         int i;
         int num_configs;
@@ -161,17 +161,20 @@ static int generic_probe(struct usb_device *udev)
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
-        c = choose_configuration(udev);
-        if (c >= 0) {
-                err = usb_set_configuration(udev, c);
-                if (err) {
-                        dev_err(&udev->dev, "can't set config #%d, error %d\n",
+        if (udev->authorized == 0)
+                dev_err(&udev->dev, "Device is not authorized for usage\n");
+        else {
+                c = usb_choose_configuration(udev);
+                if (c >= 0) {
+                        err = usb_set_configuration(udev, c);
+                        if (err) {
+                                dev_err(&udev->dev, "can't set config #%d, error %d\n",
                                         c, err);
-                        /* This need not be fatal.  The user can try to
-                         * set other configurations. */
+                                /* This need not be fatal.  The user can try to
+                                 * set other configurations. */
+                        }
                 }
         }
-
         /* USB device state == configured ... usable */
         usb_notify_add_device(udev);
 
@@ -203,8 +206,13 @@ static int generic_suspend(struct usb_device *udev, pm_message_t msg)
          */
         if (!udev->parent)
                 rc = hcd_bus_suspend(udev);
+
+        /* Non-root devices don't need to do anything for FREEZE or PRETHAW */
+        else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
+                rc = 0;
         else
                 rc = usb_port_suspend(udev);
+
         return rc;
 }
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 42ef1d5f6c..3dd997df85 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -356,10 +356,18 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
         const u8        *bufp = tbuf;
         int             len = 0;
         int             patch_wakeup = 0;
-        unsigned long   flags;
-        int             status = 0;
+        int             status;
         int             n;
 
+        might_sleep();
+
+        spin_lock_irq(&hcd_root_hub_lock);
+        status = usb_hcd_link_urb_to_ep(hcd, urb);
+        spin_unlock_irq(&hcd_root_hub_lock);
+        if (status)
+                return status;
+        urb->hcpriv = hcd;      /* Indicate it's queued */
+
         cmd = (struct usb_ctrlrequest *) urb->setup_packet;
         typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;
         wValue   = le16_to_cpu (cmd->wValue);
@@ -523,13 +531,18 @@ error:
         }
 
         /* any errors get returned through the urb completion */
-        local_irq_save (flags);
-        spin_lock (&urb->lock);
-        if (urb->status == -EINPROGRESS)
-                urb->status = status;
-        spin_unlock (&urb->lock);
-        usb_hcd_giveback_urb (hcd, urb);
-        local_irq_restore (flags);
+        spin_lock_irq(&hcd_root_hub_lock);
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
+
+        /* This peculiar use of spinlocks echoes what real HC drivers do.
+         * Avoiding calls to local_irq_disable/enable makes the code
+         * RT-friendly.
+         */
+        spin_unlock(&hcd_root_hub_lock);
+        usb_hcd_giveback_urb(hcd, urb, status);
+        spin_lock(&hcd_root_hub_lock);
+
+        spin_unlock_irq(&hcd_root_hub_lock);
         return 0;
 }
 
@@ -559,31 +572,23 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
         if (length > 0) {
 
                 /* try to complete the status urb */
-                local_irq_save (flags);
-                spin_lock(&hcd_root_hub_lock);
+                spin_lock_irqsave(&hcd_root_hub_lock, flags);
                 urb = hcd->status_urb;
                 if (urb) {
-                        spin_lock(&urb->lock);
-                        if (urb->status == -EINPROGRESS) {
-                                hcd->poll_pending = 0;
-                                hcd->status_urb = NULL;
-                                urb->status = 0;
-                                urb->hcpriv = NULL;
-                                urb->actual_length = length;
-                                memcpy(urb->transfer_buffer, buffer, length);
-                        } else          /* urb has been unlinked */
-                                length = 0;
-                        spin_unlock(&urb->lock);
-                } else
-                        length = 0;
-                spin_unlock(&hcd_root_hub_lock);
+                        hcd->poll_pending = 0;
+                        hcd->status_urb = NULL;
+                        urb->actual_length = length;
+                        memcpy(urb->transfer_buffer, buffer, length);
 
-                /* local irqs are always blocked in completions */
-                if (length > 0)
-                        usb_hcd_giveback_urb (hcd, urb);
-                else
+                        usb_hcd_unlink_urb_from_ep(hcd, urb);
+                        spin_unlock(&hcd_root_hub_lock);
+                        usb_hcd_giveback_urb(hcd, urb, 0);
+                        spin_lock(&hcd_root_hub_lock);
+                } else {
+                        length = 0;
                         hcd->poll_pending = 1;
-                local_irq_restore (flags);
+                }
+                spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
         }
 
         /* The USB 2.0 spec says 256 ms.  This is close enough and won't
@@ -611,33 +616,35 @@ static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
         int             len = 1 + (urb->dev->maxchild / 8);
 
         spin_lock_irqsave (&hcd_root_hub_lock, flags);
-        if (urb->status != -EINPROGRESS)        /* already unlinked */
-                retval = urb->status;
-        else if (hcd->status_urb || urb->transfer_buffer_length < len) {
+        if (hcd->status_urb || urb->transfer_buffer_length < len) {
                 dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
                 retval = -EINVAL;
-        } else {
-                hcd->status_urb = urb;
-                urb->hcpriv = hcd;      /* indicate it's queued */
+                goto done;
+        }
 
-                if (!hcd->uses_new_polling)
-                        mod_timer (&hcd->rh_timer,
-                                (jiffies/(HZ/4) + 1) * (HZ/4));
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval)
+                goto done;
 
-                /* If a status change has already occurred, report it ASAP */
-                else if (hcd->poll_pending)
-                        mod_timer (&hcd->rh_timer, jiffies);
-                retval = 0;
-        }
+        hcd->status_urb = urb;
+        urb->hcpriv = hcd;      /* indicate it's queued */
+        if (!hcd->uses_new_polling)
+                mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
+
+        /* If a status change has already occurred, report it ASAP */
+        else if (hcd->poll_pending)
+                mod_timer(&hcd->rh_timer, jiffies);
+        retval = 0;
+ done:
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
         return retval;
 }
 
 static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
 {
-        if (usb_pipeint (urb->pipe))
+        if (usb_endpoint_xfer_int(&urb->ep->desc))
                 return rh_queue_status (hcd, urb);
-        if (usb_pipecontrol (urb->pipe))
+        if (usb_endpoint_xfer_control(&urb->ep->desc))
                 return rh_call_control (hcd, urb);
         return -EINVAL;
 }
@@ -647,32 +654,96 @@ static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
 /* Unlinks of root-hub control URBs are legal, but they don't do anything
  * since these URBs always execute synchronously.
  */
-static int usb_rh_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
+static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         unsigned long   flags;
+        int             rc;
+
+        spin_lock_irqsave(&hcd_root_hub_lock, flags);
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
+                goto done;
 
-        if (usb_pipeendpoint(urb->pipe) == 0) { /* Control URB */
+        if (usb_endpoint_num(&urb->ep->desc) == 0) {    /* Control URB */
                 ;       /* Do nothing */
 
         } else {                                /* Status URB */
                 if (!hcd->uses_new_polling)
                         del_timer (&hcd->rh_timer);
-                local_irq_save (flags);
-                spin_lock (&hcd_root_hub_lock);
                 if (urb == hcd->status_urb) {
                         hcd->status_urb = NULL;
-                        urb->hcpriv = NULL;
-                } else
-                        urb = NULL;             /* wasn't fully queued */
-                spin_unlock (&hcd_root_hub_lock);
-                if (urb)
-                        usb_hcd_giveback_urb (hcd, urb);
-                local_irq_restore (flags);
+                        usb_hcd_unlink_urb_from_ep(hcd, urb);
+
+                        spin_unlock(&hcd_root_hub_lock);
+                        usb_hcd_giveback_urb(hcd, urb, status);
+                        spin_lock(&hcd_root_hub_lock);
+                }
         }
+ done:
+        spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
+        return rc;
+}
 
-        return 0;
+
+
+/*
+ * Show & store the current value of authorized_default
+ */
+static ssize_t usb_host_authorized_default_show(struct device *dev,
+                                                struct device_attribute *attr,
+                                                char *buf)
+{
+        struct usb_device *rh_usb_dev = to_usb_device(dev);
+        struct usb_bus *usb_bus = rh_usb_dev->bus;
+        struct usb_hcd *usb_hcd;
+
+        if (usb_bus == NULL)    /* FIXME: not sure if this case is possible */
+                return -ENODEV;
+        usb_hcd = bus_to_hcd(usb_bus);
+        return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
+}
+
+static ssize_t usb_host_authorized_default_store(struct device *dev,
+                                                 struct device_attribute *attr,
+                                                 const char *buf, size_t size)
+{
+        ssize_t result;
+        unsigned val;
+        struct usb_device *rh_usb_dev = to_usb_device(dev);
+        struct usb_bus *usb_bus = rh_usb_dev->bus;
+        struct usb_hcd *usb_hcd;
+
+        if (usb_bus == NULL)    /* FIXME: not sure if this case is possible */
+                return -ENODEV;
+        usb_hcd = bus_to_hcd(usb_bus);
+        result = sscanf(buf, "%u\n", &val);
+        if (result == 1) {
+                usb_hcd->authorized_default = val? 1 : 0;
+                result = size;
+        }
+        else
+                result = -EINVAL;
+        return result;
 }
 
+static DEVICE_ATTR(authorized_default, 0644,
+            usb_host_authorized_default_show,
+            usb_host_authorized_default_store);
+
+
+/* Group all the USB bus attributes */
+static struct attribute *usb_bus_attrs[] = {
+                &dev_attr_authorized_default.attr,
+                NULL,
+};
+
+static struct attribute_group usb_bus_attr_group = {
+        .name = NULL,   /* we want them in the same directory */
+        .attrs = usb_bus_attrs,
+};
+
+
+
 /*-------------------------------------------------------------------------*/
 
 static struct class *usb_host_class;
@@ -726,27 +797,23 @@ static void usb_bus_init (struct usb_bus *bus)
  */
 static int usb_register_bus(struct usb_bus *bus)
 {
+        int result = -E2BIG;
         int busnum;
 
         mutex_lock(&usb_bus_list_lock);
         busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
-        if (busnum < USB_MAXBUS) {
-                set_bit (busnum, busmap.busmap);
-                bus->busnum = busnum;
-        } else {
+        if (busnum >= USB_MAXBUS) {
                 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
-                mutex_unlock(&usb_bus_list_lock);
-                return -E2BIG;
+                goto error_find_busnum;
         }
-
+        set_bit (busnum, busmap.busmap);
+        bus->busnum = busnum;
         bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0),
-                                             bus->controller, "usb_host%d", busnum);
-        if (IS_ERR(bus->class_dev)) {
-                clear_bit(busnum, busmap.busmap);
-                mutex_unlock(&usb_bus_list_lock);
-                return PTR_ERR(bus->class_dev);
-        }
-
+                                             bus->controller, "usb_host%d",
+                                             busnum);
+        result = PTR_ERR(bus->class_dev);
+        if (IS_ERR(bus->class_dev))
+                goto error_create_class_dev;
         class_set_devdata(bus->class_dev, bus);
 
         /* Add it to the local list of buses */
@@ -755,8 +822,15 @@ static int usb_register_bus(struct usb_bus *bus)
 
         usb_notify_add_bus(bus);
 
-        dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum);
+        dev_info (bus->controller, "new USB bus registered, assigned bus "
+                  "number %d\n", bus->busnum);
         return 0;
+
+error_create_class_dev:
+        clear_bit(busnum, busmap.busmap);
+error_find_busnum:
+        mutex_unlock(&usb_bus_list_lock);
+        return result;
 }
 
 /**
@@ -908,103 +982,145 @@ EXPORT_SYMBOL (usb_calc_bus_time);
 
 /*-------------------------------------------------------------------------*/
 
-static void urb_unlink(struct usb_hcd *hcd, struct urb *urb)
+/**
+ * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
+ * @hcd: host controller to which @urb was submitted
+ * @urb: URB being submitted
+ *
+ * Host controller drivers should call this routine in their enqueue()
+ * method.  The HCD's private spinlock must be held and interrupts must
+ * be disabled.  The actions carried out here are required for URB
+ * submission, as well as for endpoint shutdown and for usb_kill_urb.
+ *
+ * Returns 0 for no error, otherwise a negative error code (in which case
+ * the enqueue() method must fail).  If no error occurs but enqueue() fails
+ * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
+ * the private spinlock and returning.
+ */
+int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
 {
-        unsigned long           flags;
+        int             rc = 0;
 
-        /* clear all state linking urb to this dev (and hcd) */
-        spin_lock_irqsave(&hcd_urb_list_lock, flags);
-        list_del_init (&urb->urb_list);
-        spin_unlock_irqrestore(&hcd_urb_list_lock, flags);
+        spin_lock(&hcd_urb_list_lock);
 
-        if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
-                if (usb_pipecontrol (urb->pipe)
-                        && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
-                        dma_unmap_single (hcd->self.controller, urb->setup_dma,
-                                        sizeof (struct usb_ctrlrequest),
-                                        DMA_TO_DEVICE);
-                if (urb->transfer_buffer_length != 0
-                        && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
-                        dma_unmap_single (hcd->self.controller,
-                                        urb->transfer_dma,
-                                        urb->transfer_buffer_length,
-                                        usb_pipein (urb->pipe)
-                                            ? DMA_FROM_DEVICE
-                                            : DMA_TO_DEVICE);
+        /* Check that the URB isn't being killed */
+        if (unlikely(urb->reject)) {
+                rc = -EPERM;
+                goto done;
         }
-}
-
-/* may be called in any context with a valid urb->dev usecount
- * caller surrenders "ownership" of urb
- * expects usb_submit_urb() to have sanity checked and conditioned all
- * inputs in the urb
- */
-int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
-{
-        int                     status;
-        struct usb_hcd          *hcd = bus_to_hcd(urb->dev->bus);
-        struct usb_host_endpoint *ep;
-        unsigned long           flags;
 
-        if (!hcd)
-                return -ENODEV;
+        if (unlikely(!urb->ep->enabled)) {
+                rc = -ENOENT;
+                goto done;
+        }
 
-        usbmon_urb_submit(&hcd->self, urb);
+        if (unlikely(!urb->dev->can_submit)) {
+                rc = -EHOSTUNREACH;
+                goto done;
+        }
 
         /*
-         * Atomically queue the urb,  first to our records, then to the HCD.
-         * Access to urb->status is controlled by urb->lock ... changes on
-         * i/o completion (normal or fault) or unlinking.
+         * Check the host controller's state and add the URB to the
+         * endpoint's queue.
          */
-
-        // FIXME:  verify that quiescing hc works right (RH cleans up)
-
-        spin_lock_irqsave(&hcd_urb_list_lock, flags);
-        ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
-                        [usb_pipeendpoint(urb->pipe)];
-        if (unlikely (!ep))
-                status = -ENOENT;
-        else if (unlikely (urb->reject))
-                status = -EPERM;
-        else switch (hcd->state) {
+        switch (hcd->state) {
         case HC_STATE_RUNNING:
         case HC_STATE_RESUMING:
-                list_add_tail (&urb->urb_list, &ep->urb_list);
-                status = 0;
+                urb->unlinked = 0;
+                list_add_tail(&urb->urb_list, &urb->ep->urb_list);
                 break;
         default:
-                status = -ESHUTDOWN;
-                break;
+                rc = -ESHUTDOWN;
+                goto done;
         }
-        spin_unlock_irqrestore(&hcd_urb_list_lock, flags);
-        if (status) {
-                INIT_LIST_HEAD (&urb->urb_list);
-                usbmon_urb_submit_error(&hcd->self, urb, status);
-                return status;
+ done:
+        spin_unlock(&hcd_urb_list_lock);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
+
+/**
+ * usb_hcd_check_unlink_urb - check whether an URB may be unlinked
+ * @hcd: host controller to which @urb was submitted
+ * @urb: URB being checked for unlinkability
+ * @status: error code to store in @urb if the unlink succeeds
+ *
+ * Host controller drivers should call this routine in their dequeue()
+ * method.  The HCD's private spinlock must be held and interrupts must
+ * be disabled.  The actions carried out here are required for making
+ * sure than an unlink is valid.
+ *
+ * Returns 0 for no error, otherwise a negative error code (in which case
+ * the dequeue() method must fail).  The possible error codes are:
+ *
+ *      -EIDRM: @urb was not submitted or has already completed.
+ *              The completion function may not have been called yet.
+ *
+ *      -EBUSY: @urb has already been unlinked.
+ */
+int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
+                int status)
+{
+        struct list_head        *tmp;
+
+        /* insist the urb is still queued */
+        list_for_each(tmp, &urb->ep->urb_list) {
+                if (tmp == &urb->urb_list)
+                        break;
         }
+        if (tmp != &urb->urb_list)
+                return -EIDRM;
 
-        /* increment urb's reference count as part of giving it to the HCD
-         * (which now controls it).  HCD guarantees that it either returns
-         * an error or calls giveback(), but not both.
+        /* Any status except -EINPROGRESS means something already started to
+         * unlink this URB from the hardware.  So there's no more work to do.
          */
-        urb = usb_get_urb (urb);
-        atomic_inc (&urb->use_count);
-
-        if (is_root_hub(urb->dev)) {
-                /* NOTE:  requirement on hub callers (usbfs and the hub
-                 * driver, for now) that URBs' urb->transfer_buffer be
-                 * valid and usb_buffer_{sync,unmap}() not be needed, since
-                 * they could clobber root hub response data.
-                 */
-                status = rh_urb_enqueue (hcd, urb);
-                goto done;
+        if (urb->unlinked)
+                return -EBUSY;
+        urb->unlinked = status;
+
+        /* IRQ setup can easily be broken so that USB controllers
+         * never get completion IRQs ... maybe even the ones we need to
+         * finish unlinking the initial failed usb_set_address()
+         * or device descriptor fetch.
+         */
+        if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
+                        !is_root_hub(urb->dev)) {
+                dev_warn(hcd->self.controller, "Unlink after no-IRQ?  "
+                        "Controller is probably using the wrong IRQ.\n");
+                set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
         }
 
-        /* lower level hcd code should use *_dma exclusively,
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
+
+/**
+ * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
+ * @hcd: host controller to which @urb was submitted
+ * @urb: URB being unlinked
+ *
+ * Host controller drivers should call this routine before calling
+ * usb_hcd_giveback_urb().  The HCD's private spinlock must be held and
+ * interrupts must be disabled.  The actions carried out here are required
+ * for URB completion.
+ */
+void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
+{
+        /* clear all state linking urb to this dev (and hcd) */
+        spin_lock(&hcd_urb_list_lock);
+        list_del_init(&urb->urb_list);
+        spin_unlock(&hcd_urb_list_lock);
+}
+EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
+
+static void map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+        /* Map the URB's buffers for DMA access.
+         * Lower level HCD code should use *_dma exclusively,
          * unless it uses pio or talks to another transport.
          */
-        if (hcd->self.uses_dma) {
-                if (usb_pipecontrol (urb->pipe)
+        if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
+                if (usb_endpoint_xfer_control(&urb->ep->desc)
                         && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
                         urb->setup_dma = dma_map_single (
                                         hcd->self.controller,
@@ -1017,20 +1133,75 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
                                         hcd->self.controller,
                                         urb->transfer_buffer,
                                         urb->transfer_buffer_length,
-                                        usb_pipein (urb->pipe)
+                                        usb_urb_dir_in(urb)
                                             ? DMA_FROM_DEVICE
                                             : DMA_TO_DEVICE);
         }
+}
 
-        status = hcd->driver->urb_enqueue (hcd, ep, urb, mem_flags);
-done:
-        if (unlikely (status)) {
-                urb_unlink(hcd, urb);
-                atomic_dec (&urb->use_count);
-                if (urb->reject)
-                        wake_up (&usb_kill_urb_queue);
+static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+        if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
+                if (usb_endpoint_xfer_control(&urb->ep->desc)
+                        && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
+                        dma_unmap_single(hcd->self.controller, urb->setup_dma,
+                                        sizeof(struct usb_ctrlrequest),
+                                        DMA_TO_DEVICE);
+                if (urb->transfer_buffer_length != 0
+                        && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
+                        dma_unmap_single(hcd->self.controller,
+                                        urb->transfer_dma,
+                                        urb->transfer_buffer_length,
+                                        usb_urb_dir_in(urb)
+                                            ? DMA_FROM_DEVICE
+                                            : DMA_TO_DEVICE);
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* may be called in any context with a valid urb->dev usecount
+ * caller surrenders "ownership" of urb
+ * expects usb_submit_urb() to have sanity checked and conditioned all
+ * inputs in the urb
+ */
+int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
+{
+        int                     status;
+        struct usb_hcd          *hcd = bus_to_hcd(urb->dev->bus);
+
+        /* increment urb's reference count as part of giving it to the HCD
+         * (which will control it).  HCD guarantees that it either returns
+         * an error or calls giveback(), but not both.
+         */
+        usb_get_urb(urb);
+        atomic_inc(&urb->use_count);
+        atomic_inc(&urb->dev->urbnum);
+        usbmon_urb_submit(&hcd->self, urb);
+
+        /* NOTE requirements on root-hub callers (usbfs and the hub
+         * driver, for now):  URBs' urb->transfer_buffer must be
+         * valid and usb_buffer_{sync,unmap}() not be needed, since
+         * they could clobber root hub response data.  Also, control
+         * URBs must be submitted in process context with interrupts
+         * enabled.
+         */
+        map_urb_for_dma(hcd, urb);
+        if (is_root_hub(urb->dev))
+                status = rh_urb_enqueue(hcd, urb);
+        else
+                status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
+
+        if (unlikely(status)) {
                 usbmon_urb_submit_error(&hcd->self, urb, status);
-                usb_put_urb (urb);
+                unmap_urb_for_dma(hcd, urb);
+                urb->hcpriv = NULL;
+                INIT_LIST_HEAD(&urb->urb_list);
+                atomic_dec(&urb->use_count);
+                atomic_dec(&urb->dev->urbnum);
+                if (urb->reject)
+                        wake_up(&usb_kill_urb_queue);
+                usb_put_urb(urb);
         }
         return status;
 }
@@ -1042,24 +1213,19 @@ done:
  * soon as practical.  we've already set up the urb's return status,
  * but we can't know if the callback completed already.
  */
-static int
-unlink1 (struct usb_hcd *hcd, struct urb *urb)
+static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         int             value;
 
         if (is_root_hub(urb->dev))
-                value = usb_rh_urb_dequeue (hcd, urb);
+                value = usb_rh_urb_dequeue(hcd, urb, status);
         else {
 
                 /* The only reason an HCD might fail this call is if
                  * it has not yet fully queued the urb to begin with.
                  * Such failures should be harmless. */
-                value = hcd->driver->urb_dequeue (hcd, urb);
+                value = hcd->driver->urb_dequeue(hcd, urb, status);
         }
-
-        if (value != 0)
-                dev_dbg (hcd->self.controller, "dequeue %p --> %d\n",
-                                urb, value);
         return value;
 }
 
@@ -1071,88 +1237,17 @@ unlink1 (struct usb_hcd *hcd, struct urb *urb)
  */
 int usb_hcd_unlink_urb (struct urb *urb, int status)
 {
-        struct usb_host_endpoint        *ep;
-        struct usb_hcd                  *hcd = NULL;
-        struct device                   *sys = NULL;
-        unsigned long                   flags;
-        struct list_head                *tmp;
-        int                             retval;
-
-        if (!urb)
-                return -EINVAL;
-        if (!urb->dev || !urb->dev->bus)
-                return -ENODEV;
-        ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
-                        [usb_pipeendpoint(urb->pipe)];
-        if (!ep)
-                return -ENODEV;
-
-        /*
-         * we contend for urb->status with the hcd core,
-         * which changes it while returning the urb.
-         *
-         * Caller guaranteed that the urb pointer hasn't been freed, and
-         * that it was submitted.  But as a rule it can't know whether or
-         * not it's already been unlinked ... so we respect the reversed
-         * lock sequence needed for the usb_hcd_giveback_urb() code paths
-         * (urb lock, then hcd_urb_list_lock) in case some other CPU is now
-         * unlinking it.
-         */
-        spin_lock_irqsave (&urb->lock, flags);
-        spin_lock(&hcd_urb_list_lock);
+        struct usb_hcd          *hcd;
+        int                     retval;
 
-        sys = &urb->dev->dev;
         hcd = bus_to_hcd(urb->dev->bus);
-        if (hcd == NULL) {
-                retval = -ENODEV;
-                goto done;
-        }
+        retval = unlink1(hcd, urb, status);
 
-        /* insist the urb is still queued */
-        list_for_each(tmp, &ep->urb_list) {
-                if (tmp == &urb->urb_list)
-                        break;
-        }
-        if (tmp != &urb->urb_list) {
-                retval = -EIDRM;
-                goto done;
-        }
-
-        /* Any status except -EINPROGRESS means something already started to
-         * unlink this URB from the hardware.  So there's no more work to do.
-         */
-        if (urb->status != -EINPROGRESS) {
-                retval = -EBUSY;
-                goto done;
-        }
-
-        /* IRQ setup can easily be broken so that USB controllers
-         * never get completion IRQs ... maybe even the ones we need to
-         * finish unlinking the initial failed usb_set_address()
-         * or device descriptor fetch.
-         */
-        if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
-                        !is_root_hub(urb->dev)) {
-                dev_warn (hcd->self.controller, "Unlink after no-IRQ?  "
-                        "Controller is probably using the wrong IRQ.\n");
-                set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
-        }
-
-        urb->status = status;
-
-        spin_unlock(&hcd_urb_list_lock);
-        spin_unlock_irqrestore (&urb->lock, flags);
-
-        retval = unlink1 (hcd, urb);
         if (retval == 0)
                 retval = -EINPROGRESS;
-        return retval;
-
-done:
-        spin_unlock(&hcd_urb_list_lock);
-        spin_unlock_irqrestore (&urb->lock, flags);
-        if (retval != -EIDRM && sys && sys->driver)
-                dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);
+        else if (retval != -EIDRM && retval != -EBUSY)
+                dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
+                                urb, retval);
         return retval;
 }
 
@@ -1162,6 +1257,7 @@ done:
  * usb_hcd_giveback_urb - return URB from HCD to device driver
  * @hcd: host controller returning the URB
  * @urb: urb being returned to the USB device driver.
+ * @status: completion status code for the URB.
  * Context: in_interrupt()
  *
  * This hands the URB from HCD to its USB device driver, using its
@@ -1169,14 +1265,27 @@ done:
  * (and is done using urb->hcpriv).  It also released all HCD locks;
  * the device driver won't cause problems if it frees, modifies,
  * or resubmits this URB.
+ *
+ * If @urb was unlinked, the value of @status will be overridden by
+ * @urb->unlinked.  Erroneous short transfers are detected in case
+ * the HCD hasn't checked for them.
  */
-void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
+void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
 {
-        urb_unlink(hcd, urb);
-        usbmon_urb_complete (&hcd->self, urb);
+        urb->hcpriv = NULL;
+        if (unlikely(urb->unlinked))
+                status = urb->unlinked;
+        else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
+                        urb->actual_length < urb->transfer_buffer_length &&
+                        !status))
+                status = -EREMOTEIO;
+
+        unmap_urb_for_dma(hcd, urb);
+        usbmon_urb_complete(&hcd->self, urb, status);
         usb_unanchor_urb(urb);
 
         /* pass ownership to the completion handler */
+        urb->status = status;
         urb->complete (urb);
         atomic_dec (&urb->use_count);
         if (unlikely (urb->reject))
@@ -1187,78 +1296,61 @@ EXPORT_SYMBOL (usb_hcd_giveback_urb);
 
 /*-------------------------------------------------------------------------*/
 
-/* disables the endpoint: cancels any pending urbs, then synchronizes with
- * the hcd to make sure all endpoint state is gone from hardware, and then
- * waits until the endpoint's queue is completely drained. use for
- * set_configuration, set_interface, driver removal, physical disconnect.
- *
- * example:  a qh stored in ep->hcpriv, holding state related to endpoint
- * type, maxpacket size, toggle, halt status, and scheduling.
+/* Cancel all URBs pending on this endpoint and wait for the endpoint's
+ * queue to drain completely.  The caller must first insure that no more
+ * URBs can be submitted for this endpoint.
  */
-void usb_hcd_endpoint_disable (struct usb_device *udev,
+void usb_hcd_flush_endpoint(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
         struct usb_hcd          *hcd;
         struct urb              *urb;
 
+        if (!ep)
+                return;
+        might_sleep();
         hcd = bus_to_hcd(udev->bus);
-        local_irq_disable ();
 
-        /* ep is already gone from udev->ep_{in,out}[]; no more submits */
+        /* No more submits can occur */
 rescan:
-        spin_lock(&hcd_urb_list_lock);
+        spin_lock_irq(&hcd_urb_list_lock);
         list_for_each_entry (urb, &ep->urb_list, urb_list) {
-                int     tmp;
+                int     is_in;
 
-                /* the urb may already have been unlinked */
-                if (urb->status != -EINPROGRESS)
+                if (urb->unlinked)
                         continue;
                 usb_get_urb (urb);
+                is_in = usb_urb_dir_in(urb);
                 spin_unlock(&hcd_urb_list_lock);
 
-                spin_lock (&urb->lock);
-                tmp = urb->status;
-                if (tmp == -EINPROGRESS)
-                        urb->status = -ESHUTDOWN;
-                spin_unlock (&urb->lock);
-
-                /* kick hcd unless it's already returning this */
-                if (tmp == -EINPROGRESS) {
-                        tmp = urb->pipe;
-                        unlink1 (hcd, urb);
-                        dev_dbg (hcd->self.controller,
-                                "shutdown urb %p pipe %08x ep%d%s%s\n",
-                                urb, tmp, usb_pipeendpoint (tmp),
-                                (tmp & USB_DIR_IN) ? "in" : "out",
-                                ({ char *s; \
-                                 switch (usb_pipetype (tmp)) { \
-                                 case PIPE_CONTROL:     s = ""; break; \
-                                 case PIPE_BULK:        s = "-bulk"; break; \
-                                 case PIPE_INTERRUPT:   s = "-intr"; break; \
-                                 default:               s = "-iso"; break; \
-                                }; s;}));
-                }
+                /* kick hcd */
+                unlink1(hcd, urb, -ESHUTDOWN);
+                dev_dbg (hcd->self.controller,
+                        "shutdown urb %p ep%d%s%s\n",
+                        urb, usb_endpoint_num(&ep->desc),
+                        is_in ? "in" : "out",
+                        ({      char *s;
+
+                                 switch (usb_endpoint_type(&ep->desc)) {
+                                 case USB_ENDPOINT_XFER_CONTROL:
+                                        s = ""; break;
+                                 case USB_ENDPOINT_XFER_BULK:
+                                        s = "-bulk"; break;
+                                 case USB_ENDPOINT_XFER_INT:
+                                        s = "-intr"; break;
+                                 default:
+                                        s = "-iso"; break;
+                                };
+                                s;
+                        }));
                 usb_put_urb (urb);
 
                 /* list contents may have changed */
                 goto rescan;
         }
-        spin_unlock(&hcd_urb_list_lock);
-        local_irq_enable ();
-
-        /* synchronize with the hardware, so old configuration state
-         * clears out immediately (and will be freed).
-         */
-        might_sleep ();
-        if (hcd->driver->endpoint_disable)
-                hcd->driver->endpoint_disable (hcd, ep);
+        spin_unlock_irq(&hcd_urb_list_lock);
 
-        /* Wait until the endpoint queue is completely empty.  Most HCDs
-         * will have done this already in their endpoint_disable method,
-         * but some might not.  And there could be root-hub control URBs
-         * still pending since they aren't affected by the HCDs'
-         * endpoint_disable methods.
-         */
+        /* Wait until the endpoint queue is completely empty */
         while (!list_empty (&ep->urb_list)) {
                 spin_lock_irq(&hcd_urb_list_lock);
 
@@ -1278,6 +1370,25 @@ rescan:
         }
 }
 
+/* Disables the endpoint: synchronizes with the hcd to make sure all
+ * endpoint state is gone from hardware.  usb_hcd_flush_endpoint() must
+ * have been called previously.  Use for set_configuration, set_interface,
+ * driver removal, physical disconnect.
+ *
+ * example:  a qh stored in ep->hcpriv, holding state related to endpoint
+ * type, maxpacket size, toggle, halt status, and scheduling.
+ */
+void usb_hcd_disable_endpoint(struct usb_device *udev,
+                struct usb_host_endpoint *ep)
+{
+        struct usb_hcd          *hcd;
+
+        might_sleep();
+        hcd = bus_to_hcd(udev->bus);
+        if (hcd->driver->endpoint_disable)
+                hcd->driver->endpoint_disable(hcd, ep);
+}
+
 /*-------------------------------------------------------------------------*/
 
 /* called in any context */
@@ -1525,7 +1636,6 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
         hcd->driver = driver;
         hcd->product_desc = (driver->product_desc) ? driver->product_desc :
                         "USB Host Controller";
-
         return hcd;
 }
 EXPORT_SYMBOL (usb_create_hcd);
@@ -1570,6 +1680,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
 
         dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
 
+        hcd->authorized_default = hcd->wireless? 0 : 1;
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         /* HC is in reset state, but accessible.  Now do the one-time init,
@@ -1646,10 +1757,20 @@ int usb_add_hcd(struct usb_hcd *hcd,
         if ((retval = register_root_hub(hcd)) != 0)
                 goto err_register_root_hub;
 
+        retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
+        if (retval < 0) {
+                printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
+                       retval);
+                goto error_create_attr_group;
+        }
         if (hcd->uses_new_polling && hcd->poll_rh)
                 usb_hcd_poll_rh_status(hcd);
         return retval;
 
+error_create_attr_group:
+        mutex_lock(&usb_bus_list_lock);
+        usb_disconnect(&hcd->self.root_hub);
+        mutex_unlock(&usb_bus_list_lock);
 err_register_root_hub:
         hcd->driver->stop(hcd);
 err_hcd_driver_start:
@@ -1691,6 +1812,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         cancel_work_sync(&hcd->wakeup_work);
 #endif
 
+        sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group);
         mutex_lock(&usb_bus_list_lock);
         usb_disconnect(&hcd->self.root_hub);
         mutex_unlock(&usb_bus_list_lock);
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index b5ebb73c23..98e24194a4 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -19,6 +19,8 @@
 
 #ifdef __KERNEL__
 
+#include <linux/rwsem.h>
+
 /* This file contains declarations of usbcore internals that are mostly
  * used or exposed by Host Controller Drivers.
  */
@@ -51,6 +53,12 @@
  *
  * Since "struct usb_bus" is so thin, you can't share much code in it.
  * This framework is a layer over that, and should be more sharable.
+ *
+ * @authorized_default: Specifies if new devices are authorized to
+ *                      connect by default or they require explicit
+ *                      user space authorization; this bit is settable
+ *                      through /sys/class/usb_host/X/authorized_default.
+ *                      For the rest is RO, so we don't lock to r/w it.
  */
 
 /*-------------------------------------------------------------------------*/
@@ -90,6 +98,7 @@ struct usb_hcd {
         unsigned                poll_rh:1;      /* poll for rh status? */
         unsigned                poll_pending:1; /* status has changed? */
         unsigned                wireless:1;     /* Wireless USB HCD */
+        unsigned                authorized_default:1;
 
         int                     irq;            /* irq allocated */
         void __iomem            *regs;          /* device memory/io */
@@ -182,11 +191,10 @@ struct hc_driver {
         int     (*get_frame_number) (struct usb_hcd *hcd);
 
         /* manage i/o requests, device state */
-        int     (*urb_enqueue) (struct usb_hcd *hcd,
-                                        struct usb_host_endpoint *ep,
-                                        struct urb *urb,
-                                        gfp_t mem_flags);
-        int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);
+        int     (*urb_enqueue)(struct usb_hcd *hcd,
+                                struct urb *urb, gfp_t mem_flags);
+        int     (*urb_dequeue)(struct usb_hcd *hcd,
+                                struct urb *urb, int status);
 
         /* hw synch, freeing endpoint resources that urb_dequeue can't */
         void    (*endpoint_disable)(struct usb_hcd *hcd,
@@ -204,10 +212,18 @@ struct hc_driver {
                 /* Needed only if port-change IRQs are level-triggered */
 };
 
+extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
+extern int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
+                int status);
+extern void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb);
+
 extern int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags);
 extern int usb_hcd_unlink_urb (struct urb *urb, int status);
-extern void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb);
-extern void usb_hcd_endpoint_disable (struct usb_device *udev,
+extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
+                int status);
+extern void usb_hcd_flush_endpoint(struct usb_device *udev,
+                struct usb_host_endpoint *ep);
+extern void usb_hcd_disable_endpoint(struct usb_device *udev,
                 struct usb_host_endpoint *ep);
 extern int usb_hcd_get_frame_number (struct usb_device *udev);
 
@@ -402,7 +418,7 @@ static inline void usbfs_cleanup(void) { }
 struct usb_mon_operations {
         void (*urb_submit)(struct usb_bus *bus, struct urb *urb);
         void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err);
-        void (*urb_complete)(struct usb_bus *bus, struct urb *urb);
+        void (*urb_complete)(struct usb_bus *bus, struct urb *urb, int status);
         /* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */
 };
 
@@ -421,10 +437,11 @@ static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
                 (*mon_ops->urb_submit_error)(bus, urb, error);
 }
 
-static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb)
+static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
+                int status)
 {
         if (bus->monitored)
-                (*mon_ops->urb_complete)(bus, urb);
+                (*mon_ops->urb_complete)(bus, urb, status);
 }
 
 int usb_mon_register(struct usb_mon_operations *ops);
@@ -435,7 +452,8 @@ void usb_mon_deregister(void);
 static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {}
 static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
     int error) {}
-static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) {}
+static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
+                int status) {}
 
 #endif /* CONFIG_USB_MON */
 
@@ -454,5 +472,9 @@ static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) {}
                 : (in_interrupt () ? "in_interrupt" : "can sleep"))
 
 
-#endif /* __KERNEL__ */
+/* This rwsem is for use only by the hub driver and ehci-hcd.
+ * Nobody else should touch it.
+ */
+extern struct rw_semaphore ehci_cf_port_reset_rwsem;
 
+#endif /* __KERNEL__ */
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index f7b337feb3..d20cb545a6 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -125,6 +125,12 @@ MODULE_PARM_DESC(use_both_schemes,
                 "try the other device initialization scheme if the "
                 "first one fails");
 
+/* Mutual exclusion for EHCI CF initialization.  This interferes with
+ * port reset on some companion controllers.
+ */
+DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
+EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
+
 
 static inline char *portspeed(int portstatus)
 {
@@ -347,11 +353,11 @@ void usb_kick_khubd(struct usb_device *hdev)
 static void hub_irq(struct urb *urb)
 {
         struct usb_hub *hub = urb->context;
-        int status;
+        int status = urb->status;
         int i;
         unsigned long bits;
 
-        switch (urb->status) {
+        switch (status) {
         case -ENOENT:           /* synchronous unlink */
         case -ECONNRESET:       /* async unlink */
         case -ESHUTDOWN:        /* hardware going away */
@@ -359,10 +365,10 @@ static void hub_irq(struct urb *urb)
 
         default:                /* presumably an error */
                 /* Cause a hub reset after 10 consecutive errors */
-                dev_dbg (hub->intfdev, "transfer --> %d\n", urb->status);
+                dev_dbg (hub->intfdev, "transfer --> %d\n", status);
                 if ((++hub->nerrors < 10) || hub->error)
                         goto resubmit;
-                hub->error = urb->status;
+                hub->error = status;
                 /* FALL THROUGH */
 
         /* let khubd handle things */
@@ -1220,54 +1226,14 @@ static inline void show_string(struct usb_device *udev, char *id, char *string)
 #endif
 
 /**
- * usb_new_device - perform initial device setup (usbcore-internal)
+ * usb_configure_device_otg - FIXME (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
- * This is called with devices which have been enumerated, but not yet
- * configured.  The device descriptor is available, but not descriptors
- * for any device configuration.  The caller must have locked either
- * the parent hub (if udev is a normal device) or else the
- * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
- * udev has already been installed, but udev is not yet visible through
- * sysfs or other filesystem code.
- *
- * It will return if the device is configured properly or not.  Zero if
- * the interface was registered with the driver core; else a negative
- * errno value.
- *
- * This call is synchronous, and may not be used in an interrupt context.
- *
- * Only the hub driver or root-hub registrar should ever call this.
+ * Do configuration for On-The-Go devices
  */
-int usb_new_device(struct usb_device *udev)
+static int usb_configure_device_otg(struct usb_device *udev)
 {
-        int err;
-
-        /* Determine quirks */
-        usb_detect_quirks(udev);
-
-        err = usb_get_configuration(udev);
-        if (err < 0) {
-                dev_err(&udev->dev, "can't read configurations, error %d\n",
-                        err);
-                goto fail;
-        }
-
-        /* read the standard strings and cache them if present */
-        udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
-        udev->manufacturer = usb_cache_string(udev,
-                        udev->descriptor.iManufacturer);
-        udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
-
-        /* Tell the world! */
-        dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
-                        "SerialNumber=%d\n",
-                        udev->descriptor.iManufacturer,
-                        udev->descriptor.iProduct,
-                        udev->descriptor.iSerialNumber);
-        show_string(udev, "Product", udev->product);
-        show_string(udev, "Manufacturer", udev->manufacturer);
-        show_string(udev, "SerialNumber", udev->serial);
+        int err = 0;
 
 #ifdef  CONFIG_USB_OTG
         /*
@@ -1329,8 +1295,82 @@ int usb_new_device(struct usb_device *udev)
                 err = -ENOTSUPP;
                 goto fail;
         }
+fail:
 #endif
+        return err;
+}
+
+
+/**
+ * usb_configure_device - Detect and probe device intfs/otg (usbcore-internal)
+ * @udev: newly addressed device (in ADDRESS state)
+ *
+ * This is only called by usb_new_device() and usb_authorize_device()
+ * and FIXME -- all comments that apply to them apply here wrt to
+ * environment.
+ *
+ * If the device is WUSB and not authorized, we don't attempt to read
+ * the string descriptors, as they will be errored out by the device
+ * until it has been authorized.
+ */
+static int usb_configure_device(struct usb_device *udev)
+{
+        int err;
 
+        if (udev->config == NULL) {
+                err = usb_get_configuration(udev);
+                if (err < 0) {
+                        dev_err(&udev->dev, "can't read configurations, error %d\n",
+                                err);
+                        goto fail;
+                }
+        }
+        if (udev->wusb == 1 && udev->authorized == 0) {
+                udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+                udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+                udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        }
+        else {
+                /* read the standard strings and cache them if present */
+                udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
+                udev->manufacturer = usb_cache_string(udev,
+                                                      udev->descriptor.iManufacturer);
+                udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
+        }
+        err = usb_configure_device_otg(udev);
+fail:
+        return err;
+}
+
+
+/**
+ * usb_new_device - perform initial device setup (usbcore-internal)
+ * @udev: newly addressed device (in ADDRESS state)
+ *
+ * This is called with devices which have been enumerated, but not yet
+ * configured.  The device descriptor is available, but not descriptors
+ * for any device configuration.  The caller must have locked either
+ * the parent hub (if udev is a normal device) or else the
+ * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
+ * udev has already been installed, but udev is not yet visible through
+ * sysfs or other filesystem code.
+ *
+ * It will return if the device is configured properly or not.  Zero if
+ * the interface was registered with the driver core; else a negative
+ * errno value.
+ *
+ * This call is synchronous, and may not be used in an interrupt context.
+ *
+ * Only the hub driver or root-hub registrar should ever call this.
+ */
+int usb_new_device(struct usb_device *udev)
+{
+        int err;
+
+        usb_detect_quirks(udev);                /* Determine quirks */
+        err = usb_configure_device(udev);       /* detect & probe dev/intfs */
+        if (err < 0)
+                goto fail;
         /* export the usbdev device-node for libusb */
         udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
                         (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
@@ -1346,19 +1386,106 @@ int usb_new_device(struct usb_device *udev)
         err = device_add(&udev->dev);
         if (err) {
                 dev_err(&udev->dev, "can't device_add, error %d\n", err);
-                if (udev->parent)
-                        usb_autosuspend_device(udev->parent);
                 goto fail;
         }
 
-exit:
+        /* Tell the world! */
+        dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
+                "SerialNumber=%d\n",
+                udev->descriptor.iManufacturer,
+                udev->descriptor.iProduct,
+                udev->descriptor.iSerialNumber);
+        show_string(udev, "Product", udev->product);
+        show_string(udev, "Manufacturer", udev->manufacturer);
+        show_string(udev, "SerialNumber", udev->serial);
         return err;
 
 fail:
         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
-        goto exit;
+        return err;
 }
 
+
+/**
+ * Similar to usb_disconnect()
+ *
+ * We share a lock (that we have) with device_del(), so we need to
+ * defer its call.
+ */
+int usb_deauthorize_device(struct usb_device *usb_dev)
+{
+        unsigned cnt;
+        usb_lock_device(usb_dev);
+        if (usb_dev->authorized == 0)
+                goto out_unauthorized;
+        usb_dev->authorized = 0;
+        usb_set_configuration(usb_dev, -1);
+        usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        kfree(usb_dev->config);
+        usb_dev->config = NULL;
+        for (cnt = 0; cnt < usb_dev->descriptor.bNumConfigurations; cnt++)
+                kfree(usb_dev->rawdescriptors[cnt]);
+        usb_dev->descriptor.bNumConfigurations = 0;
+        kfree(usb_dev->rawdescriptors);
+out_unauthorized:
+        usb_unlock_device(usb_dev);
+        return 0;
+}
+
+
+int usb_authorize_device(struct usb_device *usb_dev)
+{
+        int result = 0, c;
+        usb_lock_device(usb_dev);
+        if (usb_dev->authorized == 1)
+                goto out_authorized;
+        kfree(usb_dev->product);
+        usb_dev->product = NULL;
+        kfree(usb_dev->manufacturer);
+        usb_dev->manufacturer = NULL;
+        kfree(usb_dev->serial);
+        usb_dev->serial = NULL;
+        result = usb_autoresume_device(usb_dev);
+        if (result < 0) {
+                dev_err(&usb_dev->dev,
+                        "can't autoresume for authorization: %d\n", result);
+                goto error_autoresume;
+        }
+        result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
+        if (result < 0) {
+                dev_err(&usb_dev->dev, "can't re-read device descriptor for "
+                        "authorization: %d\n", result);
+                goto error_device_descriptor;
+        }
+        usb_dev->authorized = 1;
+        result = usb_configure_device(usb_dev);
+        if (result < 0)
+                goto error_configure;
+        /* Choose and set the configuration.  This registers the interfaces
+         * with the driver core and lets interface drivers bind to them.
+         */
+        c = usb_choose_configuration(usb_dev);
+        if (c >= 0) {
+                result = usb_set_configuration(usb_dev, c);
+                if (result) {
+                        dev_err(&usb_dev->dev,
+                                "can't set config #%d, error %d\n", c, result);
+                        /* This need not be fatal.  The user can try to
+                         * set other configurations. */
+                }
+        }
+        dev_info(&usb_dev->dev, "authorized to connect\n");
+error_configure:
+error_device_descriptor:
+error_autoresume:
+out_authorized:
+        usb_unlock_device(usb_dev);     // complements locktree
+        return result;
+}
+
+
 static int hub_port_status(struct usb_hub *hub, int port1,
                                u16 *status, u16 *change)
 {
@@ -1460,6 +1587,11 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
 {
         int i, status;
 
+        /* Block EHCI CF initialization during the port reset.
+         * Some companion controllers don't like it when they mix.
+         */
+        down_read(&ehci_cf_port_reset_rwsem);
+
         /* Reset the port */
         for (i = 0; i < PORT_RESET_TRIES; i++) {
                 status = set_port_feature(hub->hdev,
@@ -1481,6 +1613,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 case 0:
                         /* TRSTRCY = 10 ms; plus some extra */
                         msleep(10 + 40);
+                        udev->devnum = 0;       /* Device now at address 0 */
                         /* FALL THROUGH */
                 case -ENOTCONN:
                 case -ENODEV:
@@ -1490,7 +1623,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                         usb_set_device_state(udev, status
                                         ? USB_STATE_NOTATTACHED
                                         : USB_STATE_DEFAULT);
-                        return status;
+                        goto done;
                 }
 
                 dev_dbg (hub->intfdev,
@@ -1503,6 +1636,8 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 "Cannot enable port %i.  Maybe the USB cable is bad?\n",
                 port1);
 
+ done:
+        up_read(&ehci_cf_port_reset_rwsem);
         return status;
 }
 
@@ -1833,14 +1968,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
                 struct usb_device       *udev;
 
                 udev = hdev->children [port1-1];
-                if (udev && msg.event == PM_EVENT_SUSPEND &&
-#ifdef  CONFIG_USB_SUSPEND
-                                udev->state != USB_STATE_SUSPENDED
-#else
-                                udev->dev.power.power_state.event
-                                        == PM_EVENT_ON
-#endif
-                                ) {
+                if (udev && udev->can_submit) {
                         if (!hdev->auto_pm)
                                 dev_dbg(&intf->dev, "port %d nyet suspended\n",
                                                 port1);
@@ -1999,26 +2127,27 @@ static void ep0_reinit(struct usb_device *udev)
 {
         usb_disable_endpoint(udev, 0 + USB_DIR_IN);
         usb_disable_endpoint(udev, 0 + USB_DIR_OUT);
-        udev->ep_in[0] = udev->ep_out[0] = &udev->ep0;
+        usb_enable_endpoint(udev, &udev->ep0);
 }
 
 #define usb_sndaddr0pipe()      (PIPE_CONTROL << 30)
 #define usb_rcvaddr0pipe()      ((PIPE_CONTROL << 30) | USB_DIR_IN)
 
-static int hub_set_address(struct usb_device *udev)
+static int hub_set_address(struct usb_device *udev, int devnum)
 {
         int retval;
 
-        if (udev->devnum == 0)
+        if (devnum <= 1)
                 return -EINVAL;
         if (udev->state == USB_STATE_ADDRESS)
                 return 0;
         if (udev->state != USB_STATE_DEFAULT)
                 return -EINVAL;
         retval = usb_control_msg(udev, usb_sndaddr0pipe(),
-                USB_REQ_SET_ADDRESS, 0, udev->devnum, 0,
+                USB_REQ_SET_ADDRESS, 0, devnum, 0,
                 NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (retval == 0) {
+                udev->devnum = devnum;  /* Device now using proper address */
                 usb_set_device_state(udev, USB_STATE_ADDRESS);
                 ep0_reinit(udev);
         }
@@ -2045,6 +2174,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         unsigned                delay = HUB_SHORT_RESET_TIME;
         enum usb_device_speed   oldspeed = udev->speed;
         char                    *speed, *type;
+        int                     devnum = udev->devnum;
 
         /* root hub ports have a slightly longer reset period
          * (from USB 2.0 spec, section 7.1.7.5)
@@ -2074,7 +2204,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 goto fail;
         }
         oldspeed = udev->speed;
-  
+
         /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
          * it's fixed size except for full speed devices.
          * For Wireless USB devices, ep0 max packet is always 512 (tho
@@ -2115,7 +2245,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         dev_info (&udev->dev,
                   "%s %s speed %sUSB device using %s and address %d\n",
                   (udev->config) ? "reset" : "new", speed, type,
-                  udev->bus->controller->driver->name, udev->devnum);
+                  udev->bus->controller->driver->name, devnum);
 
         /* Set up TT records, if needed  */
         if (hdev->tt) {
@@ -2202,7 +2332,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 }
 
                 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
-                        retval = hub_set_address(udev);
+                        retval = hub_set_address(udev, devnum);
                         if (retval >= 0)
                                 break;
                         msleep(200);
@@ -2210,7 +2340,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 if (retval < 0) {
                         dev_err(&udev->dev,
                                 "device not accepting address %d, error %d\n",
-                                udev->devnum, retval);
+                                devnum, retval);
                         goto fail;
                 }
  
@@ -2263,8 +2393,10 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         retval = 0;
 
 fail:
-        if (retval)
+        if (retval) {
                 hub_port_disable(hub, port1, 0);
+                udev->devnum = devnum;  /* for disconnect processing */
+        }
         mutex_unlock(&usb_address0_mutex);
         return retval;
 }
@@ -2699,9 +2831,9 @@ static void hub_events(void)
                                 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
                                 if (hubstatus & HUB_STATUS_LOCAL_POWER)
                                         /* FIXME: Is this always true? */
-                                        hub->limited_power = 0;
-                                else
                                         hub->limited_power = 1;
+                                else
+                                        hub->limited_power = 0;
                         }
                         if (hubchange & HUB_CHANGE_OVERCURRENT) {
                                 dev_dbg (hub_dev, "overcurrent change\n");
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index d8f7b089a8..c021af3903 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -59,8 +59,8 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
                 dev_dbg(&urb->dev->dev,
                         "%s timed out on ep%d%s len=%d/%d\n",
                         current->comm,
-                        usb_pipeendpoint(urb->pipe),
-                        usb_pipein(urb->pipe) ? "in" : "out",
+                        usb_endpoint_num(&urb->ep->desc),
+                        usb_urb_dir_in(urb) ? "in" : "out",
                         urb->actual_length,
                         urb->transfer_buffer_length);
         } else
@@ -250,7 +250,8 @@ static void sg_clean (struct usb_sg_request *io)
                 io->urbs = NULL;
         }
         if (io->dev->dev.dma_mask != NULL)
-                usb_buffer_unmap_sg (io->dev, io->pipe, io->sg, io->nents);
+                usb_buffer_unmap_sg (io->dev, usb_pipein(io->pipe),
+                                io->sg, io->nents);
         io->dev = NULL;
 }
 
@@ -278,8 +279,8 @@ static void sg_complete (struct urb *urb)
                 dev_err (io->dev->bus->controller,
                         "dev %s ep%d%s scatterlist error %d/%d\n",
                         io->dev->devpath,
-                        usb_pipeendpoint (urb->pipe),
-                        usb_pipein (urb->pipe) ? "in" : "out",
+                        usb_endpoint_num(&urb->ep->desc),
+                        usb_urb_dir_in(urb) ? "in" : "out",
                         status, io->status);
                 // BUG ();
         }
@@ -379,7 +380,8 @@ int usb_sg_init (
          */
         dma = (dev->dev.dma_mask != NULL);
         if (dma)
-                io->entries = usb_buffer_map_sg (dev, pipe, sg, nents);
+                io->entries = usb_buffer_map_sg(dev, usb_pipein(pipe),
+                                sg, nents);
         else
                 io->entries = nents;
 
@@ -1013,8 +1015,11 @@ void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr)
                 ep = dev->ep_in[epnum];
                 dev->ep_in[epnum] = NULL;
         }
-        if (ep && dev->bus)
-                usb_hcd_endpoint_disable(dev, ep);
+        if (ep) {
+                ep->enabled = 0;
+                usb_hcd_flush_endpoint(dev, ep);
+                usb_hcd_disable_endpoint(dev, ep);
+        }
 }
 
 /**
@@ -1096,23 +1101,21 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
  * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers.
  * For control endpoints, both the input and output sides are handled.
  */
-static void
-usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
+void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
 {
-        unsigned int epaddr = ep->desc.bEndpointAddress;
-        unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
-        int is_control;
+        int epnum = usb_endpoint_num(&ep->desc);
+        int is_out = usb_endpoint_dir_out(&ep->desc);
+        int is_control = usb_endpoint_xfer_control(&ep->desc);
 
-        is_control = ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-                        == USB_ENDPOINT_XFER_CONTROL);
-        if (usb_endpoint_out(epaddr) || is_control) {
+        if (is_out || is_control) {
                 usb_settoggle(dev, epnum, 1, 0);
                 dev->ep_out[epnum] = ep;
         }
-        if (!usb_endpoint_out(epaddr) || is_control) {
+        if (!is_out || is_control) {
                 usb_settoggle(dev, epnum, 0, 0);
                 dev->ep_in[epnum] = ep;
         }
+        ep->enabled = 1;
 }
 
 /*
@@ -1171,6 +1174,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
         struct usb_host_interface *alt;
         int ret;
         int manual = 0;
+        int changed;
 
         if (dev->state == USB_STATE_SUSPENDED)
                 return -EHOSTUNREACH;
@@ -1210,7 +1214,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          */
 
         /* prevent submissions using previous endpoint settings */
-        if (device_is_registered(&iface->dev))
+        changed = (iface->cur_altsetting != alt);
+        if (changed && device_is_registered(&iface->dev))
                 usb_remove_sysfs_intf_files(iface);
         usb_disable_interface(dev, iface);
 
@@ -1247,7 +1252,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          * (Likewise, EP0 never "halts" on well designed devices.)
          */
         usb_enable_interface(dev, iface);
-        if (device_is_registered(&iface->dev))
+        if (changed && device_is_registered(&iface->dev))
                 usb_create_sysfs_intf_files(iface);
 
         return 0;
@@ -1328,7 +1333,7 @@ int usb_reset_configuration(struct usb_device *dev)
         return 0;
 }
 
-void usb_release_interface(struct device *dev)
+static void usb_release_interface(struct device *dev)
 {
         struct usb_interface *intf = to_usb_interface(dev);
         struct usb_interface_cache *intfc =
@@ -1339,14 +1344,11 @@ void usb_release_interface(struct device *dev)
 }
 
 #ifdef  CONFIG_HOTPLUG
-static int usb_if_uevent(struct device *dev, char **envp, int num_envp,
-                 char *buffer, int buffer_size)
+static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct usb_device *usb_dev;
         struct usb_interface *intf;
         struct usb_host_interface *alt;
-        int i = 0;
-        int length = 0;
 
         if (!dev)
                 return -ENODEV;
@@ -1359,39 +1361,30 @@ static int usb_if_uevent(struct device *dev, char **envp, int num_envp,
         alt = intf->cur_altsetting;
 
 #ifdef CONFIG_USB_DEVICEFS
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "DEVICE=/proc/bus/usb/%03d/%03d",
+        if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
                            usb_dev->bus->busnum, usb_dev->devnum))
                 return -ENOMEM;
 #endif
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "PRODUCT=%x/%x/%x",
+        if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
                            le16_to_cpu(usb_dev->descriptor.idVendor),
                            le16_to_cpu(usb_dev->descriptor.idProduct),
                            le16_to_cpu(usb_dev->descriptor.bcdDevice)))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                           buffer, buffer_size, &length,
-                           "TYPE=%d/%d/%d",
+        if (add_uevent_var(env, "TYPE=%d/%d/%d",
                            usb_dev->descriptor.bDeviceClass,
                            usb_dev->descriptor.bDeviceSubClass,
                            usb_dev->descriptor.bDeviceProtocol))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                   buffer, buffer_size, &length,
-                   "INTERFACE=%d/%d/%d",
+        if (add_uevent_var(env, "INTERFACE=%d/%d/%d",
                    alt->desc.bInterfaceClass,
                    alt->desc.bInterfaceSubClass,
                    alt->desc.bInterfaceProtocol))
                 return -ENOMEM;
 
-        if (add_uevent_var(envp, num_envp, &i,
-                   buffer, buffer_size, &length,
+        if (add_uevent_var(env,
                    "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
                    le16_to_cpu(usb_dev->descriptor.idVendor),
                    le16_to_cpu(usb_dev->descriptor.idProduct),
@@ -1404,14 +1397,12 @@ static int usb_if_uevent(struct device *dev, char **envp, int num_envp,
                    alt->desc.bInterfaceProtocol))
                 return -ENOMEM;
 
-        envp[i] = NULL;
         return 0;
 }
 
 #else
 
-static int usb_if_uevent(struct device *dev, char **envp,
-                         int num_envp, char *buffer, int buffer_size)
+static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return -ENODEV;
 }
@@ -1481,6 +1472,9 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
  * channels are available independently; and choosing between open
  * standard device protocols (like CDC) or proprietary ones.
  *
+ * Note that a non-authorized device (dev->authorized == 0) will only
+ * be put in unconfigured mode.
+ *
  * Note that USB has an additional level of device configurability,
  * associated with interfaces.  That configurability is accessed using
  * usb_set_interface().
@@ -1502,7 +1496,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
         struct usb_interface **new_interfaces = NULL;
         int n, nintf;
 
-        if (configuration == -1)
+        if (dev->authorized == 0 || configuration == -1)
                 configuration = 0;
         else {
                 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index ebf3dc2011..d42c561c75 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -32,52 +32,6 @@ static const struct usb_device_id usb_quirk_list[] = {
         { USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME },
         /* HP 5300/5370C scanner */
         { USB_DEVICE(0x03f0, 0x0701), .driver_info = USB_QUIRK_STRING_FETCH_255 },
-        /* Hewlett-Packard PhotoSmart 720 / PhotoSmart 935 (storage) */
-        { USB_DEVICE(0x03f0, 0x4002), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* SGS Thomson Microelectronics 4in1 card reader */
-        { USB_DEVICE(0x0483, 0x0321), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* Acer Peripherals Inc. (now BenQ Corp.) Prisa 640BU */
-        { USB_DEVICE(0x04a5, 0x207e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Benq S2W 3300U */
-        { USB_DEVICE(0x04a5, 0x20b0), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Canon, Inc. CanoScan N1240U/LiDE30 */
-        { USB_DEVICE(0x04a9, 0x220e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Canon, Inc. CanoScan N650U/N656U */
-        { USB_DEVICE(0x04a9, 0x2206), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Canon, Inc. CanoScan 1220U */
-        { USB_DEVICE(0x04a9, 0x2207), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Canon, Inc. CanoScan N670U/N676U/LiDE 20 */
-        { USB_DEVICE(0x04a9, 0x220d), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* old Cannon scanner */
-        { USB_DEVICE(0x04a9, 0x2220), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Seiko Epson Corp. Perfection 1200 */
-        { USB_DEVICE(0x04b8, 0x0104), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Seiko Epson Corp. Perfection 660 */
-        { USB_DEVICE(0x04b8, 0x0114), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Epson Perfection 1260 Photo */
-        { USB_DEVICE(0x04b8, 0x011d), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Seiko Epson Corp - Perfection 1670 */
-        { USB_DEVICE(0x04b8, 0x011f), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* EPSON Perfection 2480 */
-        { USB_DEVICE(0x04b8, 0x0121), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Seiko Epson Corp.*/
-        { USB_DEVICE(0x04b8, 0x0122), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Samsung ML-2010 printer */
-        { USB_DEVICE(0x04e8, 0x326c), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Samsung ML-2510 Series printer */
-        { USB_DEVICE(0x04e8, 0x327e), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Elsa MicroLink 56k (V.250) */
-        { USB_DEVICE(0x05cc, 0x2267), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Ultima Electronics Corp.*/
-        { USB_DEVICE(0x05d8, 0x4005), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* Genesys USB-to-IDE */
-        { USB_DEVICE(0x0503, 0x0702), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* USB Graphical LCD - EEH Datalink GmbH */
-        { USB_DEVICE(0x060c, 0x04eb), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
 
         /* INTEL VALUE SSD */
         { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME },
@@ -85,44 +39,15 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* M-Systems Flash Disk Pioneers */
         { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Agfa Snapscan1212u */
-        { USB_DEVICE(0x06bd, 0x2061), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Seagate RSS LLC */
-        { USB_DEVICE(0x0bc2, 0x3000), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        /* Umax [hex] Astra 3400U */
-        { USB_DEVICE(0x1606, 0x0060), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
         /* Philips PSC805 audio device */
         { USB_DEVICE(0x0471, 0x0155), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* Alcor multi-card reader */
-        { USB_DEVICE(0x058f, 0x6366), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* Canon EOS 5D in PC Connection mode */
-        { USB_DEVICE(0x04a9, 0x3101), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* RIM Blackberry */
-        { USB_DEVICE(0x0fca, 0x0001), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        { USB_DEVICE(0x0fca, 0x0004), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-        { USB_DEVICE(0x0fca, 0x0006), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
-        /* Apple iPhone */
-        { USB_DEVICE(0x05ac, 0x1290), .driver_info = USB_QUIRK_NO_AUTOSUSPEND },
-
         /* SKYMEDI USB_DRIVE */
         { USB_DEVICE(0x1516, 0x8628), .driver_info = USB_QUIRK_RESET_RESUME },
 
         { }  /* terminating entry must be last */
 };
 
-static void usb_autosuspend_quirk(struct usb_device *udev)
-{
-#ifdef  CONFIG_USB_SUSPEND
-        /* disable autosuspend, but allow the user to re-enable it via sysfs */
-        udev->autosuspend_disabled = 1;
-#endif
-}
-
 static const struct usb_device_id *find_id(struct usb_device *udev)
 {
         const struct usb_device_id *id = usb_quirk_list;
@@ -149,13 +74,9 @@ void usb_detect_quirks(struct usb_device *udev)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
                                 udev->quirks);
 
-        /* do any special quirk handling here if needed */
-        if (udev->quirks & USB_QUIRK_NO_AUTOSUSPEND)
-                usb_autosuspend_quirk(udev);
-
         /* By default, disable autosuspend for all non-hubs */
 #ifdef  CONFIG_USB_SUSPEND
         if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
-                udev->autosuspend_delay = -1;
+                udev->autosuspend_disabled = 1;
 #endif
 }
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 2ab222be8f..b04afd06e5 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -169,6 +169,16 @@ show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
 
+static ssize_t
+show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev;
+
+        udev = to_usb_device(dev);
+        return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
+}
+static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
+
 
 #if defined(CONFIG_USB_PERSIST) || defined(CONFIG_USB_SUSPEND)
 static const char power_group[] = "power";
@@ -413,6 +423,44 @@ usb_descriptor_attr(bDeviceProtocol, "%02x\n")
 usb_descriptor_attr(bNumConfigurations, "%d\n")
 usb_descriptor_attr(bMaxPacketSize0, "%d\n")
 
+
+
+/* show if the device is authorized (1) or not (0) */
+static ssize_t usb_dev_authorized_show(struct device *dev,
+                                       struct device_attribute *attr,
+                                       char *buf)
+{
+        struct usb_device *usb_dev = to_usb_device(dev);
+        return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
+}
+
+
+/*
+ * Authorize a device to be used in the system
+ *
+ * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
+ */
+static ssize_t usb_dev_authorized_store(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t size)
+{
+        ssize_t result;
+        struct usb_device *usb_dev = to_usb_device(dev);
+        unsigned val;
+        result = sscanf(buf, "%u\n", &val);
+        if (result != 1)
+                result = -EINVAL;
+        else if (val == 0)
+                result = usb_deauthorize_device(usb_dev);
+        else
+                result = usb_authorize_device(usb_dev);
+        return result < 0? result : size;
+}
+
+static DEVICE_ATTR(authorized, 0644,
+            usb_dev_authorized_show, usb_dev_authorized_store);
+
+
 static struct attribute *dev_attrs[] = {
         /* current configuration's attributes */
         &dev_attr_configuration.attr,
@@ -420,6 +468,7 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_bConfigurationValue.attr,
         &dev_attr_bmAttributes.attr,
         &dev_attr_bMaxPower.attr,
+        &dev_attr_urbnum.attr,
         /* device attributes */
         &dev_attr_idVendor.attr,
         &dev_attr_idProduct.attr,
@@ -435,6 +484,7 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_version.attr,
         &dev_attr_maxchild.attr,
         &dev_attr_quirks.attr,
+        &dev_attr_authorized.attr,
         NULL,
 };
 static struct attribute_group dev_attr_grp = {
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index be63022846..c20c03aaf0 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -3,6 +3,7 @@
 #include <linux/bitops.h>
 #include <linux/slab.h>
 #include <linux/init.h>
+#include <linux/log2.h>
 #include <linux/usb.h>
 #include <linux/wait.h>
 #include "hcd.h"
@@ -38,7 +39,6 @@ void usb_init_urb(struct urb *urb)
         if (urb) {
                 memset(urb, 0, sizeof(*urb));
                 kref_init(&urb->kref);
-                spin_lock_init(&urb->lock);
                 INIT_LIST_HEAD(&urb->anchor_list);
         }
 }
@@ -277,44 +277,58 @@ EXPORT_SYMBOL_GPL(usb_unanchor_urb);
  */
 int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
 {
-        int                     pipe, temp, max;
-        struct usb_device       *dev;
-        int                     is_out;
+        int                             xfertype, max;
+        struct usb_device               *dev;
+        struct usb_host_endpoint        *ep;
+        int                             is_out;
 
         if (!urb || urb->hcpriv || !urb->complete)
                 return -EINVAL;
-        if (!(dev = urb->dev) ||
-            (dev->state < USB_STATE_DEFAULT) ||
-            (!dev->bus) || (dev->devnum <= 0))
+        if (!(dev = urb->dev) || dev->state < USB_STATE_DEFAULT)
                 return -ENODEV;
-        if (dev->bus->controller->power.power_state.event != PM_EVENT_ON
-                        || dev->state == USB_STATE_SUSPENDED)
-                return -EHOSTUNREACH;
 
+        /* For now, get the endpoint from the pipe.  Eventually drivers
+         * will be required to set urb->ep directly and we will eliminate
+         * urb->pipe.
+         */
+        ep = (usb_pipein(urb->pipe) ? dev->ep_in : dev->ep_out)
+                        [usb_pipeendpoint(urb->pipe)];
+        if (!ep)
+                return -ENOENT;
+
+        urb->ep = ep;
         urb->status = -EINPROGRESS;
         urb->actual_length = 0;
 
         /* Lots of sanity checks, so HCDs can rely on clean data
          * and don't need to duplicate tests
          */
-        pipe = urb->pipe;
-        temp = usb_pipetype(pipe);
-        is_out = usb_pipeout(pipe);
+        xfertype = usb_endpoint_type(&ep->desc);
+        if (xfertype == USB_ENDPOINT_XFER_CONTROL) {
+                struct usb_ctrlrequest *setup =
+                                (struct usb_ctrlrequest *) urb->setup_packet;
+
+                if (!setup)
+                        return -ENOEXEC;
+                is_out = !(setup->bRequestType & USB_DIR_IN) ||
+                                !setup->wLength;
+        } else {
+                is_out = usb_endpoint_dir_out(&ep->desc);
+        }
 
-        if (!usb_pipecontrol(pipe) && dev->state < USB_STATE_CONFIGURED)
-                return -ENODEV;
+        /* Cache the direction for later use */
+        urb->transfer_flags = (urb->transfer_flags & ~URB_DIR_MASK) |
+                        (is_out ? URB_DIR_OUT : URB_DIR_IN);
 
-        /* FIXME there should be a sharable lock protecting us against
-         * config/altsetting changes and disconnects, kicking in here.
-         * (here == before maxpacket, and eventually endpoint type,
-         * checks get made.)
-         */
+        if (xfertype != USB_ENDPOINT_XFER_CONTROL &&
+                        dev->state < USB_STATE_CONFIGURED)
+                return -ENODEV;
 
-        max = usb_maxpacket(dev, pipe, is_out);
+        max = le16_to_cpu(ep->desc.wMaxPacketSize);
         if (max <= 0) {
                 dev_dbg(&dev->dev,
                         "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
-                        usb_pipeendpoint(pipe), is_out ? "out" : "in",
+                        usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
                         __FUNCTION__, max);
                 return -EMSGSIZE;
         }
@@ -323,7 +337,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
          * but drivers only control those sizes for ISO.
          * while we're checking, initialize return status.
          */
-        if (temp == PIPE_ISOCHRONOUS) {
+        if (xfertype == USB_ENDPOINT_XFER_ISOC) {
                 int     n, len;
 
                 /* "high bandwidth" mode, 1-3 packets/uframe? */
@@ -358,20 +372,20 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
 
         /* enforce simple/standard policy */
         allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP |
-                        URB_NO_INTERRUPT);
-        switch (temp) {
-        case PIPE_BULK:
+                        URB_NO_INTERRUPT | URB_DIR_MASK);
+        switch (xfertype) {
+        case USB_ENDPOINT_XFER_BULK:
                 if (is_out)
                         allowed |= URB_ZERO_PACKET;
                 /* FALLTHROUGH */
-        case PIPE_CONTROL:
+        case USB_ENDPOINT_XFER_CONTROL:
                 allowed |= URB_NO_FSBR; /* only affects UHCI */
                 /* FALLTHROUGH */
         default:                        /* all non-iso endpoints */
                 if (!is_out)
                         allowed |= URB_SHORT_NOT_OK;
                 break;
-        case PIPE_ISOCHRONOUS:
+        case USB_ENDPOINT_XFER_ISOC:
                 allowed |= URB_ISO_ASAP;
                 break;
         }
@@ -393,9 +407,9 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
          * supports different values... this uses EHCI/UHCI defaults (and
          * EHCI can use smaller non-default values).
          */
-        switch (temp) {
-        case PIPE_ISOCHRONOUS:
-        case PIPE_INTERRUPT:
+        switch (xfertype) {
+        case USB_ENDPOINT_XFER_ISOC:
+        case USB_ENDPOINT_XFER_INT:
                 /* too small? */
                 if (urb->interval <= 0)
                         return -EINVAL;
@@ -405,29 +419,27 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                         // NOTE usb handles 2^15
                         if (urb->interval > (1024 * 8))
                                 urb->interval = 1024 * 8;
-                        temp = 1024 * 8;
+                        max = 1024 * 8;
                         break;
                 case USB_SPEED_FULL:    /* units are frames/msec */
                 case USB_SPEED_LOW:
-                        if (temp == PIPE_INTERRUPT) {
+                        if (xfertype == USB_ENDPOINT_XFER_INT) {
                                 if (urb->interval > 255)
                                         return -EINVAL;
                                 // NOTE ohci only handles up to 32
-                                temp = 128;
+                                max = 128;
                         } else {
                                 if (urb->interval > 1024)
                                         urb->interval = 1024;
                                 // NOTE usb and ohci handle up to 2^15
-                                temp = 1024;
+                                max = 1024;
                         }
                         break;
                 default:
                         return -EINVAL;
                 }
-                /* power of two? */
-                while (temp > urb->interval)
-                        temp >>= 1;
-                urb->interval = temp;
+                /* Round down to a power of 2, no more than max */
+                urb->interval = min(max, 1 << ilog2(urb->interval));
         }
 
         return usb_hcd_submit_urb(urb, mem_flags);
@@ -496,8 +508,10 @@ int usb_unlink_urb(struct urb *urb)
 {
         if (!urb)
                 return -EINVAL;
-        if (!(urb->dev && urb->dev->bus))
+        if (!urb->dev)
                 return -ENODEV;
+        if (!urb->ep)
+                return -EIDRM;
         return usb_hcd_unlink_urb(urb, -ECONNRESET);
 }
 
@@ -523,19 +537,21 @@ int usb_unlink_urb(struct urb *urb)
  */
 void usb_kill_urb(struct urb *urb)
 {
+        static DEFINE_MUTEX(reject_mutex);
+
         might_sleep();
-        if (!(urb && urb->dev && urb->dev->bus))
+        if (!(urb && urb->dev && urb->ep))
                 return;
-        spin_lock_irq(&urb->lock);
+        mutex_lock(&reject_mutex);
         ++urb->reject;
-        spin_unlock_irq(&urb->lock);
+        mutex_unlock(&reject_mutex);
 
         usb_hcd_unlink_urb(urb, -ENOENT);
         wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
 
-        spin_lock_irq(&urb->lock);
+        mutex_lock(&reject_mutex);
         --urb->reject;
-        spin_unlock_irq(&urb->lock);
+        mutex_unlock(&reject_mutex);
 }
 
 /**
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 0fee5c66fd..c99938d5f7 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -223,6 +223,15 @@ static void ksuspend_usb_cleanup(void)
 
 #endif  /* CONFIG_PM */
 
+
+/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
+static unsigned usb_bus_is_wusb(struct usb_bus *bus)
+{
+        struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
+        return hcd->wireless;
+}
+
+
 /**
  * usb_alloc_dev - usb device constructor (usbcore-internal)
  * @parent: hub to which device is connected; null to allocate a root hub
@@ -239,6 +248,8 @@ struct usb_device *
 usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
 {
         struct usb_device *dev;
+        struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
+        unsigned root_hub = 0;
 
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (!dev)
@@ -255,12 +266,14 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
         dev->dev.dma_mask = bus->controller->dma_mask;
         set_dev_node(&dev->dev, dev_to_node(bus->controller));
         dev->state = USB_STATE_ATTACHED;
+        atomic_set(&dev->urbnum, 0);
 
         INIT_LIST_HEAD(&dev->ep0.urb_list);
         dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
         dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
         /* ep0 maxpacket comes later, from device descriptor */
-        dev->ep_in[0] = dev->ep_out[0] = &dev->ep0;
+        usb_enable_endpoint(dev, &dev->ep0);
+        dev->can_submit = 1;
 
         /* Save readable and stable topology id, distinguishing devices
          * by location for diagnostics, tools, driver model, etc.  The
@@ -275,6 +288,7 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
 
                 dev->dev.parent = bus->controller;
                 sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum);
+                root_hub = 1;
         } else {
                 /* match any labeling on the hubs; it's one-based */
                 if (parent->devpath[0] == '0')
@@ -301,6 +315,12 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
         INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
         dev->autosuspend_delay = usb_autosuspend_delay * HZ;
 #endif
+        if (root_hub)   /* Root hub always ok [and always wired] */
+                dev->authorized = 1;
+        else {
+                dev->authorized = usb_hcd->authorized_default;
+                dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
+        }
         return dev;
 }
 
@@ -748,7 +768,7 @@ void usb_buffer_unmap(struct urb *urb)
 /**
  * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
  * @dev: device to which the scatterlist will be mapped
- * @pipe: endpoint defining the mapping direction
+ * @is_in: mapping transfer direction
  * @sg: the scatterlist to map
  * @nents: the number of entries in the scatterlist
  *
@@ -771,14 +791,13 @@ void usb_buffer_unmap(struct urb *urb)
  *
  * Reverse the effect of this call with usb_buffer_unmap_sg().
  */
-int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
+int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
                       struct scatterlist *sg, int nents)
 {
         struct usb_bus          *bus;
         struct device           *controller;
 
         if (!dev
-                        || usb_pipecontrol(pipe)
                         || !(bus = dev->bus)
                         || !(controller = bus->controller)
                         || !controller->dma_mask)
@@ -786,7 +805,7 @@ int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
 
         // FIXME generic api broken like pci, can't report errors
         return dma_map_sg(controller, sg, nents,
-                        usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
+                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 }
 
 /* XXX DISABLED, no users currently.  If you wish to re-enable this
@@ -799,14 +818,14 @@ int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
 /**
  * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
  * @dev: device to which the scatterlist will be mapped
- * @pipe: endpoint defining the mapping direction
+ * @is_in: mapping transfer direction
  * @sg: the scatterlist to synchronize
  * @n_hw_ents: the positive return value from usb_buffer_map_sg
  *
  * Use this when you are re-using a scatterlist's data buffers for
  * another USB request.
  */
-void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe,
+void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
                            struct scatterlist *sg, int n_hw_ents)
 {
         struct usb_bus          *bus;
@@ -819,20 +838,20 @@ void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe,
                 return;
 
         dma_sync_sg(controller, sg, n_hw_ents,
-                        usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
+                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 }
 #endif
 
 /**
  * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
  * @dev: device to which the scatterlist will be mapped
- * @pipe: endpoint defining the mapping direction
+ * @is_in: mapping transfer direction
  * @sg: the scatterlist to unmap
  * @n_hw_ents: the positive return value from usb_buffer_map_sg
  *
  * Reverses the effect of usb_buffer_map_sg().
  */
-void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe,
+void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
                          struct scatterlist *sg, int n_hw_ents)
 {
         struct usb_bus          *bus;
@@ -845,7 +864,7 @@ void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe,
                 return;
 
         dma_unmap_sg(controller, sg, n_hw_ents,
-                        usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
+                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 }
 
 /* format to disable USB on kernel command line is: nousb */
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index ad5fa0338f..c52626c51f 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -8,17 +8,22 @@ extern int usb_create_ep_files(struct device *parent, struct usb_host_endpoint *
                                 struct usb_device *udev);
 extern void usb_remove_ep_files(struct usb_host_endpoint *endpoint);
 
+extern void usb_enable_endpoint(struct usb_device *dev,
+                struct usb_host_endpoint *ep);
 extern void usb_disable_endpoint (struct usb_device *dev, unsigned int epaddr);
 extern void usb_disable_interface (struct usb_device *dev,
                 struct usb_interface *intf);
 extern void usb_release_interface_cache(struct kref *ref);
 extern void usb_disable_device (struct usb_device *dev, int skip_ep0);
+extern int usb_deauthorize_device (struct usb_device *);
+extern int usb_authorize_device (struct usb_device *);
 extern void usb_detect_quirks(struct usb_device *udev);
 
 extern int usb_get_device_descriptor(struct usb_device *dev,
                 unsigned int size);
 extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
+extern int usb_choose_configuration(struct usb_device *udev);
 
 extern void usb_kick_khubd(struct usb_device *dev);
 extern int usb_match_device(struct usb_device *dev,
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 767aed5b4b..f81d08d653 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -67,6 +67,17 @@ config USB_GADGET_DEBUG_FILES
            driver on a new board.   Enable these files by choosing "Y"
            here.  If in doubt, or to conserve kernel memory, say "N".
 
+config USB_GADGET_DEBUG_FS
+        boolean "Debugging information files in debugfs"
+        depends on USB_GADGET && DEBUG_FS
+        help
+           Some of the drivers in the "gadget" framework can expose
+           debugging information in files under /sys/kernel/debug/.
+           The information in these files may help when you're
+           troubleshooting or bringing up a driver on a new board.
+           Enable these files by choosing "Y" here.  If in doubt, or
+           to conserve kernel memory, say "N".
+
 config  USB_GADGET_SELECTED
         boolean
 
@@ -103,6 +114,20 @@ config USB_AMD5536UDC
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_ATMEL_USBA
+        boolean "Atmel USBA"
+        select USB_GADGET_DUALSPEED
+        depends on AVR32
+        help
+          USBA is the integrated high-speed USB Device controller on
+          the AT32AP700x processors from Atmel.
+
+config USB_ATMEL_USBA
+        tristate
+        depends on USB_GADGET_ATMEL_USBA
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_FSL_USB2
         boolean "Freescale Highspeed USB DR Peripheral Controller"
         depends on MPC834x || PPC_MPC831x
@@ -228,7 +253,6 @@ config USB_LH7A40X
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-
 config USB_GADGET_OMAP
         boolean "OMAP USB Device Controller"
         depends on ARCH_OMAP
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 1bc0f03550..904e57bf61 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_USB_OMAP)		+= omap_udc.o
 obj-$(CONFIG_USB_LH7A40X)       += lh7a40x_udc.o
 obj-$(CONFIG_USB_S3C2410)       += s3c2410_udc.o
 obj-$(CONFIG_USB_AT91)          += at91_udc.o
+obj-$(CONFIG_USB_ATMEL_USBA)    += atmel_usba_udc.o
 obj-$(CONFIG_USB_FSL_USB2)      += fsl_usb2_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 714156ca8f..1c80406025 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -69,7 +69,7 @@
 
 /* gadget stack */
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 /* udc specific */
 #include "amd5536udc.h"
@@ -3244,7 +3244,6 @@ static int udc_pci_probe(
                 retval = -ENOMEM;
                 goto finished;
         }
-        memset(dev, 0, sizeof(struct udc));
 
         /* pci setup */
         if (pci_enable_device(pdev) < 0) {
@@ -3286,14 +3285,12 @@ static int udc_pci_probe(
 
         pci_set_drvdata(pdev, dev);
 
-        /* chip revision */
-        dev->chiprev = 0;
+        /* chip revision for Hs AMD5536 */
+        dev->chiprev = pdev->revision;
 
         pci_set_master(pdev);
         pci_set_mwi(pdev);
 
-        /* chip rev for Hs AMD5536 */
-        pci_read_config_byte(pdev, PCI_REVISION_ID, (u8 *) &dev->chiprev);
         /* init dma pools */
         if (use_dma) {
                 retval = init_dma_pools(dev);
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 63d7d65686..a6adf7e0f6 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -38,7 +38,7 @@
 #include <linux/proc_fs.h>
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
 #include <asm/hardware.h>
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
new file mode 100644
index 0000000000..4fb5ff4695
--- /dev/null
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -0,0 +1,2077 @@
+/*
+ * Driver for the Atmel USBA high speed USB device controller
+ *
+ * Copyright (C) 2005-2007 Atmel Corporation
+ *
+ * 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/clk.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/list.h>
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/delay.h>
+
+#include <asm/gpio.h>
+#include <asm/arch/board.h>
+
+#include "atmel_usba_udc.h"
+
+
+static struct usba_udc the_udc;
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+
+static int queue_dbg_open(struct inode *inode, struct file *file)
+{
+        struct usba_ep *ep = inode->i_private;
+        struct usba_request *req, *req_copy;
+        struct list_head *queue_data;
+
+        queue_data = kmalloc(sizeof(*queue_data), GFP_KERNEL);
+        if (!queue_data)
+                return -ENOMEM;
+        INIT_LIST_HEAD(queue_data);
+
+        spin_lock_irq(&ep->udc->lock);
+        list_for_each_entry(req, &ep->queue, queue) {
+                req_copy = kmalloc(sizeof(*req_copy), GFP_ATOMIC);
+                if (!req_copy)
+                        goto fail;
+                memcpy(req_copy, req, sizeof(*req_copy));
+                list_add_tail(&req_copy->queue, queue_data);
+        }
+        spin_unlock_irq(&ep->udc->lock);
+
+        file->private_data = queue_data;
+        return 0;
+
+fail:
+        spin_unlock_irq(&ep->udc->lock);
+        list_for_each_entry_safe(req, req_copy, queue_data, queue) {
+                list_del(&req->queue);
+                kfree(req);
+        }
+        kfree(queue_data);
+        return -ENOMEM;
+}
+
+/*
+ * bbbbbbbb llllllll IZS sssss nnnn FDL\n\0
+ *
+ * b: buffer address
+ * l: buffer length
+ * I/i: interrupt/no interrupt
+ * Z/z: zero/no zero
+ * S/s: short ok/short not ok
+ * s: status
+ * n: nr_packets
+ * F/f: submitted/not submitted to FIFO
+ * D/d: using/not using DMA
+ * L/l: last transaction/not last transaction
+ */
+static ssize_t queue_dbg_read(struct file *file, char __user *buf,
+                size_t nbytes, loff_t *ppos)
+{
+        struct list_head *queue = file->private_data;
+        struct usba_request *req, *tmp_req;
+        size_t len, remaining, actual = 0;
+        char tmpbuf[38];
+
+        if (!access_ok(VERIFY_WRITE, buf, nbytes))
+                return -EFAULT;
+
+        mutex_lock(&file->f_dentry->d_inode->i_mutex);
+        list_for_each_entry_safe(req, tmp_req, queue, queue) {
+                len = snprintf(tmpbuf, sizeof(tmpbuf),
+                                "%8p %08x %c%c%c %5d %c%c%c\n",
+                                req->req.buf, req->req.length,
+                                req->req.no_interrupt ? 'i' : 'I',
+                                req->req.zero ? 'Z' : 'z',
+                                req->req.short_not_ok ? 's' : 'S',
+                                req->req.status,
+                                req->submitted ? 'F' : 'f',
+                                req->using_dma ? 'D' : 'd',
+                                req->last_transaction ? 'L' : 'l');
+                len = min(len, sizeof(tmpbuf));
+                if (len > nbytes)
+                        break;
+
+                list_del(&req->queue);
+                kfree(req);
+
+                remaining = __copy_to_user(buf, tmpbuf, len);
+                actual += len - remaining;
+                if (remaining)
+                        break;
+
+                nbytes -= len;
+                buf += len;
+        }
+        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+
+        return actual;
+}
+
+static int queue_dbg_release(struct inode *inode, struct file *file)
+{
+        struct list_head *queue_data = file->private_data;
+        struct usba_request *req, *tmp_req;
+
+        list_for_each_entry_safe(req, tmp_req, queue_data, queue) {
+                list_del(&req->queue);
+                kfree(req);
+        }
+        kfree(queue_data);
+        return 0;
+}
+
+static int regs_dbg_open(struct inode *inode, struct file *file)
+{
+        struct usba_udc *udc;
+        unsigned int i;
+        u32 *data;
+        int ret = -ENOMEM;
+
+        mutex_lock(&inode->i_mutex);
+        udc = inode->i_private;
+        data = kmalloc(inode->i_size, GFP_KERNEL);
+        if (!data)
+                goto out;
+
+        spin_lock_irq(&udc->lock);
+        for (i = 0; i < inode->i_size / 4; i++)
+                data[i] = __raw_readl(udc->regs + i * 4);
+        spin_unlock_irq(&udc->lock);
+
+        file->private_data = data;
+        ret = 0;
+
+out:
+        mutex_unlock(&inode->i_mutex);
+
+        return ret;
+}
+
+static ssize_t regs_dbg_read(struct file *file, char __user *buf,
+                size_t nbytes, loff_t *ppos)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        int ret;
+
+        mutex_lock(&inode->i_mutex);
+        ret = simple_read_from_buffer(buf, nbytes, ppos,
+                        file->private_data,
+                        file->f_dentry->d_inode->i_size);
+        mutex_unlock(&inode->i_mutex);
+
+        return ret;
+}
+
+static int regs_dbg_release(struct inode *inode, struct file *file)
+{
+        kfree(file->private_data);
+        return 0;
+}
+
+const struct file_operations queue_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = queue_dbg_open,
+        .llseek         = no_llseek,
+        .read           = queue_dbg_read,
+        .release        = queue_dbg_release,
+};
+
+const struct file_operations regs_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = regs_dbg_open,
+        .llseek         = generic_file_llseek,
+        .read           = regs_dbg_read,
+        .release        = regs_dbg_release,
+};
+
+static void usba_ep_init_debugfs(struct usba_udc *udc,
+                struct usba_ep *ep)
+{
+        struct dentry *ep_root;
+
+        ep_root = debugfs_create_dir(ep->ep.name, udc->debugfs_root);
+        if (!ep_root)
+                goto err_root;
+        ep->debugfs_dir = ep_root;
+
+        ep->debugfs_queue = debugfs_create_file("queue", 0400, ep_root,
+                                                ep, &queue_dbg_fops);
+        if (!ep->debugfs_queue)
+                goto err_queue;
+
+        if (ep->can_dma) {
+                ep->debugfs_dma_status
+                        = debugfs_create_u32("dma_status", 0400, ep_root,
+                                        &ep->last_dma_status);
+                if (!ep->debugfs_dma_status)
+                        goto err_dma_status;
+        }
+        if (ep_is_control(ep)) {
+                ep->debugfs_state
+                        = debugfs_create_u32("state", 0400, ep_root,
+                                        &ep->state);
+                if (!ep->debugfs_state)
+                        goto err_state;
+        }
+
+        return;
+
+err_state:
+        if (ep->can_dma)
+                debugfs_remove(ep->debugfs_dma_status);
+err_dma_status:
+        debugfs_remove(ep->debugfs_queue);
+err_queue:
+        debugfs_remove(ep_root);
+err_root:
+        dev_err(&ep->udc->pdev->dev,
+                "failed to create debugfs directory for %s\n", ep->ep.name);
+}
+
+static void usba_ep_cleanup_debugfs(struct usba_ep *ep)
+{
+        debugfs_remove(ep->debugfs_queue);
+        debugfs_remove(ep->debugfs_dma_status);
+        debugfs_remove(ep->debugfs_state);
+        debugfs_remove(ep->debugfs_dir);
+        ep->debugfs_dma_status = NULL;
+        ep->debugfs_dir = NULL;
+}
+
+static void usba_init_debugfs(struct usba_udc *udc)
+{
+        struct dentry *root, *regs;
+        struct resource *regs_resource;
+
+        root = debugfs_create_dir(udc->gadget.name, NULL);
+        if (IS_ERR(root) || !root)
+                goto err_root;
+        udc->debugfs_root = root;
+
+        regs = debugfs_create_file("regs", 0400, root, udc, &regs_dbg_fops);
+        if (!regs)
+                goto err_regs;
+
+        regs_resource = platform_get_resource(udc->pdev, IORESOURCE_MEM,
+                                CTRL_IOMEM_ID);
+        regs->d_inode->i_size = regs_resource->end - regs_resource->start + 1;
+        udc->debugfs_regs = regs;
+
+        usba_ep_init_debugfs(udc, to_usba_ep(udc->gadget.ep0));
+
+        return;
+
+err_regs:
+        debugfs_remove(root);
+err_root:
+        udc->debugfs_root = NULL;
+        dev_err(&udc->pdev->dev, "debugfs is not available\n");
+}
+
+static void usba_cleanup_debugfs(struct usba_udc *udc)
+{
+        usba_ep_cleanup_debugfs(to_usba_ep(udc->gadget.ep0));
+        debugfs_remove(udc->debugfs_regs);
+        debugfs_remove(udc->debugfs_root);
+        udc->debugfs_regs = NULL;
+        udc->debugfs_root = NULL;
+}
+#else
+static inline void usba_ep_init_debugfs(struct usba_udc *udc,
+                                         struct usba_ep *ep)
+{
+
+}
+
+static inline void usba_ep_cleanup_debugfs(struct usba_ep *ep)
+{
+
+}
+
+static inline void usba_init_debugfs(struct usba_udc *udc)
+{
+
+}
+
+static inline void usba_cleanup_debugfs(struct usba_udc *udc)
+{
+
+}
+#endif
+
+static int vbus_is_present(struct usba_udc *udc)
+{
+        if (udc->vbus_pin != -1)
+                return gpio_get_value(udc->vbus_pin);
+
+        /* No Vbus detection: Assume always present */
+        return 1;
+}
+
+static void copy_to_fifo(void __iomem *fifo, const void *buf, int len)
+{
+        unsigned long tmp;
+
+        DBG(DBG_FIFO, "copy to FIFO (len %d):\n", len);
+        for (; len > 0; len -= 4, buf += 4, fifo += 4) {
+                tmp = *(unsigned long *)buf;
+                if (len >= 4) {
+                        DBG(DBG_FIFO, "  -> %08lx\n", tmp);
+                        __raw_writel(tmp, fifo);
+                } else {
+                        do {
+                                DBG(DBG_FIFO, "  -> %02lx\n", tmp >> 24);
+                                __raw_writeb(tmp >> 24, fifo);
+                                fifo++;
+                                tmp <<= 8;
+                        } while (--len);
+                        break;
+                }
+        }
+}
+
+static void copy_from_fifo(void *buf, void __iomem *fifo, int len)
+{
+        union {
+                unsigned long *w;
+                unsigned char *b;
+        } p;
+        unsigned long tmp;
+
+        DBG(DBG_FIFO, "copy from FIFO (len %d):\n", len);
+        for (p.w = buf; len > 0; len -= 4, p.w++, fifo += 4) {
+                if (len >= 4) {
+                        tmp = __raw_readl(fifo);
+                        *p.w = tmp;
+                        DBG(DBG_FIFO, "  -> %08lx\n", tmp);
+                } else {
+                        do {
+                                tmp = __raw_readb(fifo);
+                                *p.b = tmp;
+                                DBG(DBG_FIFO, " -> %02lx\n", tmp);
+                                fifo++, p.b++;
+                        } while (--len);
+                }
+        }
+}
+
+static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req)
+{
+        unsigned int transaction_len;
+
+        transaction_len = req->req.length - req->req.actual;
+        req->last_transaction = 1;
+        if (transaction_len > ep->ep.maxpacket) {
+                transaction_len = ep->ep.maxpacket;
+                req->last_transaction = 0;
+        } else if (transaction_len == ep->ep.maxpacket && req->req.zero)
+                req->last_transaction = 0;
+
+        DBG(DBG_QUEUE, "%s: submit_transaction, req %p (length %d)%s\n",
+                ep->ep.name, req, transaction_len,
+                req->last_transaction ? ", done" : "");
+
+        copy_to_fifo(ep->fifo, req->req.buf + req->req.actual, transaction_len);
+        usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
+        req->req.actual += transaction_len;
+}
+
+static void submit_request(struct usba_ep *ep, struct usba_request *req)
+{
+        DBG(DBG_QUEUE, "%s: submit_request: req %p (length %d)\n",
+                ep->ep.name, req, req->req.length);
+
+        req->req.actual = 0;
+        req->submitted = 1;
+
+        if (req->using_dma) {
+                if (req->req.length == 0) {
+                        usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
+                        return;
+                }
+
+                if (req->req.zero)
+                        usba_ep_writel(ep, CTL_ENB, USBA_SHORT_PACKET);
+                else
+                        usba_ep_writel(ep, CTL_DIS, USBA_SHORT_PACKET);
+
+                usba_dma_writel(ep, ADDRESS, req->req.dma);
+                usba_dma_writel(ep, CONTROL, req->ctrl);
+        } else {
+                next_fifo_transaction(ep, req);
+                if (req->last_transaction) {
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
+                        usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
+                } else {
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
+                        usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
+                }
+        }
+}
+
+static void submit_next_request(struct usba_ep *ep)
+{
+        struct usba_request *req;
+
+        if (list_empty(&ep->queue)) {
+                usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY | USBA_RX_BK_RDY);
+                return;
+        }
+
+        req = list_entry(ep->queue.next, struct usba_request, queue);
+        if (!req->submitted)
+                submit_request(ep, req);
+}
+
+static void send_status(struct usba_udc *udc, struct usba_ep *ep)
+{
+        ep->state = STATUS_STAGE_IN;
+        usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
+        usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
+}
+
+static void receive_data(struct usba_ep *ep)
+{
+        struct usba_udc *udc = ep->udc;
+        struct usba_request *req;
+        unsigned long status;
+        unsigned int bytecount, nr_busy;
+        int is_complete = 0;
+
+        status = usba_ep_readl(ep, STA);
+        nr_busy = USBA_BFEXT(BUSY_BANKS, status);
+
+        DBG(DBG_QUEUE, "receive data: nr_busy=%u\n", nr_busy);
+
+        while (nr_busy > 0) {
+                if (list_empty(&ep->queue)) {
+                        usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
+                        break;
+                }
+                req = list_entry(ep->queue.next,
+                                 struct usba_request, queue);
+
+                bytecount = USBA_BFEXT(BYTE_COUNT, status);
+
+                if (status & (1 << 31))
+                        is_complete = 1;
+                if (req->req.actual + bytecount >= req->req.length) {
+                        is_complete = 1;
+                        bytecount = req->req.length - req->req.actual;
+                }
+
+                copy_from_fifo(req->req.buf + req->req.actual,
+                                ep->fifo, bytecount);
+                req->req.actual += bytecount;
+
+                usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
+
+                if (is_complete) {
+                        DBG(DBG_QUEUE, "%s: request done\n", ep->ep.name);
+                        req->req.status = 0;
+                        list_del_init(&req->queue);
+                        usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
+                        spin_unlock(&udc->lock);
+                        req->req.complete(&ep->ep, &req->req);
+                        spin_lock(&udc->lock);
+                }
+
+                status = usba_ep_readl(ep, STA);
+                nr_busy = USBA_BFEXT(BUSY_BANKS, status);
+
+                if (is_complete && ep_is_control(ep)) {
+                        send_status(udc, ep);
+                        break;
+                }
+        }
+}
+
+static void
+request_complete(struct usba_ep *ep, struct usba_request *req, int status)
+{
+        struct usba_udc *udc = ep->udc;
+
+        WARN_ON(!list_empty(&req->queue));
+
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = status;
+
+        if (req->mapped) {
+                dma_unmap_single(
+                        &udc->pdev->dev, req->req.dma, req->req.length,
+                        ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                req->req.dma = DMA_ADDR_INVALID;
+                req->mapped = 0;
+        }
+
+        DBG(DBG_GADGET | DBG_REQ,
+                "%s: req %p complete: status %d, actual %u\n",
+                ep->ep.name, req, req->req.status, req->req.actual);
+
+        spin_unlock(&udc->lock);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&udc->lock);
+}
+
+static void
+request_complete_list(struct usba_ep *ep, struct list_head *list, int status)
+{
+        struct usba_request *req, *tmp_req;
+
+        list_for_each_entry_safe(req, tmp_req, list, queue) {
+                list_del_init(&req->queue);
+                request_complete(ep, req, status);
+        }
+}
+
+static int
+usba_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+        unsigned long flags, ept_cfg, maxpacket;
+        unsigned int nr_trans;
+
+        DBG(DBG_GADGET, "%s: ep_enable: desc=%p\n", ep->ep.name, desc);
+
+        maxpacket = le16_to_cpu(desc->wMaxPacketSize) & 0x7ff;
+
+        if (((desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK) != ep->index)
+                        || ep->index == 0
+                        || desc->bDescriptorType != USB_DT_ENDPOINT
+                        || maxpacket == 0
+                        || maxpacket > ep->fifo_size) {
+                DBG(DBG_ERR, "ep_enable: Invalid argument");
+                return -EINVAL;
+        }
+
+        ep->is_isoc = 0;
+        ep->is_in = 0;
+
+        if (maxpacket <= 8)
+                ept_cfg = USBA_BF(EPT_SIZE, USBA_EPT_SIZE_8);
+        else
+                /* LSB is bit 1, not 0 */
+                ept_cfg = USBA_BF(EPT_SIZE, fls(maxpacket - 1) - 3);
+
+        DBG(DBG_HW, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n",
+                        ep->ep.name, ept_cfg, maxpacket);
+
+        if ((desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) {
+                ep->is_in = 1;
+                ept_cfg |= USBA_EPT_DIR_IN;
+        }
+
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL);
+                ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE);
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                if (!ep->can_isoc) {
+                        DBG(DBG_ERR, "ep_enable: %s is not isoc capable\n",
+                                        ep->ep.name);
+                        return -EINVAL;
+                }
+
+                /*
+                 * Bits 11:12 specify number of _additional_
+                 * transactions per microframe.
+                 */
+                nr_trans = ((le16_to_cpu(desc->wMaxPacketSize) >> 11) & 3) + 1;
+                if (nr_trans > 3)
+                        return -EINVAL;
+
+                ep->is_isoc = 1;
+                ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_ISO);
+
+                /*
+                 * Do triple-buffering on high-bandwidth iso endpoints.
+                 */
+                if (nr_trans > 1 && ep->nr_banks == 3)
+                        ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_TRIPLE);
+                else
+                        ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE);
+                ept_cfg |= USBA_BF(NB_TRANS, nr_trans);
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK);
+                ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE);
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_INT);
+                ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE);
+                break;
+        }
+
+        spin_lock_irqsave(&ep->udc->lock, flags);
+
+        if (ep->desc) {
+                spin_unlock_irqrestore(&ep->udc->lock, flags);
+                DBG(DBG_ERR, "ep%d already enabled\n", ep->index);
+                return -EBUSY;
+        }
+
+        ep->desc = desc;
+        ep->ep.maxpacket = maxpacket;
+
+        usba_ep_writel(ep, CFG, ept_cfg);
+        usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
+
+        if (ep->can_dma) {
+                u32 ctrl;
+
+                usba_writel(udc, INT_ENB,
+                                (usba_readl(udc, INT_ENB)
+                                        | USBA_BF(EPT_INT, 1 << ep->index)
+                                        | USBA_BF(DMA_INT, 1 << ep->index)));
+                ctrl = USBA_AUTO_VALID | USBA_INTDIS_DMA;
+                usba_ep_writel(ep, CTL_ENB, ctrl);
+        } else {
+                usba_writel(udc, INT_ENB,
+                                (usba_readl(udc, INT_ENB)
+                                        | USBA_BF(EPT_INT, 1 << ep->index)));
+        }
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        DBG(DBG_HW, "EPT_CFG%d after init: %#08lx\n", ep->index,
+                        (unsigned long)usba_ep_readl(ep, CFG));
+        DBG(DBG_HW, "INT_ENB after init: %#08lx\n",
+                        (unsigned long)usba_readl(udc, INT_ENB));
+
+        return 0;
+}
+
+static int usba_ep_disable(struct usb_ep *_ep)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+        LIST_HEAD(req_list);
+        unsigned long flags;
+
+        DBG(DBG_GADGET, "ep_disable: %s\n", ep->ep.name);
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        if (!ep->desc) {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                DBG(DBG_ERR, "ep_disable: %s not enabled\n", ep->ep.name);
+                return -EINVAL;
+        }
+        ep->desc = NULL;
+
+        list_splice_init(&ep->queue, &req_list);
+        if (ep->can_dma) {
+                usba_dma_writel(ep, CONTROL, 0);
+                usba_dma_writel(ep, ADDRESS, 0);
+                usba_dma_readl(ep, STATUS);
+        }
+        usba_ep_writel(ep, CTL_DIS, USBA_EPT_ENABLE);
+        usba_writel(udc, INT_ENB,
+                        usba_readl(udc, INT_ENB)
+                        & ~USBA_BF(EPT_INT, 1 << ep->index));
+
+        request_complete_list(ep, &req_list, -ESHUTDOWN);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static struct usb_request *
+usba_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
+{
+        struct usba_request *req;
+
+        DBG(DBG_GADGET, "ep_alloc_request: %p, 0x%x\n", _ep, gfp_flags);
+
+        req = kzalloc(sizeof(*req), gfp_flags);
+        if (!req)
+                return NULL;
+
+        INIT_LIST_HEAD(&req->queue);
+        req->req.dma = DMA_ADDR_INVALID;
+
+        return &req->req;
+}
+
+static void
+usba_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct usba_request *req = to_usba_req(_req);
+
+        DBG(DBG_GADGET, "ep_free_request: %p, %p\n", _ep, _req);
+
+        kfree(req);
+}
+
+static int queue_dma(struct usba_udc *udc, struct usba_ep *ep,
+                struct usba_request *req, gfp_t gfp_flags)
+{
+        unsigned long flags;
+        int ret;
+
+        DBG(DBG_DMA, "%s: req l/%u d/%08x %c%c%c\n",
+                ep->ep.name, req->req.length, req->req.dma,
+                req->req.zero ? 'Z' : 'z',
+                req->req.short_not_ok ? 'S' : 's',
+                req->req.no_interrupt ? 'I' : 'i');
+
+        if (req->req.length > 0x10000) {
+                /* Lengths from 0 to 65536 (inclusive) are supported */
+                DBG(DBG_ERR, "invalid request length %u\n", req->req.length);
+                return -EINVAL;
+        }
+
+        req->using_dma = 1;
+
+        if (req->req.dma == DMA_ADDR_INVALID) {
+                req->req.dma = dma_map_single(
+                        &udc->pdev->dev, req->req.buf, req->req.length,
+                        ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                req->mapped = 1;
+        } else {
+                dma_sync_single_for_device(
+                        &udc->pdev->dev, req->req.dma, req->req.length,
+                        ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                req->mapped = 0;
+        }
+
+        req->ctrl = USBA_BF(DMA_BUF_LEN, req->req.length)
+                        | USBA_DMA_CH_EN | USBA_DMA_END_BUF_IE
+                        | USBA_DMA_END_TR_EN | USBA_DMA_END_TR_IE;
+
+        if (ep->is_in)
+                req->ctrl |= USBA_DMA_END_BUF_EN;
+
+        /*
+         * Add this request to the queue and submit for DMA if
+         * possible. Check if we're still alive first -- we may have
+         * received a reset since last time we checked.
+         */
+        ret = -ESHUTDOWN;
+        spin_lock_irqsave(&udc->lock, flags);
+        if (ep->desc) {
+                if (list_empty(&ep->queue))
+                        submit_request(ep, req);
+
+                list_add_tail(&req->queue, &ep->queue);
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+static int
+usba_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+{
+        struct usba_request *req = to_usba_req(_req);
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+        unsigned long flags;
+        int ret;
+
+        DBG(DBG_GADGET | DBG_QUEUE | DBG_REQ, "%s: queue req %p, len %u\n",
+                        ep->ep.name, req, _req->length);
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN || !ep->desc)
+                return -ESHUTDOWN;
+
+        req->submitted = 0;
+        req->using_dma = 0;
+        req->last_transaction = 0;
+
+        _req->status = -EINPROGRESS;
+        _req->actual = 0;
+
+        if (ep->can_dma)
+                return queue_dma(udc, ep, req, gfp_flags);
+
+        /* May have received a reset since last time we checked */
+        ret = -ESHUTDOWN;
+        spin_lock_irqsave(&udc->lock, flags);
+        if (ep->desc) {
+                list_add_tail(&req->queue, &ep->queue);
+
+                if (ep->is_in || (ep_is_control(ep)
+                                && (ep->state == DATA_STAGE_IN
+                                        || ep->state == STATUS_STAGE_IN)))
+                        usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
+                else
+                        usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY);
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+static void
+usba_update_req(struct usba_ep *ep, struct usba_request *req, u32 status)
+{
+        req->req.actual = req->req.length - USBA_BFEXT(DMA_BUF_LEN, status);
+}
+
+static int stop_dma(struct usba_ep *ep, u32 *pstatus)
+{
+        unsigned int timeout;
+        u32 status;
+
+        /*
+         * Stop the DMA controller. When writing both CH_EN
+         * and LINK to 0, the other bits are not affected.
+         */
+        usba_dma_writel(ep, CONTROL, 0);
+
+        /* Wait for the FIFO to empty */
+        for (timeout = 40; timeout; --timeout) {
+                status = usba_dma_readl(ep, STATUS);
+                if (!(status & USBA_DMA_CH_EN))
+                        break;
+                udelay(1);
+        }
+
+        if (pstatus)
+                *pstatus = status;
+
+        if (timeout == 0) {
+                dev_err(&ep->udc->pdev->dev,
+                        "%s: timed out waiting for DMA FIFO to empty\n",
+                        ep->ep.name);
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static int usba_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+        struct usba_request *req = to_usba_req(_req);
+        unsigned long flags;
+        u32 status;
+
+        DBG(DBG_GADGET | DBG_QUEUE, "ep_dequeue: %s, req %p\n",
+                        ep->ep.name, req);
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        if (req->using_dma) {
+                /*
+                 * If this request is currently being transferred,
+                 * stop the DMA controller and reset the FIFO.
+                 */
+                if (ep->queue.next == &req->queue) {
+                        status = usba_dma_readl(ep, STATUS);
+                        if (status & USBA_DMA_CH_EN)
+                                stop_dma(ep, &status);
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+                        ep->last_dma_status = status;
+#endif
+
+                        usba_writel(udc, EPT_RST, 1 << ep->index);
+
+                        usba_update_req(ep, req, status);
+                }
+        }
+
+        /*
+         * Errors should stop the queue from advancing until the
+         * completion function returns.
+         */
+        list_del_init(&req->queue);
+
+        request_complete(ep, req, -ECONNRESET);
+
+        /* Process the next request if any */
+        submit_next_request(ep);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static int usba_ep_set_halt(struct usb_ep *_ep, int value)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+        unsigned long flags;
+        int ret = 0;
+
+        DBG(DBG_GADGET, "endpoint %s: %s HALT\n", ep->ep.name,
+                        value ? "set" : "clear");
+
+        if (!ep->desc) {
+                DBG(DBG_ERR, "Attempted to halt uninitialized ep %s\n",
+                                ep->ep.name);
+                return -ENODEV;
+        }
+        if (ep->is_isoc) {
+                DBG(DBG_ERR, "Attempted to halt isochronous ep %s\n",
+                                ep->ep.name);
+                return -ENOTTY;
+        }
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /*
+         * We can't halt IN endpoints while there are still data to be
+         * transferred
+         */
+        if (!list_empty(&ep->queue)
+                        || ((value && ep->is_in && (usba_ep_readl(ep, STA)
+                                        & USBA_BF(BUSY_BANKS, -1L))))) {
+                ret = -EAGAIN;
+        } else {
+                if (value)
+                        usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL);
+                else
+                        usba_ep_writel(ep, CLR_STA,
+                                        USBA_FORCE_STALL | USBA_TOGGLE_CLR);
+                usba_ep_readl(ep, STA);
+        }
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+static int usba_ep_fifo_status(struct usb_ep *_ep)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+
+        return USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA));
+}
+
+static void usba_ep_fifo_flush(struct usb_ep *_ep)
+{
+        struct usba_ep *ep = to_usba_ep(_ep);
+        struct usba_udc *udc = ep->udc;
+
+        usba_writel(udc, EPT_RST, 1 << ep->index);
+}
+
+static const struct usb_ep_ops usba_ep_ops = {
+        .enable         = usba_ep_enable,
+        .disable        = usba_ep_disable,
+        .alloc_request  = usba_ep_alloc_request,
+        .free_request   = usba_ep_free_request,
+        .queue          = usba_ep_queue,
+        .dequeue        = usba_ep_dequeue,
+        .set_halt       = usba_ep_set_halt,
+        .fifo_status    = usba_ep_fifo_status,
+        .fifo_flush     = usba_ep_fifo_flush,
+};
+
+static int usba_udc_get_frame(struct usb_gadget *gadget)
+{
+        struct usba_udc *udc = to_usba_udc(gadget);
+
+        return USBA_BFEXT(FRAME_NUMBER, usba_readl(udc, FNUM));
+}
+
+static int usba_udc_wakeup(struct usb_gadget *gadget)
+{
+        struct usba_udc *udc = to_usba_udc(gadget);
+        unsigned long flags;
+        u32 ctrl;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (udc->devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
+                ctrl = usba_readl(udc, CTRL);
+                usba_writel(udc, CTRL, ctrl | USBA_REMOTE_WAKE_UP);
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+static int
+usba_udc_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered)
+{
+        struct usba_udc *udc = to_usba_udc(gadget);
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (is_selfpowered)
+                udc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
+        else
+                udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static const struct usb_gadget_ops usba_udc_ops = {
+        .get_frame              = usba_udc_get_frame,
+        .wakeup                 = usba_udc_wakeup,
+        .set_selfpowered        = usba_udc_set_selfpowered,
+};
+
+#define EP(nam, idx, maxpkt, maxbk, dma, isoc)                  \
+{                                                               \
+        .ep     = {                                             \
+                .ops            = &usba_ep_ops,                 \
+                .name           = nam,                          \
+                .maxpacket      = maxpkt,                       \
+        },                                                      \
+        .udc            = &the_udc,                             \
+        .queue          = LIST_HEAD_INIT(usba_ep[idx].queue),   \
+        .fifo_size      = maxpkt,                               \
+        .nr_banks       = maxbk,                                \
+        .index          = idx,                                  \
+        .can_dma        = dma,                                  \
+        .can_isoc       = isoc,                                 \
+}
+
+static struct usba_ep usba_ep[] = {
+        EP("ep0", 0, 64, 1, 0, 0),
+        EP("ep1in-bulk", 1, 512, 2, 1, 1),
+        EP("ep2out-bulk", 2, 512, 2, 1, 1),
+        EP("ep3in-int", 3, 64, 3, 1, 0),
+        EP("ep4out-int", 4, 64, 3, 1, 0),
+        EP("ep5in-iso", 5, 1024, 3, 1, 1),
+        EP("ep6out-iso", 6, 1024, 3, 1, 1),
+};
+#undef EP
+
+static struct usb_endpoint_descriptor usba_ep0_desc = {
+        .bLength = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+        .bEndpointAddress = 0,
+        .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize = __constant_cpu_to_le16(64),
+        /* FIXME: I have no idea what to put here */
+        .bInterval = 1,
+};
+
+static void nop_release(struct device *dev)
+{
+
+}
+
+static struct usba_udc the_udc = {
+        .gadget = {
+                .ops            = &usba_udc_ops,
+                .ep0            = &usba_ep[0].ep,
+                .ep_list        = LIST_HEAD_INIT(the_udc.gadget.ep_list),
+                .is_dualspeed   = 1,
+                .name           = "atmel_usba_udc",
+                .dev    = {
+                        .bus_id         = "gadget",
+                        .release        = nop_release,
+                },
+        },
+
+        .lock   = SPIN_LOCK_UNLOCKED,
+};
+
+/*
+ * Called with interrupts disabled and udc->lock held.
+ */
+static void reset_all_endpoints(struct usba_udc *udc)
+{
+        struct usba_ep *ep;
+        struct usba_request *req, *tmp_req;
+
+        usba_writel(udc, EPT_RST, ~0UL);
+
+        ep = to_usba_ep(udc->gadget.ep0);
+        list_for_each_entry_safe(req, tmp_req, &ep->queue, queue) {
+                list_del_init(&req->queue);
+                request_complete(ep, req, -ECONNRESET);
+        }
+
+        list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
+                if (ep->desc) {
+                        spin_unlock(&udc->lock);
+                        usba_ep_disable(&ep->ep);
+                        spin_lock(&udc->lock);
+                }
+        }
+}
+
+static struct usba_ep *get_ep_by_addr(struct usba_udc *udc, u16 wIndex)
+{
+        struct usba_ep *ep;
+
+        if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
+                return to_usba_ep(udc->gadget.ep0);
+
+        list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
+                u8 bEndpointAddress;
+
+                if (!ep->desc)
+                        continue;
+                bEndpointAddress = ep->desc->bEndpointAddress;
+                if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
+                        continue;
+                if ((bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)
+                                == (wIndex & USB_ENDPOINT_NUMBER_MASK))
+                        return ep;
+        }
+
+        return NULL;
+}
+
+/* Called with interrupts disabled and udc->lock held */
+static inline void set_protocol_stall(struct usba_udc *udc, struct usba_ep *ep)
+{
+        usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL);
+        ep->state = WAIT_FOR_SETUP;
+}
+
+static inline int is_stalled(struct usba_udc *udc, struct usba_ep *ep)
+{
+        if (usba_ep_readl(ep, STA) & USBA_FORCE_STALL)
+                return 1;
+        return 0;
+}
+
+static inline void set_address(struct usba_udc *udc, unsigned int addr)
+{
+        u32 regval;
+
+        DBG(DBG_BUS, "setting address %u...\n", addr);
+        regval = usba_readl(udc, CTRL);
+        regval = USBA_BFINS(DEV_ADDR, addr, regval);
+        usba_writel(udc, CTRL, regval);
+}
+
+static int do_test_mode(struct usba_udc *udc)
+{
+        static const char test_packet_buffer[] = {
+                /* JKJKJKJK * 9 */
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                /* JJKKJJKK * 8 */
+                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+                /* JJKKJJKK * 8 */
+                0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
+                /* JJJJJJJKKKKKKK * 8 */
+                0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                /* JJJJJJJK * 8 */
+                0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
+                /* {JKKKKKKK * 10}, JK */
+                0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E
+        };
+        struct usba_ep *ep;
+        struct device *dev = &udc->pdev->dev;
+        int test_mode;
+
+        test_mode = udc->test_mode;
+
+        /* Start from a clean slate */
+        reset_all_endpoints(udc);
+
+        switch (test_mode) {
+        case 0x0100:
+                /* Test_J */
+                usba_writel(udc, TST, USBA_TST_J_MODE);
+                dev_info(dev, "Entering Test_J mode...\n");
+                break;
+        case 0x0200:
+                /* Test_K */
+                usba_writel(udc, TST, USBA_TST_K_MODE);
+                dev_info(dev, "Entering Test_K mode...\n");
+                break;
+        case 0x0300:
+                /*
+                 * Test_SE0_NAK: Force high-speed mode and set up ep0
+                 * for Bulk IN transfers
+                 */
+                ep = &usba_ep[0];
+                usba_writel(udc, TST,
+                                USBA_BF(SPEED_CFG, USBA_SPEED_CFG_FORCE_HIGH));
+                usba_ep_writel(ep, CFG,
+                                USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64)
+                                | USBA_EPT_DIR_IN
+                                | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK)
+                                | USBA_BF(BK_NUMBER, 1));
+                if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) {
+                        set_protocol_stall(udc, ep);
+                        dev_err(dev, "Test_SE0_NAK: ep0 not mapped\n");
+                } else {
+                        usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
+                        dev_info(dev, "Entering Test_SE0_NAK mode...\n");
+                }
+                break;
+        case 0x0400:
+                /* Test_Packet */
+                ep = &usba_ep[0];
+                usba_ep_writel(ep, CFG,
+                                USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64)
+                                | USBA_EPT_DIR_IN
+                                | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK)
+                                | USBA_BF(BK_NUMBER, 1));
+                if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) {
+                        set_protocol_stall(udc, ep);
+                        dev_err(dev, "Test_Packet: ep0 not mapped\n");
+                } else {
+                        usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
+                        usba_writel(udc, TST, USBA_TST_PKT_MODE);
+                        copy_to_fifo(ep->fifo, test_packet_buffer,
+                                        sizeof(test_packet_buffer));
+                        usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
+                        dev_info(dev, "Entering Test_Packet mode...\n");
+                }
+                break;
+        default:
+                dev_err(dev, "Invalid test mode: 0x%04x\n", test_mode);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* 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))
+                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))
+                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))
+                return true;
+        return false;
+}
+
+static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
+                struct usb_ctrlrequest *crq)
+{
+        int retval = 0;;
+
+        switch (crq->bRequest) {
+        case USB_REQ_GET_STATUS: {
+                u16 status;
+
+                if (crq->bRequestType == (USB_DIR_IN | USB_RECIP_DEVICE)) {
+                        status = cpu_to_le16(udc->devstatus);
+                } else if (crq->bRequestType
+                                == (USB_DIR_IN | USB_RECIP_INTERFACE)) {
+                        status = __constant_cpu_to_le16(0);
+                } else if (crq->bRequestType
+                                == (USB_DIR_IN | USB_RECIP_ENDPOINT)) {
+                        struct usba_ep *target;
+
+                        target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
+                        if (!target)
+                                goto stall;
+
+                        status = 0;
+                        if (is_stalled(udc, target))
+                                status |= __constant_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)))
+                        goto stall;
+                ep->state = DATA_STAGE_IN;
+                __raw_writew(status, ep->fifo);
+                usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
+                break;
+        }
+
+        case USB_REQ_CLEAR_FEATURE: {
+                if (crq->bRequestType == USB_RECIP_DEVICE) {
+                        if (feature_is_dev_remote_wakeup(crq))
+                                udc->devstatus
+                                        &= ~(1 << USB_DEVICE_REMOTE_WAKEUP);
+                        else
+                                /* Can't CLEAR_FEATURE TEST_MODE */
+                                goto stall;
+                } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
+                        struct usba_ep *target;
+
+                        if (crq->wLength != __constant_cpu_to_le16(0)
+                                        || !feature_is_ep_halt(crq))
+                                goto stall;
+                        target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
+                        if (!target)
+                                goto stall;
+
+                        usba_ep_writel(target, CLR_STA, USBA_FORCE_STALL);
+                        if (target->index != 0)
+                                usba_ep_writel(target, CLR_STA,
+                                                USBA_TOGGLE_CLR);
+                } else {
+                        goto delegate;
+                }
+
+                send_status(udc, ep);
+                break;
+        }
+
+        case USB_REQ_SET_FEATURE: {
+                if (crq->bRequestType == USB_RECIP_DEVICE) {
+                        if (feature_is_dev_test_mode(crq)) {
+                                send_status(udc, ep);
+                                ep->state = STATUS_STAGE_TEST;
+                                udc->test_mode = le16_to_cpu(crq->wIndex);
+                                return 0;
+                        } else if (feature_is_dev_remote_wakeup(crq)) {
+                                udc->devstatus |= 1 << USB_DEVICE_REMOTE_WAKEUP;
+                        } else {
+                                goto stall;
+                        }
+                } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
+                        struct usba_ep *target;
+
+                        if (crq->wLength != __constant_cpu_to_le16(0)
+                                        || !feature_is_ep_halt(crq))
+                                goto stall;
+
+                        target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
+                        if (!target)
+                                goto stall;
+
+                        usba_ep_writel(target, SET_STA, USBA_FORCE_STALL);
+                } else
+                        goto delegate;
+
+                send_status(udc, ep);
+                break;
+        }
+
+        case USB_REQ_SET_ADDRESS:
+                if (crq->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
+                        goto delegate;
+
+                set_address(udc, le16_to_cpu(crq->wValue));
+                send_status(udc, ep);
+                ep->state = STATUS_STAGE_ADDR;
+                break;
+
+        default:
+delegate:
+                spin_unlock(&udc->lock);
+                retval = udc->driver->setup(&udc->gadget, crq);
+                spin_lock(&udc->lock);
+        }
+
+        return retval;
+
+stall:
+        printk(KERN_ERR
+                "udc: %s: Invalid setup request: %02x.%02x v%04x i%04x l%d, "
+                "halting endpoint...\n",
+                ep->ep.name, crq->bRequestType, crq->bRequest,
+                le16_to_cpu(crq->wValue), le16_to_cpu(crq->wIndex),
+                le16_to_cpu(crq->wLength));
+        set_protocol_stall(udc, ep);
+        return -1;
+}
+
+static void usba_control_irq(struct usba_udc *udc, struct usba_ep *ep)
+{
+        struct usba_request *req;
+        u32 epstatus;
+        u32 epctrl;
+
+restart:
+        epstatus = usba_ep_readl(ep, STA);
+        epctrl = usba_ep_readl(ep, CTL);
+
+        DBG(DBG_INT, "%s [%d]: s/%08x c/%08x\n",
+                        ep->ep.name, ep->state, epstatus, epctrl);
+
+        req = NULL;
+        if (!list_empty(&ep->queue))
+                req = list_entry(ep->queue.next,
+                                 struct usba_request, queue);
+
+        if ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) {
+                if (req->submitted)
+                        next_fifo_transaction(ep, req);
+                else
+                        submit_request(ep, req);
+
+                if (req->last_transaction) {
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
+                        usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
+                }
+                goto restart;
+        }
+        if ((epstatus & epctrl) & USBA_TX_COMPLETE) {
+                usba_ep_writel(ep, CLR_STA, USBA_TX_COMPLETE);
+
+                switch (ep->state) {
+                case DATA_STAGE_IN:
+                        usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY);
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
+                        ep->state = STATUS_STAGE_OUT;
+                        break;
+                case STATUS_STAGE_ADDR:
+                        /* Activate our new address */
+                        usba_writel(udc, CTRL, (usba_readl(udc, CTRL)
+                                                | USBA_FADDR_EN));
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
+                        ep->state = WAIT_FOR_SETUP;
+                        break;
+                case STATUS_STAGE_IN:
+                        if (req) {
+                                list_del_init(&req->queue);
+                                request_complete(ep, req, 0);
+                                submit_next_request(ep);
+                        }
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
+                        ep->state = WAIT_FOR_SETUP;
+                        break;
+                case STATUS_STAGE_TEST:
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
+                        ep->state = WAIT_FOR_SETUP;
+                        if (do_test_mode(udc))
+                                set_protocol_stall(udc, ep);
+                        break;
+                default:
+                        printk(KERN_ERR
+                                "udc: %s: TXCOMP: Invalid endpoint state %d, "
+                                "halting endpoint...\n",
+                                ep->ep.name, ep->state);
+                        set_protocol_stall(udc, ep);
+                        break;
+                }
+
+                goto restart;
+        }
+        if ((epstatus & epctrl) & USBA_RX_BK_RDY) {
+                switch (ep->state) {
+                case STATUS_STAGE_OUT:
+                        usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
+                        usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
+
+                        if (req) {
+                                list_del_init(&req->queue);
+                                request_complete(ep, req, 0);
+                        }
+                        ep->state = WAIT_FOR_SETUP;
+                        break;
+
+                case DATA_STAGE_OUT:
+                        receive_data(ep);
+                        break;
+
+                default:
+                        usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
+                        usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
+                        printk(KERN_ERR
+                                "udc: %s: RXRDY: Invalid endpoint state %d, "
+                                "halting endpoint...\n",
+                                ep->ep.name, ep->state);
+                        set_protocol_stall(udc, ep);
+                        break;
+                }
+
+                goto restart;
+        }
+        if (epstatus & USBA_RX_SETUP) {
+                union {
+                        struct usb_ctrlrequest crq;
+                        unsigned long data[2];
+                } crq;
+                unsigned int pkt_len;
+                int ret;
+
+                if (ep->state != WAIT_FOR_SETUP) {
+                        /*
+                         * Didn't expect a SETUP packet at this
+                         * point. Clean up any pending requests (which
+                         * may be successful).
+                         */
+                        int status = -EPROTO;
+
+                        /*
+                         * RXRDY and TXCOMP are dropped when SETUP
+                         * packets arrive.  Just pretend we received
+                         * the status packet.
+                         */
+                        if (ep->state == STATUS_STAGE_OUT
+                                        || ep->state == STATUS_STAGE_IN) {
+                                usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
+                                status = 0;
+                        }
+
+                        if (req) {
+                                list_del_init(&req->queue);
+                                request_complete(ep, req, status);
+                        }
+                }
+
+                pkt_len = USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA));
+                DBG(DBG_HW, "Packet length: %u\n", pkt_len);
+                if (pkt_len != sizeof(crq)) {
+                        printk(KERN_WARNING "udc: Invalid packet length %u "
+                                "(expected %lu)\n", pkt_len, sizeof(crq));
+                        set_protocol_stall(udc, ep);
+                        return;
+                }
+
+                DBG(DBG_FIFO, "Copying ctrl request from 0x%p:\n", ep->fifo);
+                copy_from_fifo(crq.data, ep->fifo, sizeof(crq));
+
+                /* Free up one bank in the FIFO so that we can
+                 * generate or receive a reply right away. */
+                usba_ep_writel(ep, CLR_STA, USBA_RX_SETUP);
+
+                /* printk(KERN_DEBUG "setup: %d: %02x.%02x\n",
+                        ep->state, crq.crq.bRequestType,
+                        crq.crq.bRequest); */
+
+                if (crq.crq.bRequestType & USB_DIR_IN) {
+                        /*
+                         * The USB 2.0 spec states that "if wLength is
+                         * zero, there is no data transfer phase."
+                         * However, testusb #14 seems to actually
+                         * expect a data phase even if wLength = 0...
+                         */
+                        ep->state = DATA_STAGE_IN;
+                } else {
+                        if (crq.crq.wLength != __constant_cpu_to_le16(0))
+                                ep->state = DATA_STAGE_OUT;
+                        else
+                                ep->state = STATUS_STAGE_IN;
+                }
+
+                ret = -1;
+                if (ep->index == 0)
+                        ret = handle_ep0_setup(udc, ep, &crq.crq);
+                else {
+                        spin_unlock(&udc->lock);
+                        ret = udc->driver->setup(&udc->gadget, &crq.crq);
+                        spin_lock(&udc->lock);
+                }
+
+                DBG(DBG_BUS, "req %02x.%02x, length %d, state %d, ret %d\n",
+                        crq.crq.bRequestType, crq.crq.bRequest,
+                        le16_to_cpu(crq.crq.wLength), ep->state, ret);
+
+                if (ret < 0) {
+                        /* Let the host know that we failed */
+                        set_protocol_stall(udc, ep);
+                }
+        }
+}
+
+static void usba_ep_irq(struct usba_udc *udc, struct usba_ep *ep)
+{
+        struct usba_request *req;
+        u32 epstatus;
+        u32 epctrl;
+
+        epstatus = usba_ep_readl(ep, STA);
+        epctrl = usba_ep_readl(ep, CTL);
+
+        DBG(DBG_INT, "%s: interrupt, status: 0x%08x\n", ep->ep.name, epstatus);
+
+        while ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) {
+                DBG(DBG_BUS, "%s: TX PK ready\n", ep->ep.name);
+
+                if (list_empty(&ep->queue)) {
+                        dev_warn(&udc->pdev->dev, "ep_irq: queue empty\n");
+                        usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
+                        return;
+                }
+
+                req = list_entry(ep->queue.next, struct usba_request, queue);
+
+                if (req->using_dma) {
+                        /* Send a zero-length packet */
+                        usba_ep_writel(ep, SET_STA,
+                                        USBA_TX_PK_RDY);
+                        usba_ep_writel(ep, CTL_DIS,
+                                        USBA_TX_PK_RDY);
+                        list_del_init(&req->queue);
+                        submit_next_request(ep);
+                        request_complete(ep, req, 0);
+                } else {
+                        if (req->submitted)
+                                next_fifo_transaction(ep, req);
+                        else
+                                submit_request(ep, req);
+
+                        if (req->last_transaction) {
+                                list_del_init(&req->queue);
+                                submit_next_request(ep);
+                                request_complete(ep, req, 0);
+                        }
+                }
+
+                epstatus = usba_ep_readl(ep, STA);
+                epctrl = usba_ep_readl(ep, CTL);
+        }
+        if ((epstatus & epctrl) & USBA_RX_BK_RDY) {
+                DBG(DBG_BUS, "%s: RX data ready\n", ep->ep.name);
+                receive_data(ep);
+                usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
+        }
+}
+
+static void usba_dma_irq(struct usba_udc *udc, struct usba_ep *ep)
+{
+        struct usba_request *req;
+        u32 status, control, pending;
+
+        status = usba_dma_readl(ep, STATUS);
+        control = usba_dma_readl(ep, CONTROL);
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+        ep->last_dma_status = status;
+#endif
+        pending = status & control;
+        DBG(DBG_INT | DBG_DMA, "dma irq, s/%#08x, c/%#08x\n", status, control);
+
+        if (status & USBA_DMA_CH_EN) {
+                dev_err(&udc->pdev->dev,
+                        "DMA_CH_EN is set after transfer is finished!\n");
+                dev_err(&udc->pdev->dev,
+                        "status=%#08x, pending=%#08x, control=%#08x\n",
+                        status, pending, control);
+
+                /*
+                 * try to pretend nothing happened. We might have to
+                 * do something here...
+                 */
+        }
+
+        if (list_empty(&ep->queue))
+                /* Might happen if a reset comes along at the right moment */
+                return;
+
+        if (pending & (USBA_DMA_END_TR_ST | USBA_DMA_END_BUF_ST)) {
+                req = list_entry(ep->queue.next, struct usba_request, queue);
+                usba_update_req(ep, req, status);
+
+                list_del_init(&req->queue);
+                submit_next_request(ep);
+                request_complete(ep, req, 0);
+        }
+}
+
+static irqreturn_t usba_udc_irq(int irq, void *devid)
+{
+        struct usba_udc *udc = devid;
+        u32 status;
+        u32 dma_status;
+        u32 ep_status;
+
+        spin_lock(&udc->lock);
+
+        status = usba_readl(udc, INT_STA);
+        DBG(DBG_INT, "irq, status=%#08x\n", status);
+
+        if (status & USBA_DET_SUSPEND) {
+                usba_writel(udc, INT_CLR, USBA_DET_SUSPEND);
+                DBG(DBG_BUS, "Suspend detected\n");
+                if (udc->gadget.speed != USB_SPEED_UNKNOWN
+                                && udc->driver && udc->driver->suspend) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->suspend(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+
+        if (status & USBA_WAKE_UP) {
+                usba_writel(udc, INT_CLR, USBA_WAKE_UP);
+                DBG(DBG_BUS, "Wake Up CPU detected\n");
+        }
+
+        if (status & USBA_END_OF_RESUME) {
+                usba_writel(udc, INT_CLR, USBA_END_OF_RESUME);
+                DBG(DBG_BUS, "Resume detected\n");
+                if (udc->gadget.speed != USB_SPEED_UNKNOWN
+                                && udc->driver && udc->driver->resume) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->resume(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+
+        dma_status = USBA_BFEXT(DMA_INT, status);
+        if (dma_status) {
+                int i;
+
+                for (i = 1; i < USBA_NR_ENDPOINTS; i++)
+                        if (dma_status & (1 << i))
+                                usba_dma_irq(udc, &usba_ep[i]);
+        }
+
+        ep_status = USBA_BFEXT(EPT_INT, status);
+        if (ep_status) {
+                int i;
+
+                for (i = 0; i < USBA_NR_ENDPOINTS; i++)
+                        if (ep_status & (1 << i)) {
+                                if (ep_is_control(&usba_ep[i]))
+                                        usba_control_irq(udc, &usba_ep[i]);
+                                else
+                                        usba_ep_irq(udc, &usba_ep[i]);
+                        }
+        }
+
+        if (status & USBA_END_OF_RESET) {
+                struct usba_ep *ep0;
+
+                usba_writel(udc, INT_CLR, USBA_END_OF_RESET);
+                reset_all_endpoints(udc);
+
+                if (status & USBA_HIGH_SPEED) {
+                        DBG(DBG_BUS, "High-speed bus reset detected\n");
+                        udc->gadget.speed = USB_SPEED_HIGH;
+                } else {
+                        DBG(DBG_BUS, "Full-speed bus reset detected\n");
+                        udc->gadget.speed = USB_SPEED_FULL;
+                }
+
+                ep0 = &usba_ep[0];
+                ep0->desc = &usba_ep0_desc;
+                ep0->state = WAIT_FOR_SETUP;
+                usba_ep_writel(ep0, CFG,
+                                (USBA_BF(EPT_SIZE, EP0_EPT_SIZE)
+                                | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL)
+                                | USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE)));
+                usba_ep_writel(ep0, CTL_ENB,
+                                USBA_EPT_ENABLE | USBA_RX_SETUP);
+                usba_writel(udc, INT_ENB,
+                                (usba_readl(udc, INT_ENB)
+                                | USBA_BF(EPT_INT, 1)
+                                | USBA_DET_SUSPEND
+                                | USBA_END_OF_RESUME));
+
+                if (!(usba_ep_readl(ep0, CFG) & USBA_EPT_MAPPED))
+                        dev_warn(&udc->pdev->dev,
+                                 "WARNING: EP0 configuration is invalid!\n");
+        }
+
+        spin_unlock(&udc->lock);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t usba_vbus_irq(int irq, void *devid)
+{
+        struct usba_udc *udc = devid;
+        int vbus;
+
+        /* debounce */
+        udelay(10);
+
+        spin_lock(&udc->lock);
+
+        /* May happen if Vbus pin toggles during probe() */
+        if (!udc->driver)
+                goto out;
+
+        vbus = gpio_get_value(udc->vbus_pin);
+        if (vbus != udc->vbus_prev) {
+                if (vbus) {
+                        usba_writel(udc, CTRL, USBA_EN_USBA);
+                        usba_writel(udc, INT_ENB, USBA_END_OF_RESET);
+                } else {
+                        udc->gadget.speed = USB_SPEED_UNKNOWN;
+                        reset_all_endpoints(udc);
+                        usba_writel(udc, CTRL, 0);
+                        spin_unlock(&udc->lock);
+                        udc->driver->disconnect(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+                udc->vbus_prev = vbus;
+        }
+
+out:
+        spin_unlock(&udc->lock);
+
+        return IRQ_HANDLED;
+}
+
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct usba_udc *udc = &the_udc;
+        unsigned long flags;
+        int ret;
+
+        if (!udc->pdev)
+                return -ENODEV;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (udc->driver) {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                return -EBUSY;
+        }
+
+        udc->devstatus = 1 << USB_DEVICE_SELF_POWERED;
+        udc->driver = driver;
+        udc->gadget.dev.driver = &driver->driver;
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        clk_enable(udc->pclk);
+        clk_enable(udc->hclk);
+
+        ret = driver->bind(&udc->gadget);
+        if (ret) {
+                DBG(DBG_ERR, "Could not bind to driver %s: error %d\n",
+                        driver->driver.name, ret);
+                goto err_driver_bind;
+        }
+
+        DBG(DBG_GADGET, "registered driver `%s'\n", driver->driver.name);
+
+        udc->vbus_prev = 0;
+        if (udc->vbus_pin != -1)
+                enable_irq(gpio_to_irq(udc->vbus_pin));
+
+        /* If Vbus is present, enable the controller and wait for reset */
+        spin_lock_irqsave(&udc->lock, flags);
+        if (vbus_is_present(udc) && udc->vbus_prev == 0) {
+                usba_writel(udc, CTRL, USBA_EN_USBA);
+                usba_writel(udc, INT_ENB, USBA_END_OF_RESET);
+        }
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+
+err_driver_bind:
+        udc->driver = NULL;
+        udc->gadget.dev.driver = NULL;
+        return ret;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct usba_udc *udc = &the_udc;
+        unsigned long flags;
+
+        if (!udc->pdev)
+                return -ENODEV;
+        if (driver != udc->driver)
+                return -EINVAL;
+
+        if (udc->vbus_pin != -1)
+                disable_irq(gpio_to_irq(udc->vbus_pin));
+
+        spin_lock_irqsave(&udc->lock, flags);
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        reset_all_endpoints(udc);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        /* This will also disable the DP pullup */
+        usba_writel(udc, CTRL, 0);
+
+        driver->unbind(&udc->gadget);
+        udc->gadget.dev.driver = NULL;
+        udc->driver = NULL;
+
+        clk_disable(udc->hclk);
+        clk_disable(udc->pclk);
+
+        DBG(DBG_GADGET, "unregistered driver `%s'\n", driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static int __init usba_udc_probe(struct platform_device *pdev)
+{
+        struct usba_platform_data *pdata = pdev->dev.platform_data;
+        struct resource *regs, *fifo;
+        struct clk *pclk, *hclk;
+        struct usba_udc *udc = &the_udc;
+        int irq, ret, i;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, CTRL_IOMEM_ID);
+        fifo = platform_get_resource(pdev, IORESOURCE_MEM, FIFO_IOMEM_ID);
+        if (!regs || !fifo)
+                return -ENXIO;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        pclk = clk_get(&pdev->dev, "pclk");
+        if (IS_ERR(pclk))
+                return PTR_ERR(pclk);
+        hclk = clk_get(&pdev->dev, "hclk");
+        if (IS_ERR(hclk)) {
+                ret = PTR_ERR(hclk);
+                goto err_get_hclk;
+        }
+
+        udc->pdev = pdev;
+        udc->pclk = pclk;
+        udc->hclk = hclk;
+        udc->vbus_pin = -1;
+
+        ret = -ENOMEM;
+        udc->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        if (!udc->regs) {
+                dev_err(&pdev->dev, "Unable to map I/O memory, aborting.\n");
+                goto err_map_regs;
+        }
+        dev_info(&pdev->dev, "MMIO registers at 0x%08lx mapped at %p\n",
+                 (unsigned long)regs->start, udc->regs);
+        udc->fifo = ioremap(fifo->start, fifo->end - fifo->start + 1);
+        if (!udc->fifo) {
+                dev_err(&pdev->dev, "Unable to map FIFO, aborting.\n");
+                goto err_map_fifo;
+        }
+        dev_info(&pdev->dev, "FIFO at 0x%08lx mapped at %p\n",
+                 (unsigned long)fifo->start, udc->fifo);
+
+        device_initialize(&udc->gadget.dev);
+        udc->gadget.dev.parent = &pdev->dev;
+        udc->gadget.dev.dma_mask = pdev->dev.dma_mask;
+
+        platform_set_drvdata(pdev, udc);
+
+        /* Make sure we start from a clean slate */
+        clk_enable(pclk);
+        usba_writel(udc, CTRL, 0);
+        clk_disable(pclk);
+
+        INIT_LIST_HEAD(&usba_ep[0].ep.ep_list);
+        usba_ep[0].ep_regs = udc->regs + USBA_EPT_BASE(0);
+        usba_ep[0].dma_regs = udc->regs + USBA_DMA_BASE(0);
+        usba_ep[0].fifo = udc->fifo + USBA_FIFO_BASE(0);
+        for (i = 1; i < ARRAY_SIZE(usba_ep); i++) {
+                struct usba_ep *ep = &usba_ep[i];
+
+                ep->ep_regs = udc->regs + USBA_EPT_BASE(i);
+                ep->dma_regs = udc->regs + USBA_DMA_BASE(i);
+                ep->fifo = udc->fifo + USBA_FIFO_BASE(i);
+
+                list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
+        }
+
+        ret = request_irq(irq, usba_udc_irq, 0, "atmel_usba_udc", udc);
+        if (ret) {
+                dev_err(&pdev->dev, "Cannot request irq %d (error %d)\n",
+                        irq, ret);
+                goto err_request_irq;
+        }
+        udc->irq = irq;
+
+        ret = device_add(&udc->gadget.dev);
+        if (ret) {
+                dev_dbg(&pdev->dev, "Could not add gadget: %d\n", ret);
+                goto err_device_add;
+        }
+
+        if (pdata && pdata->vbus_pin != GPIO_PIN_NONE) {
+                if (!gpio_request(pdata->vbus_pin, "atmel_usba_udc")) {
+                        udc->vbus_pin = pdata->vbus_pin;
+
+                        ret = request_irq(gpio_to_irq(udc->vbus_pin),
+                                        usba_vbus_irq, 0,
+                                        "atmel_usba_udc", udc);
+                        if (ret) {
+                                gpio_free(udc->vbus_pin);
+                                udc->vbus_pin = -1;
+                                dev_warn(&udc->pdev->dev,
+                                         "failed to request vbus irq; "
+                                         "assuming always on\n");
+                        } else {
+                                disable_irq(gpio_to_irq(udc->vbus_pin));
+                        }
+                }
+        }
+
+        usba_init_debugfs(udc);
+        for (i = 1; i < ARRAY_SIZE(usba_ep); i++)
+                usba_ep_init_debugfs(udc, &usba_ep[i]);
+
+        return 0;
+
+err_device_add:
+        free_irq(irq, udc);
+err_request_irq:
+        iounmap(udc->fifo);
+err_map_fifo:
+        iounmap(udc->regs);
+err_map_regs:
+        clk_put(hclk);
+err_get_hclk:
+        clk_put(pclk);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return ret;
+}
+
+static int __exit usba_udc_remove(struct platform_device *pdev)
+{
+        struct usba_udc *udc;
+        int i;
+
+        udc = platform_get_drvdata(pdev);
+
+        for (i = 1; i < ARRAY_SIZE(usba_ep); i++)
+                usba_ep_cleanup_debugfs(&usba_ep[i]);
+        usba_cleanup_debugfs(udc);
+
+        if (udc->vbus_pin != -1)
+                gpio_free(udc->vbus_pin);
+
+        free_irq(udc->irq, udc);
+        iounmap(udc->fifo);
+        iounmap(udc->regs);
+        clk_put(udc->hclk);
+        clk_put(udc->pclk);
+
+        device_unregister(&udc->gadget.dev);
+
+        return 0;
+}
+
+static struct platform_driver udc_driver = {
+        .remove         = __exit_p(usba_udc_remove),
+        .driver         = {
+                .name           = "atmel_usba_udc",
+        },
+};
+
+static int __init udc_init(void)
+{
+        return platform_driver_probe(&udc_driver, usba_udc_probe);
+}
+module_init(udc_init);
+
+static void __exit udc_exit(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(udc_exit);
+
+MODULE_DESCRIPTION("Atmel USBA UDC driver");
+MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/atmel_usba_udc.h b/drivers/usb/gadget/atmel_usba_udc.h
new file mode 100644
index 0000000000..a68304e31a
--- /dev/null
+++ b/drivers/usb/gadget/atmel_usba_udc.h
@@ -0,0 +1,352 @@
+/*
+ * Driver for the Atmel USBA high speed USB device controller
+ *
+ * Copyright (C) 2005-2007 Atmel Corporation
+ *
+ * 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.
+ */
+#ifndef __LINUX_USB_GADGET_USBA_UDC_H__
+#define __LINUX_USB_GADGET_USBA_UDC_H__
+
+/* USB register offsets */
+#define USBA_CTRL                               0x0000
+#define USBA_FNUM                               0x0004
+#define USBA_INT_ENB                            0x0010
+#define USBA_INT_STA                            0x0014
+#define USBA_INT_CLR                            0x0018
+#define USBA_EPT_RST                            0x001c
+#define USBA_TST                                0x00e0
+
+/* USB endpoint register offsets */
+#define USBA_EPT_CFG                            0x0000
+#define USBA_EPT_CTL_ENB                        0x0004
+#define USBA_EPT_CTL_DIS                        0x0008
+#define USBA_EPT_CTL                            0x000c
+#define USBA_EPT_SET_STA                        0x0014
+#define USBA_EPT_CLR_STA                        0x0018
+#define USBA_EPT_STA                            0x001c
+
+/* USB DMA register offsets */
+#define USBA_DMA_NXT_DSC                        0x0000
+#define USBA_DMA_ADDRESS                        0x0004
+#define USBA_DMA_CONTROL                        0x0008
+#define USBA_DMA_STATUS                         0x000c
+
+/* Bitfields in CTRL */
+#define USBA_DEV_ADDR_OFFSET                    0
+#define USBA_DEV_ADDR_SIZE                      7
+#define USBA_FADDR_EN                           (1 <<  7)
+#define USBA_EN_USBA                            (1 <<  8)
+#define USBA_DETACH                             (1 <<  9)
+#define USBA_REMOTE_WAKE_UP                     (1 << 10)
+
+/* Bitfields in FNUM */
+#define USBA_MICRO_FRAME_NUM_OFFSET             0
+#define USBA_MICRO_FRAME_NUM_SIZE               3
+#define USBA_FRAME_NUMBER_OFFSET                3
+#define USBA_FRAME_NUMBER_SIZE                  11
+#define USBA_FRAME_NUM_ERROR                    (1 << 31)
+
+/* Bitfields in INT_ENB/INT_STA/INT_CLR */
+#define USBA_HIGH_SPEED                         (1 <<  0)
+#define USBA_DET_SUSPEND                        (1 <<  1)
+#define USBA_MICRO_SOF                          (1 <<  2)
+#define USBA_SOF                                (1 <<  3)
+#define USBA_END_OF_RESET                       (1 <<  4)
+#define USBA_WAKE_UP                            (1 <<  5)
+#define USBA_END_OF_RESUME                      (1 <<  6)
+#define USBA_UPSTREAM_RESUME                    (1 <<  7)
+#define USBA_EPT_INT_OFFSET                     8
+#define USBA_EPT_INT_SIZE                       16
+#define USBA_DMA_INT_OFFSET                     24
+#define USBA_DMA_INT_SIZE                       8
+
+/* Bitfields in EPT_RST */
+#define USBA_RST_OFFSET                         0
+#define USBA_RST_SIZE                           16
+
+/* Bitfields in USBA_TST */
+#define USBA_SPEED_CFG_OFFSET                   0
+#define USBA_SPEED_CFG_SIZE                     2
+#define USBA_TST_J_MODE                         (1 <<  2)
+#define USBA_TST_K_MODE                         (1 <<  3)
+#define USBA_TST_PKT_MODE                       (1 <<  4)
+#define USBA_OPMODE2                            (1 <<  5)
+
+/* Bitfields in EPT_CFG */
+#define USBA_EPT_SIZE_OFFSET                    0
+#define USBA_EPT_SIZE_SIZE                      3
+#define USBA_EPT_DIR_IN                         (1 <<  3)
+#define USBA_EPT_TYPE_OFFSET                    4
+#define USBA_EPT_TYPE_SIZE                      2
+#define USBA_BK_NUMBER_OFFSET                   6
+#define USBA_BK_NUMBER_SIZE                     2
+#define USBA_NB_TRANS_OFFSET                    8
+#define USBA_NB_TRANS_SIZE                      2
+#define USBA_EPT_MAPPED                         (1 << 31)
+
+/* Bitfields in EPT_CTL/EPT_CTL_ENB/EPT_CTL_DIS */
+#define USBA_EPT_ENABLE                         (1 <<  0)
+#define USBA_AUTO_VALID                         (1 <<  1)
+#define USBA_INTDIS_DMA                         (1 <<  3)
+#define USBA_NYET_DIS                           (1 <<  4)
+#define USBA_DATAX_RX                           (1 <<  6)
+#define USBA_MDATA_RX                           (1 <<  7)
+/* Bits 8-15 and 31 enable interrupts for respective bits in EPT_STA */
+#define USBA_BUSY_BANK_IE                       (1 << 18)
+
+/* Bitfields in EPT_SET_STA/EPT_CLR_STA/EPT_STA */
+#define USBA_FORCE_STALL                        (1 <<  5)
+#define USBA_TOGGLE_CLR                         (1 <<  6)
+#define USBA_TOGGLE_SEQ_OFFSET                  6
+#define USBA_TOGGLE_SEQ_SIZE                    2
+#define USBA_ERR_OVFLW                          (1 <<  8)
+#define USBA_RX_BK_RDY                          (1 <<  9)
+#define USBA_KILL_BANK                          (1 <<  9)
+#define USBA_TX_COMPLETE                        (1 << 10)
+#define USBA_TX_PK_RDY                          (1 << 11)
+#define USBA_ISO_ERR_TRANS                      (1 << 11)
+#define USBA_RX_SETUP                           (1 << 12)
+#define USBA_ISO_ERR_FLOW                       (1 << 12)
+#define USBA_STALL_SENT                         (1 << 13)
+#define USBA_ISO_ERR_CRC                        (1 << 13)
+#define USBA_ISO_ERR_NBTRANS                    (1 << 13)
+#define USBA_NAK_IN                             (1 << 14)
+#define USBA_ISO_ERR_FLUSH                      (1 << 14)
+#define USBA_NAK_OUT                            (1 << 15)
+#define USBA_CURRENT_BANK_OFFSET                16
+#define USBA_CURRENT_BANK_SIZE                  2
+#define USBA_BUSY_BANKS_OFFSET                  18
+#define USBA_BUSY_BANKS_SIZE                    2
+#define USBA_BYTE_COUNT_OFFSET                  20
+#define USBA_BYTE_COUNT_SIZE                    11
+#define USBA_SHORT_PACKET                       (1 << 31)
+
+/* Bitfields in DMA_CONTROL */
+#define USBA_DMA_CH_EN                          (1 <<  0)
+#define USBA_DMA_LINK                           (1 <<  1)
+#define USBA_DMA_END_TR_EN                      (1 <<  2)
+#define USBA_DMA_END_BUF_EN                     (1 <<  3)
+#define USBA_DMA_END_TR_IE                      (1 <<  4)
+#define USBA_DMA_END_BUF_IE                     (1 <<  5)
+#define USBA_DMA_DESC_LOAD_IE                   (1 <<  6)
+#define USBA_DMA_BURST_LOCK                     (1 <<  7)
+#define USBA_DMA_BUF_LEN_OFFSET                 16
+#define USBA_DMA_BUF_LEN_SIZE                   16
+
+/* Bitfields in DMA_STATUS */
+#define USBA_DMA_CH_ACTIVE                      (1 <<  1)
+#define USBA_DMA_END_TR_ST                      (1 <<  4)
+#define USBA_DMA_END_BUF_ST                     (1 <<  5)
+#define USBA_DMA_DESC_LOAD_ST                   (1 <<  6)
+
+/* Constants for SPEED_CFG */
+#define USBA_SPEED_CFG_NORMAL                   0
+#define USBA_SPEED_CFG_FORCE_HIGH               2
+#define USBA_SPEED_CFG_FORCE_FULL               3
+
+/* Constants for EPT_SIZE */
+#define USBA_EPT_SIZE_8                         0
+#define USBA_EPT_SIZE_16                        1
+#define USBA_EPT_SIZE_32                        2
+#define USBA_EPT_SIZE_64                        3
+#define USBA_EPT_SIZE_128                       4
+#define USBA_EPT_SIZE_256                       5
+#define USBA_EPT_SIZE_512                       6
+#define USBA_EPT_SIZE_1024                      7
+
+/* Constants for EPT_TYPE */
+#define USBA_EPT_TYPE_CONTROL                   0
+#define USBA_EPT_TYPE_ISO                       1
+#define USBA_EPT_TYPE_BULK                      2
+#define USBA_EPT_TYPE_INT                       3
+
+/* Constants for BK_NUMBER */
+#define USBA_BK_NUMBER_ZERO                     0
+#define USBA_BK_NUMBER_ONE                      1
+#define USBA_BK_NUMBER_DOUBLE                   2
+#define USBA_BK_NUMBER_TRIPLE                   3
+
+/* Bit manipulation macros */
+#define USBA_BF(name, value)                                    \
+        (((value) & ((1 << USBA_##name##_SIZE) - 1))            \
+         << USBA_##name##_OFFSET)
+#define USBA_BFEXT(name, value)                                 \
+        (((value) >> USBA_##name##_OFFSET)                      \
+         & ((1 << USBA_##name##_SIZE) - 1))
+#define USBA_BFINS(name, value, old)                            \
+        (((old) & ~(((1 << USBA_##name##_SIZE) - 1)             \
+                    << USBA_##name##_OFFSET))                   \
+         | USBA_BF(name, value))
+
+/* Register access macros */
+#define usba_readl(udc, reg)                                    \
+        __raw_readl((udc)->regs + USBA_##reg)
+#define usba_writel(udc, reg, value)                            \
+        __raw_writel((value), (udc)->regs + USBA_##reg)
+#define usba_ep_readl(ep, reg)                                  \
+        __raw_readl((ep)->ep_regs + USBA_EPT_##reg)
+#define usba_ep_writel(ep, reg, value)                          \
+        __raw_writel((value), (ep)->ep_regs + USBA_EPT_##reg)
+#define usba_dma_readl(ep, reg)                                 \
+        __raw_readl((ep)->dma_regs + USBA_DMA_##reg)
+#define usba_dma_writel(ep, reg, value)                         \
+        __raw_writel((value), (ep)->dma_regs + USBA_DMA_##reg)
+
+/* Calculate base address for a given endpoint or DMA controller */
+#define USBA_EPT_BASE(x)        (0x100 + (x) * 0x20)
+#define USBA_DMA_BASE(x)        (0x300 + (x) * 0x10)
+#define USBA_FIFO_BASE(x)       ((x) << 16)
+
+/* Synth parameters */
+#define USBA_NR_ENDPOINTS       7
+
+#define EP0_FIFO_SIZE           64
+#define EP0_EPT_SIZE            USBA_EPT_SIZE_64
+#define EP0_NR_BANKS            1
+
+/*
+ * REVISIT: Try to eliminate this value. Can we rely on req->mapped to
+ * provide this information?
+ */
+#define DMA_ADDR_INVALID (~(dma_addr_t)0)
+
+#define FIFO_IOMEM_ID   0
+#define CTRL_IOMEM_ID   1
+
+#ifdef DEBUG
+#define DBG_ERR         0x0001  /* report all error returns */
+#define DBG_HW          0x0002  /* debug hardware initialization */
+#define DBG_GADGET      0x0004  /* calls to/from gadget driver */
+#define DBG_INT         0x0008  /* interrupts */
+#define DBG_BUS         0x0010  /* report changes in bus state */
+#define DBG_QUEUE       0x0020  /* debug request queue processing */
+#define DBG_FIFO        0x0040  /* debug FIFO contents */
+#define DBG_DMA         0x0080  /* debug DMA handling */
+#define DBG_REQ         0x0100  /* print out queued request length */
+#define DBG_ALL         0xffff
+#define DBG_NONE        0x0000
+
+#define DEBUG_LEVEL     (DBG_ERR)
+#define DBG(level, fmt, ...)                                    \
+        do {                                                    \
+                if ((level) & DEBUG_LEVEL)                      \
+                        printk(KERN_DEBUG "udc: " fmt, ## __VA_ARGS__); \
+        } while (0)
+#else
+#define DBG(level, fmt...)
+#endif
+
+enum usba_ctrl_state {
+        WAIT_FOR_SETUP,
+        DATA_STAGE_IN,
+        DATA_STAGE_OUT,
+        STATUS_STAGE_IN,
+        STATUS_STAGE_OUT,
+        STATUS_STAGE_ADDR,
+        STATUS_STAGE_TEST,
+};
+/*
+  EP_STATE_IDLE,
+  EP_STATE_SETUP,
+  EP_STATE_IN_DATA,
+  EP_STATE_OUT_DATA,
+  EP_STATE_SET_ADDR_STATUS,
+  EP_STATE_RX_STATUS,
+  EP_STATE_TX_STATUS,
+  EP_STATE_HALT,
+*/
+
+struct usba_dma_desc {
+        dma_addr_t next;
+        dma_addr_t addr;
+        u32 ctrl;
+};
+
+struct usba_ep {
+        int                                     state;
+        void __iomem                            *ep_regs;
+        void __iomem                            *dma_regs;
+        void __iomem                            *fifo;
+        struct usb_ep                           ep;
+        struct usba_udc                         *udc;
+
+        struct list_head                        queue;
+        const struct usb_endpoint_descriptor    *desc;
+
+        u16                                     fifo_size;
+        u8                                      nr_banks;
+        u8                                      index;
+        unsigned int                            can_dma:1;
+        unsigned int                            can_isoc:1;
+        unsigned int                            is_isoc:1;
+        unsigned int                            is_in:1;
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+        u32                                     last_dma_status;
+        struct dentry                           *debugfs_dir;
+        struct dentry                           *debugfs_queue;
+        struct dentry                           *debugfs_dma_status;
+        struct dentry                           *debugfs_state;
+#endif
+};
+
+struct usba_request {
+        struct usb_request                      req;
+        struct list_head                        queue;
+
+        u32                                     ctrl;
+
+        unsigned int                            submitted:1;
+        unsigned int                            last_transaction:1;
+        unsigned int                            using_dma:1;
+        unsigned int                            mapped:1;
+};
+
+struct usba_udc {
+        /* Protect hw registers from concurrent modifications */
+        spinlock_t lock;
+
+        void __iomem *regs;
+        void __iomem *fifo;
+
+        struct usb_gadget gadget;
+        struct usb_gadget_driver *driver;
+        struct platform_device *pdev;
+        int irq;
+        int vbus_pin;
+        struct clk *pclk;
+        struct clk *hclk;
+
+        u16 devstatus;
+
+        u16 test_mode;
+        int vbus_prev;
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+        struct dentry *debugfs_root;
+        struct dentry *debugfs_regs;
+#endif
+};
+
+static inline struct usba_ep *to_usba_ep(struct usb_ep *ep)
+{
+        return container_of(ep, struct usba_ep, ep);
+}
+
+static inline struct usba_request *to_usba_req(struct usb_request *req)
+{
+        return container_of(req, struct usba_request, req);
+}
+
+static inline struct usba_udc *to_usba_udc(struct usb_gadget *gadget)
+{
+        return container_of(gadget, struct usba_udc, gadget);
+}
+
+#define ep_is_control(ep)       ((ep)->index == 0)
+#define ep_is_idle(ep)          ((ep)->state == EP_STATE_IDLE)
+
+#endif /* __LINUX_USB_GADGET_USBA_UDC_H */
diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
index c6760aee1e..a4e54b2743 100644
--- a/drivers/usb/gadget/config.c
+++ b/drivers/usb/gadget/config.c
@@ -25,7 +25,7 @@
 #include <linux/device.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 
 /**
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index d008d1360a..9db2482bdf 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -46,7 +46,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/usb.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -962,13 +962,13 @@ static struct platform_driver dummy_udc_driver = {
 
 static int dummy_urb_enqueue (
         struct usb_hcd                  *hcd,
-        struct usb_host_endpoint        *ep,
         struct urb                      *urb,
         gfp_t                           mem_flags
 ) {
         struct dummy    *dum;
         struct urbp     *urbp;
         unsigned long   flags;
+        int             rc;
 
         if (!urb->transfer_buffer && urb->transfer_buffer_length)
                 return -EINVAL;
@@ -980,6 +980,11 @@ static int dummy_urb_enqueue (
 
         dum = hcd_to_dummy (hcd);
         spin_lock_irqsave (&dum->lock, flags);
+        rc = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (rc) {
+                kfree(urbp);
+                goto done;
+        }
 
         if (!dum->udev) {
                 dum->udev = urb->dev;
@@ -996,36 +1001,35 @@ static int dummy_urb_enqueue (
         if (!timer_pending (&dum->timer))
                 mod_timer (&dum->timer, jiffies + 1);
 
-        spin_unlock_irqrestore (&dum->lock, flags);
-        return 0;
+ done:
+        spin_unlock_irqrestore(&dum->lock, flags);
+        return rc;
 }
 
-static int dummy_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
+static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct dummy    *dum;
         unsigned long   flags;
+        int             rc;
 
         /* giveback happens automatically in timer callback,
          * so make sure the callback happens */
         dum = hcd_to_dummy (hcd);
         spin_lock_irqsave (&dum->lock, flags);
-        if (dum->rh_state != DUMMY_RH_RUNNING && !list_empty(&dum->urbp_list))
+
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (!rc && dum->rh_state != DUMMY_RH_RUNNING &&
+                        !list_empty(&dum->urbp_list))
                 mod_timer (&dum->timer, jiffies);
-        spin_unlock_irqrestore (&dum->lock, flags);
-        return 0;
-}
 
-static void maybe_set_status (struct urb *urb, int status)
-{
-        spin_lock (&urb->lock);
-        if (urb->status == -EINPROGRESS)
-                urb->status = status;
-        spin_unlock (&urb->lock);
+        spin_unlock_irqrestore (&dum->lock, flags);
+        return rc;
 }
 
 /* transfer up to a frame's worth; caller must own lock */
 static int
-transfer (struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit)
+transfer(struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit,
+                int *status)
 {
         struct dummy_request    *req;
 
@@ -1088,24 +1092,20 @@ top:
                  *
                  * partially filling a buffer optionally blocks queue advances
                  * (so completion handlers can clean up the queue) but we don't
-                 * need to emulate such data-in-flight.  so we only show part
-                 * of the URB_SHORT_NOT_OK effect: completion status.
+                 * need to emulate such data-in-flight.
                  */
                 if (is_short) {
                         if (host_len == dev_len) {
                                 req->req.status = 0;
-                                maybe_set_status (urb, 0);
+                                *status = 0;
                         } else if (to_host) {
                                 req->req.status = 0;
                                 if (dev_len > host_len)
-                                        maybe_set_status (urb, -EOVERFLOW);
+                                        *status = -EOVERFLOW;
                                 else
-                                        maybe_set_status (urb,
-                                                (urb->transfer_flags
-                                                        & URB_SHORT_NOT_OK)
-                                                ? -EREMOTEIO : 0);
+                                        *status = 0;
                         } else if (!to_host) {
-                                maybe_set_status (urb, 0);
+                                *status = 0;
                                 if (host_len > dev_len)
                                         req->req.status = -EOVERFLOW;
                                 else
@@ -1119,9 +1119,8 @@ top:
                                 req->req.status = 0;
                         if (urb->transfer_buffer_length == urb->actual_length
                                         && !(urb->transfer_flags
-                                                & URB_ZERO_PACKET)) {
-                                maybe_set_status (urb, 0);
-                        }
+                                                & URB_ZERO_PACKET))
+                                *status = 0;
                 }
 
                 /* device side completion --> continuable */
@@ -1137,7 +1136,7 @@ top:
                 }
 
                 /* host side completion --> terminate */
-                if (urb->status != -EINPROGRESS)
+                if (*status != -EINPROGRESS)
                         break;
 
                 /* rescan to continue with any other queued i/o */
@@ -1248,12 +1247,12 @@ restart:
                 u8                      address;
                 struct dummy_ep         *ep = NULL;
                 int                     type;
+                int                     status = -EINPROGRESS;
 
                 urb = urbp->urb;
-                if (urb->status != -EINPROGRESS) {
-                        /* likely it was just unlinked */
+                if (urb->unlinked)
                         goto return_urb;
-                } else if (dum->rh_state != DUMMY_RH_RUNNING)
+                else if (dum->rh_state != DUMMY_RH_RUNNING)
                         continue;
                 type = usb_pipetype (urb->pipe);
 
@@ -1274,7 +1273,7 @@ restart:
                         dev_dbg (dummy_dev(dum),
                                 "no ep configured for urb %p\n",
                                 urb);
-                        maybe_set_status (urb, -EPROTO);
+                        status = -EPROTO;
                         goto return_urb;
                 }
 
@@ -1289,7 +1288,7 @@ restart:
                         /* NOTE: must not be iso! */
                         dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n",
                                         ep->ep.name, urb);
-                        maybe_set_status (urb, -EPIPE);
+                        status = -EPIPE;
                         goto return_urb;
                 }
                 /* FIXME make sure both ends agree on maxpacket */
@@ -1307,7 +1306,7 @@ restart:
                         w_value = le16_to_cpu(setup.wValue);
                         if (le16_to_cpu(setup.wLength) !=
                                         urb->transfer_buffer_length) {
-                                maybe_set_status (urb, -EOVERFLOW);
+                                status = -EOVERFLOW;
                                 goto return_urb;
                         }
 
@@ -1337,7 +1336,7 @@ restart:
                                 if (setup.bRequestType != Dev_Request)
                                         break;
                                 dum->address = w_value;
-                                maybe_set_status (urb, 0);
+                                status = 0;
                                 dev_dbg (udc_dev(dum), "set_address = %d\n",
                                                 w_value);
                                 value = 0;
@@ -1364,7 +1363,7 @@ restart:
                                         if (value == 0) {
                                                 dum->devstatus |=
                                                         (1 << w_value);
-                                                maybe_set_status (urb, 0);
+                                                status = 0;
                                         }
 
                                 } else if (setup.bRequestType == Ep_Request) {
@@ -1376,7 +1375,7 @@ restart:
                                         }
                                         ep2->halted = 1;
                                         value = 0;
-                                        maybe_set_status (urb, 0);
+                                        status = 0;
                                 }
                                 break;
                         case USB_REQ_CLEAR_FEATURE:
@@ -1386,7 +1385,7 @@ restart:
                                                 dum->devstatus &= ~(1 <<
                                                         USB_DEVICE_REMOTE_WAKEUP);
                                                 value = 0;
-                                                maybe_set_status (urb, 0);
+                                                status = 0;
                                                 break;
                                         default:
                                                 value = -EOPNOTSUPP;
@@ -1401,7 +1400,7 @@ restart:
                                         }
                                         ep2->halted = 0;
                                         value = 0;
-                                        maybe_set_status (urb, 0);
+                                        status = 0;
                                 }
                                 break;
                         case USB_REQ_GET_STATUS:
@@ -1438,7 +1437,7 @@ restart:
                                         urb->actual_length = min (2,
                                                 urb->transfer_buffer_length);
                                         value = 0;
-                                        maybe_set_status (urb, 0);
+                                        status = 0;
                                 }
                                 break;
                         }
@@ -1465,7 +1464,7 @@ restart:
                                         dev_dbg (udc_dev(dum),
                                                 "setup --> %d\n",
                                                 value);
-                                maybe_set_status (urb, -EPIPE);
+                                status = -EPIPE;
                                 urb->actual_length = 0;
                         }
 
@@ -1482,7 +1481,7 @@ restart:
                          * report random errors, to debug drivers.
                          */
                         limit = max (limit, periodic_bytes (dum, ep));
-                        maybe_set_status (urb, -ENOSYS);
+                        status = -ENOSYS;
                         break;
 
                 case PIPE_INTERRUPT:
@@ -1496,23 +1495,23 @@ restart:
                 default:
                 treat_control_like_bulk:
                         ep->last_io = jiffies;
-                        total = transfer (dum, urb, ep, limit);
+                        total = transfer(dum, urb, ep, limit, &status);
                         break;
                 }
 
                 /* incomplete transfer? */
-                if (urb->status == -EINPROGRESS)
+                if (status == -EINPROGRESS)
                         continue;
 
 return_urb:
-                urb->hcpriv = NULL;
                 list_del (&urbp->urbp_list);
                 kfree (urbp);
                 if (ep)
                         ep->already_seen = ep->setup_stage = 0;
 
+                usb_hcd_unlink_urb_from_ep(dummy_to_hcd(dum), urb);
                 spin_unlock (&dum->lock);
-                usb_hcd_giveback_urb (dummy_to_hcd(dum), urb);
+                usb_hcd_giveback_urb(dummy_to_hcd(dum), urb, status);
                 spin_lock (&dum->lock);
 
                 goto restart;
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 3aa46cfa66..f9d07108bc 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -28,7 +28,7 @@
 #include <linux/string.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index f70055473a..9e732bff9d 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -19,40 +19,18 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+/* #define VERBOSE_DEBUG */
 
-// #define DEBUG 1
-// #define VERBOSE
-
-#include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
-#include <linux/moduleparam.h>
 #include <linux/ctype.h>
-
-#include <asm/byteorder.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-#include <asm/uaccess.h>
-#include <asm/unaligned.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/cdc.h>
-#include <linux/usb_gadget.h>
-
-#include <linux/random.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/ethtool.h>
+#include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
@@ -356,15 +334,15 @@ module_param (qmult, uint, S_IRUGO|S_IWUSR);
 #define qlen(gadget) \
         (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
 
-/* also defer IRQs on highspeed TX */
-#define TX_DELAY        qmult
-
 static inline int BITRATE(struct usb_gadget *g)
 {
         return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;
 }
 
 #else   /* full speed (low speed doesn't do bulk) */
+
+#define qmult           1
+
 #define DEVSPEED        USB_SPEED_FULL
 
 #define qlen(gadget) DEFAULT_QLEN
@@ -390,7 +368,7 @@ static inline int BITRATE(struct usb_gadget *g)
         do { } while (0)
 #endif /* DEBUG */
 
-#ifdef VERBOSE
+#ifdef VERBOSE_DEBUG
 #define VDEBUG  DEBUG
 #else
 #define VDEBUG(dev,fmt,args...) \
@@ -830,8 +808,6 @@ static const struct usb_descriptor_header *fs_rndis_function [] = {
 };
 #endif
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-
 /*
  * usb 2.0 devices need to expose both high speed and full speed
  * descriptors, unless they only run at full speed.
@@ -934,18 +910,15 @@ static const struct usb_descriptor_header *hs_rndis_function [] = {
 
 
 /* maxpacket and other transfer characteristics vary by speed. */
-#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
-
-#else
-
-/* if there's no high speed support, maxpacket doesn't change. */
-#define ep_desc(g,hs,fs) (((void)(g)), (fs))
-
-static inline void __init hs_subset_descriptors(void)
+static inline struct usb_endpoint_descriptor *
+ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+                struct usb_endpoint_descriptor *fs)
 {
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
 }
 
-#endif  /* !CONFIG_USB_GADGET_DUALSPEED */
 
 /*-------------------------------------------------------------------------*/
 
@@ -989,22 +962,19 @@ static struct usb_gadget_strings	stringtab = {
  * complications: class descriptors, and an altsetting.
  */
 static int
-config_buf (enum usb_device_speed speed,
-        u8 *buf, u8 type,
-        unsigned index, int is_otg)
+config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
 {
         int                                     len;
         const struct usb_config_descriptor      *config;
         const struct usb_descriptor_header      **function;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        int                             hs = (speed == USB_SPEED_HIGH);
+        int                                     hs = 0;
 
-        if (type == USB_DT_OTHER_SPEED_CONFIG)
-                hs = !hs;
+        if (gadget_is_dualspeed(g)) {
+                hs = (g->speed == USB_SPEED_HIGH);
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        hs = !hs;
+        }
 #define which_fn(t)     (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
-#else
-#define which_fn(t)     (fs_ ## t ## _function)
-#endif
 
         if (index >= device_desc.bNumConfigurations)
                 return -EINVAL;
@@ -1217,7 +1187,7 @@ eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags)
                 if (number)
                         eth_reset_config (dev);
                 usb_gadget_vbus_draw(dev->gadget,
-                                dev->gadget->is_otg ? 8 : 100);
+                                gadget_is_otg(dev->gadget) ? 8 : 100);
         } else {
                 char *speed;
                 unsigned power;
@@ -1399,24 +1369,22 @@ eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         value = min (wLength, (u16) sizeof device_desc);
                         memcpy (req->buf, &device_desc, value);
                         break;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
                 case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         value = min (wLength, (u16) sizeof dev_qualifier);
                         memcpy (req->buf, &dev_qualifier, value);
                         break;
 
                 case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         // FALLTHROUGH
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
                 case USB_DT_CONFIG:
-                        value = config_buf (gadget->speed, req->buf,
+                        value = config_buf(gadget, req->buf,
                                         wValue >> 8,
                                         wValue & 0xff,
-                                        gadget->is_otg);
+                                        gadget_is_otg(gadget));
                         if (value >= 0)
                                 value = min (wLength, (u16) value);
                         break;
@@ -1585,12 +1553,12 @@ done_set_intf:
                                 && rndis_control_intf.bInterfaceNumber
                                         == wIndex) {
                         u8 *buf;
+                        u32 n;
 
                         /* return the result */
-                        buf = rndis_get_next_response (dev->rndis_config,
-                                                       &value);
+                        buf = rndis_get_next_response(dev->rndis_config, &n);
                         if (buf) {
-                                memcpy (req->buf, buf, value);
+                                memcpy(req->buf, buf, n);
                                 req->complete = rndis_response_complete;
                                 rndis_free_response(dev->rndis_config, buf);
                         }
@@ -1989,8 +1957,20 @@ static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
         }
 
         spin_lock_irqsave(&dev->req_lock, flags);
+        /*
+         * this freelist can be empty if an interrupt triggered disconnect()
+         * and reconfigured the gadget (shutting down this queue) after the
+         * network stack decided to xmit but before we got the spinlock.
+         */
+        if (list_empty(&dev->tx_reqs)) {
+                spin_unlock_irqrestore(&dev->req_lock, flags);
+                return 1;
+        }
+
         req = container_of (dev->tx_reqs.next, struct usb_request, list);
         list_del (&req->list);
+
+        /* temporarily stop TX queue when the freelist empties */
         if (list_empty (&dev->tx_reqs))
                 netif_stop_queue (net);
         spin_unlock_irqrestore(&dev->req_lock, flags);
@@ -2026,12 +2006,11 @@ static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
 
         req->length = length;
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
         /* throttle highspeed IRQ rate back slightly */
-        req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
-                ? ((atomic_read (&dev->tx_qlen) % TX_DELAY) != 0)
-                : 0;
-#endif
+        if (gadget_is_dualspeed(dev->gadget))
+                req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
+                        ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
+                        : 0;
 
         retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
         switch (retval) {
@@ -2188,8 +2167,7 @@ static int eth_stop (struct net_device *net)
         }
 
         if (rndis_active(dev)) {
-                rndis_set_param_medium (dev->rndis_config,
-                                        NDIS_MEDIUM_802_3, 0);
+                rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);
                 (void) rndis_signal_disconnect (dev->rndis_config);
         }
 
@@ -2443,26 +2421,28 @@ autoconf_fail:
         if (rndis)
                 device_desc.bNumConfigurations = 2;
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-        if (rndis)
-                dev_qualifier.bNumConfigurations = 2;
-        else if (!cdc)
-                dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
+        if (gadget_is_dualspeed(gadget)) {
+                if (rndis)
+                        dev_qualifier.bNumConfigurations = 2;
+                else if (!cdc)
+                        dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
 
-        /* assumes ep0 uses the same value for both speeds ... */
-        dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
+                /* assumes ep0 uses the same value for both speeds ... */
+                dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
 
-        /* and that all endpoints are dual-speed */
-        hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
-        hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
+                /* and that all endpoints are dual-speed */
+                hs_source_desc.bEndpointAddress =
+                                fs_source_desc.bEndpointAddress;
+                hs_sink_desc.bEndpointAddress =
+                                fs_sink_desc.bEndpointAddress;
 #if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-        if (status_ep)
-                hs_status_desc.bEndpointAddress =
-                                fs_status_desc.bEndpointAddress;
+                if (status_ep)
+                        hs_status_desc.bEndpointAddress =
+                                        fs_status_desc.bEndpointAddress;
 #endif
-#endif  /* DUALSPEED */
+        }
 
-        if (gadget->is_otg) {
+        if (gadget_is_otg(gadget)) {
                 otg_descriptor.bmAttributes |= USB_OTG_HNP,
                 eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
                 eth_config.bMaxPower = 4;
@@ -2598,12 +2578,11 @@ fail0:
                 if (rndis_set_param_dev (dev->rndis_config, dev->net,
                                          &dev->stats, &dev->cdc_filter))
                         goto fail0;
-                if (rndis_set_param_vendor (dev->rndis_config, vendorID,
-                                            manufacturer))
+                if (rndis_set_param_vendor(dev->rndis_config, vendorID,
+                                        manufacturer))
                         goto fail0;
-                if (rndis_set_param_medium (dev->rndis_config,
-                                            NDIS_MEDIUM_802_3,
-                                            0))
+                if (rndis_set_param_medium(dev->rndis_config,
+                                        NDIS_MEDIUM_802_3, 0))
                         goto fail0;
                 INFO (dev, "RNDIS ready\n");
         }
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 965ad7bec7..73726c570a 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -1,7 +1,7 @@
 /*
  * file_storage.c -- File-backed USB Storage Gadget, for USB development
  *
- * Copyright (C) 2003-2005 Alan Stern
+ * Copyright (C) 2003-2007 Alan Stern
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -217,17 +217,11 @@
  */
 
 
-#undef DEBUG
-#undef VERBOSE
-#undef DUMP_MSGS
-
+/* #define VERBOSE_DEBUG */
+/* #define DUMP_MSGS */
 
-#include <asm/system.h>
-#include <asm/uaccess.h>
 
-#include <linux/bitops.h>
 #include <linux/blkdev.h>
-#include <linux/compiler.h>
 #include <linux/completion.h>
 #include <linux/dcache.h>
 #include <linux/delay.h>
@@ -235,18 +229,10 @@
 #include <linux/fcntl.h>
 #include <linux/file.h>
 #include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
 #include <linux/kref.h>
 #include <linux/kthread.h>
 #include <linux/limits.h>
-#include <linux/list.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/pagemap.h>
 #include <linux/rwsem.h>
-#include <linux/sched.h>
-#include <linux/signal.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
@@ -254,7 +240,7 @@
 #include <linux/utsname.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
@@ -263,7 +249,7 @@
 
 #define DRIVER_DESC             "File-backed Storage Gadget"
 #define DRIVER_NAME             "g_file_storage"
-#define DRIVER_VERSION          "28 November 2005"
+#define DRIVER_VERSION          "7 August 2007"
 
 static const char longname[] = DRIVER_DESC;
 static const char shortname[] = DRIVER_NAME;
@@ -289,57 +275,48 @@ MODULE_LICENSE("Dual BSD/GPL");
 
 /*-------------------------------------------------------------------------*/
 
-#define xprintk(f,level,fmt,args...) \
-        dev_printk(level , &(f)->gadget->dev , fmt , ## args)
-#define yprintk(l,level,fmt,args...) \
-        dev_printk(level , &(l)->dev , fmt , ## args)
-
 #ifdef DEBUG
-#define DBG(fsg,fmt,args...) \
-        xprintk(fsg , KERN_DEBUG , fmt , ## args)
 #define LDBG(lun,fmt,args...) \
-        yprintk(lun , KERN_DEBUG , fmt , ## args)
+        dev_dbg(&(lun)->dev , fmt , ## args)
 #define MDBG(fmt,args...) \
         printk(KERN_DEBUG DRIVER_NAME ": " fmt , ## args)
 #else
-#define DBG(fsg,fmt,args...) \
-        do { } while (0)
 #define LDBG(lun,fmt,args...) \
         do { } while (0)
 #define MDBG(fmt,args...) \
         do { } while (0)
-#undef VERBOSE
+#undef VERBOSE_DEBUG
 #undef DUMP_MSGS
 #endif /* DEBUG */
 
-#ifdef VERBOSE
-#define VDBG    DBG
+#ifdef VERBOSE_DEBUG
 #define VLDBG   LDBG
 #else
-#define VDBG(fsg,fmt,args...) \
-        do { } while (0)
 #define VLDBG(lun,fmt,args...) \
         do { } while (0)
-#endif /* VERBOSE */
+#endif /* VERBOSE_DEBUG */
 
-#define ERROR(fsg,fmt,args...) \
-        xprintk(fsg , KERN_ERR , fmt , ## args)
 #define LERROR(lun,fmt,args...) \
-        yprintk(lun , KERN_ERR , fmt , ## args)
-
-#define WARN(fsg,fmt,args...) \
-        xprintk(fsg , KERN_WARNING , fmt , ## args)
+        dev_err(&(lun)->dev , fmt , ## args)
 #define LWARN(lun,fmt,args...) \
-        yprintk(lun , KERN_WARNING , fmt , ## args)
-
-#define INFO(fsg,fmt,args...) \
-        xprintk(fsg , KERN_INFO , fmt , ## args)
+        dev_warn(&(lun)->dev , fmt , ## args)
 #define LINFO(lun,fmt,args...) \
-        yprintk(lun , KERN_INFO , fmt , ## args)
+        dev_info(&(lun)->dev , fmt , ## args)
 
 #define MINFO(fmt,args...) \
         printk(KERN_INFO DRIVER_NAME ": " fmt , ## args)
 
+#define DBG(d, fmt, args...) \
+        dev_dbg(&(d)->gadget->dev , fmt , ## args)
+#define VDBG(d, fmt, args...) \
+        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+#define ERROR(d, fmt, args...) \
+        dev_err(&(d)->gadget->dev , fmt , ## args)
+#define WARN(d, fmt, args...) \
+        dev_warn(&(d)->gadget->dev , fmt , ## args)
+#define INFO(d, fmt, args...) \
+        dev_info(&(d)->gadget->dev , fmt , ## args)
+
 
 /*-------------------------------------------------------------------------*/
 
@@ -350,8 +327,8 @@ MODULE_LICENSE("Dual BSD/GPL");
 static struct {
         char            *file[MAX_LUNS];
         int             ro[MAX_LUNS];
-        int             num_filenames;
-        int             num_ros;
+        unsigned int    num_filenames;
+        unsigned int    num_ros;
         unsigned int    nluns;
 
         int             removable;
@@ -578,7 +555,7 @@ struct lun {
 
 #define backing_file_is_open(curlun)    ((curlun)->filp != NULL)
 
-static inline struct lun *dev_to_lun(struct device *dev)
+static struct lun *dev_to_lun(struct device *dev)
 {
         return container_of(dev, struct lun, dev);
 }
@@ -711,13 +688,13 @@ struct fsg_dev {
 
 typedef void (*fsg_routine_t)(struct fsg_dev *);
 
-static int inline exception_in_progress(struct fsg_dev *fsg)
+static int exception_in_progress(struct fsg_dev *fsg)
 {
         return (fsg->state > FSG_STATE_IDLE);
 }
 
 /* Make bulk-out requests be divisible by the maxpacket size */
-static void inline set_bulk_out_req_length(struct fsg_dev *fsg,
+static void set_bulk_out_req_length(struct fsg_dev *fsg,
                 struct fsg_buffhd *bh, unsigned int length)
 {
         unsigned int    rem;
@@ -743,50 +720,36 @@ static void	close_all_backing_files(struct fsg_dev *fsg);
 static void dump_msg(struct fsg_dev *fsg, const char *label,
                 const u8 *buf, unsigned int length)
 {
-        unsigned int    start, num, i;
-        char            line[52], *p;
-
-        if (length >= 512)
-                return;
-        DBG(fsg, "%s, length %u:\n", label, length);
-
-        start = 0;
-        while (length > 0) {
-                num = min(length, 16u);
-                p = line;
-                for (i = 0; i < num; ++i) {
-                        if (i == 8)
-                                *p++ = ' ';
-                        sprintf(p, " %02x", buf[i]);
-                        p += 3;
-                }
-                *p = 0;
-                printk(KERN_DEBUG "%6x: %s\n", start, line);
-                buf += num;
-                start += num;
-                length -= num;
+        if (length < 512) {
+                DBG(fsg, "%s, length %u:\n", label, length);
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
+                                16, 1, buf, length, 0);
         }
 }
 
-static void inline dump_cdb(struct fsg_dev *fsg)
+static void dump_cdb(struct fsg_dev *fsg)
 {}
 
 #else
 
-static void inline dump_msg(struct fsg_dev *fsg, const char *label,
+static void dump_msg(struct fsg_dev *fsg, const char *label,
                 const u8 *buf, unsigned int length)
 {}
 
-static void inline dump_cdb(struct fsg_dev *fsg)
-{
-        int     i;
-        char    cmdbuf[3*MAX_COMMAND_SIZE + 1];
+#ifdef VERBOSE_DEBUG
 
-        for (i = 0; i < fsg->cmnd_size; ++i)
-                sprintf(cmdbuf + i*3, " %02x", fsg->cmnd[i]);
-        VDBG(fsg, "SCSI CDB: %s\n", cmdbuf);
+static void dump_cdb(struct fsg_dev *fsg)
+{
+        print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,
+                        16, 1, fsg->cmnd, fsg->cmnd_size, 0);
 }
 
+#else
+
+static void dump_cdb(struct fsg_dev *fsg)
+{}
+
+#endif /* VERBOSE_DEBUG */
 #endif /* DUMP_MSGS */
 
 
@@ -809,24 +772,24 @@ static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
 
 /* Routines for unaligned data access */
 
-static u16 inline get_be16(u8 *buf)
+static u16 get_be16(u8 *buf)
 {
         return ((u16) buf[0] << 8) | ((u16) buf[1]);
 }
 
-static u32 inline get_be32(u8 *buf)
+static u32 get_be32(u8 *buf)
 {
         return ((u32) buf[0] << 24) | ((u32) buf[1] << 16) |
                         ((u32) buf[2] << 8) | ((u32) buf[3]);
 }
 
-static void inline put_be16(u8 *buf, u16 val)
+static void put_be16(u8 *buf, u16 val)
 {
         buf[0] = val >> 8;
         buf[1] = val;
 }
 
-static void inline put_be32(u8 *buf, u32 val)
+static void put_be32(u8 *buf, u32 val)
 {
         buf[0] = val >> 24;
         buf[1] = val >> 16;
@@ -950,8 +913,6 @@ static const struct usb_descriptor_header *fs_function[] = {
 #define FS_FUNCTION_PRE_EP_ENTRIES      2
 
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-
 /*
  * USB 2.0 devices need to expose both high speed and full speed
  * descriptors, unless they only run at full speed.
@@ -1014,14 +975,14 @@ static const struct usb_descriptor_header *hs_function[] = {
 #define HS_FUNCTION_PRE_EP_ENTRIES      2
 
 /* Maxpacket and other transfer characteristics vary by speed. */
-#define ep_desc(g,fs,hs)        (((g)->speed==USB_SPEED_HIGH) ? (hs) : (fs))
-
-#else
-
-/* If there's no high speed support, always use the full-speed descriptor. */
-#define ep_desc(g,fs,hs)        fs
-
-#endif  /* !CONFIG_USB_GADGET_DUALSPEED */
+static struct usb_endpoint_descriptor *
+ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
+                struct usb_endpoint_descriptor *hs)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
+}
 
 
 /* The CBI specification limits the serial string to 12 uppercase hexadecimal
@@ -1053,26 +1014,22 @@ static struct usb_gadget_strings	stringtab = {
 static int populate_config_buf(struct usb_gadget *gadget,
                 u8 *buf, u8 type, unsigned index)
 {
-#ifdef CONFIG_USB_GADGET_DUALSPEED
         enum usb_device_speed                   speed = gadget->speed;
-#endif
         int                                     len;
         const struct usb_descriptor_header      **function;
 
         if (index > 0)
                 return -EINVAL;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        if (type == USB_DT_OTHER_SPEED_CONFIG)
+        if (gadget_is_dualspeed(gadget) && type == USB_DT_OTHER_SPEED_CONFIG)
                 speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
-        if (speed == USB_SPEED_HIGH)
+        if (gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH)
                 function = hs_function;
         else
-#endif
                 function = fs_function;
 
         /* for now, don't advertise srp-only devices */
-        if (!gadget->is_otg)
+        if (!gadget_is_otg(gadget))
                 function++;
 
         len = usb_gadget_config_buf(&config_desc, buf, EP0_BUFSIZE, function);
@@ -1394,10 +1351,9 @@ static int standard_setup_req(struct fsg_dev *fsg,
                         value = sizeof device_desc;
                         memcpy(req->buf, &device_desc, value);
                         break;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
                 case USB_DT_DEVICE_QUALIFIER:
                         VDBG(fsg, "get device qualifier\n");
-                        if (!fsg->gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(fsg->gadget))
                                 break;
                         value = sizeof dev_qualifier;
                         memcpy(req->buf, &dev_qualifier, value);
@@ -1405,15 +1361,12 @@ static int standard_setup_req(struct fsg_dev *fsg,
 
                 case USB_DT_OTHER_SPEED_CONFIG:
                         VDBG(fsg, "get other-speed config descriptor\n");
-                        if (!fsg->gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(fsg->gadget))
                                 break;
                         goto get_config;
-#endif
                 case USB_DT_CONFIG:
                         VDBG(fsg, "get configuration descriptor\n");
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-                get_config:
-#endif
+get_config:
                         value = populate_config_buf(fsg->gadget,
                                         req->buf,
                                         w_value >> 8,
@@ -1646,7 +1599,8 @@ static int do_read(struct fsg_dev *fsg)
                 /* Wait for the next buffer to become available */
                 bh = fsg->next_buffhd_to_fill;
                 while (bh->state != BUF_STATE_EMPTY) {
-                        if ((rc = sleep_thread(fsg)) != 0)
+                        rc = sleep_thread(fsg);
+                        if (rc)
                                 return rc;
                 }
 
@@ -1885,7 +1839,8 @@ static int do_write(struct fsg_dev *fsg)
                 }
 
                 /* Wait for something to happen */
-                if ((rc = sleep_thread(fsg)) != 0)
+                rc = sleep_thread(fsg);
+                if (rc)
                         return rc;
         }
 
@@ -2369,7 +2324,8 @@ static int pad_with_zeros(struct fsg_dev *fsg)
 
                 /* Wait for the next buffer to be free */
                 while (bh->state != BUF_STATE_EMPTY) {
-                        if ((rc = sleep_thread(fsg)) != 0)
+                        rc = sleep_thread(fsg);
+                        if (rc)
                                 return rc;
                 }
 
@@ -2429,7 +2385,8 @@ static int throw_away_data(struct fsg_dev *fsg)
                 }
 
                 /* Otherwise wait for something to happen */
-                if ((rc = sleep_thread(fsg)) != 0)
+                rc = sleep_thread(fsg);
+                if (rc)
                         return rc;
         }
         return 0;
@@ -2551,7 +2508,8 @@ static int send_status(struct fsg_dev *fsg)
         /* Wait for the next buffer to become available */
         bh = fsg->next_buffhd_to_fill;
         while (bh->state != BUF_STATE_EMPTY) {
-                if ((rc = sleep_thread(fsg)) != 0)
+                rc = sleep_thread(fsg);
+                if (rc)
                         return rc;
         }
 
@@ -2771,9 +2729,10 @@ static int do_scsi_command(struct fsg_dev *fsg)
         /* Wait for the next buffer to become available for data or status */
         bh = fsg->next_buffhd_to_drain = fsg->next_buffhd_to_fill;
         while (bh->state != BUF_STATE_EMPTY) {
-                if ((rc = sleep_thread(fsg)) != 0)
+                rc = sleep_thread(fsg);
+                if (rc)
                         return rc;
-                }
+        }
         fsg->phase_error = 0;
         fsg->short_packet_received = 0;
 
@@ -3005,7 +2964,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
         /* Is the CBW meaningful? */
         if (cbw->Lun >= MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
-                        cbw->Length < 6 || cbw->Length > MAX_COMMAND_SIZE) {
+                        cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
                 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
                                 "cmdlen %u\n",
                                 cbw->Lun, cbw->Flags, cbw->Length);
@@ -3045,9 +3004,10 @@ static int get_next_command(struct fsg_dev *fsg)
                 /* Wait for the next buffer to become available */
                 bh = fsg->next_buffhd_to_fill;
                 while (bh->state != BUF_STATE_EMPTY) {
-                        if ((rc = sleep_thread(fsg)) != 0)
+                        rc = sleep_thread(fsg);
+                        if (rc)
                                 return rc;
-                        }
+                }
 
                 /* Queue a request to read a Bulk-only CBW */
                 set_bulk_out_req_length(fsg, bh, USB_BULK_CB_WRAP_LEN);
@@ -3061,9 +3021,10 @@ static int get_next_command(struct fsg_dev *fsg)
 
                 /* Wait for the CBW to arrive */
                 while (bh->state != BUF_STATE_FULL) {
-                        if ((rc = sleep_thread(fsg)) != 0)
+                        rc = sleep_thread(fsg);
+                        if (rc)
                                 return rc;
-                        }
+                }
                 smp_rmb();
                 rc = received_cbw(fsg, bh);
                 bh->state = BUF_STATE_EMPTY;
@@ -3072,9 +3033,10 @@ static int get_next_command(struct fsg_dev *fsg)
 
                 /* Wait for the next command to arrive */
                 while (fsg->cbbuf_cmnd_size == 0) {
-                        if ((rc = sleep_thread(fsg)) != 0)
+                        rc = sleep_thread(fsg);
+                        if (rc)
                                 return rc;
-                        }
+                }
 
                 /* Is the previous status interrupt request still busy?
                  * The host is allowed to skip reading the status,
@@ -3595,7 +3557,8 @@ static ssize_t show_ro(struct device *dev, struct device_attribute *attr, char *
         return sprintf(buf, "%d\n", curlun->ro);
 }
 
-static ssize_t show_file(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_file(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         struct lun      *curlun = dev_to_lun(dev);
         struct fsg_dev  *fsg = dev_get_drvdata(dev);
@@ -3604,8 +3567,8 @@ static ssize_t show_file(struct device *dev, struct device_attribute *attr, char
 
         down_read(&fsg->filesem);
         if (backing_file_is_open(curlun)) {     // Get the complete pathname
-                p = d_path(curlun->filp->f_path.dentry, curlun->filp->f_path.mnt,
-                                buf, PAGE_SIZE - 1);
+                p = d_path(curlun->filp->f_path.dentry,
+                                curlun->filp->f_path.mnt, buf, PAGE_SIZE - 1);
                 if (IS_ERR(p))
                         rc = PTR_ERR(p);
                 else {
@@ -3623,7 +3586,8 @@ static ssize_t show_file(struct device *dev, struct device_attribute *attr, char
 }
 
 
-static ssize_t store_ro(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t store_ro(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
 {
         ssize_t         rc = count;
         struct lun      *curlun = dev_to_lun(dev);
@@ -3647,7 +3611,8 @@ static ssize_t store_ro(struct device *dev, struct device_attribute *attr, const
         return rc;
 }
 
-static ssize_t store_file(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t store_file(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
 {
         struct lun      *curlun = dev_to_lun(dev);
         struct fsg_dev  *fsg = dev_get_drvdata(dev);
@@ -3859,7 +3824,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         /* Find out how many LUNs there should be */
         i = mod_data.nluns;
         if (i == 0)
-                i = max(mod_data.num_filenames, 1);
+                i = max(mod_data.num_filenames, 1u);
         if (i > MAX_LUNS) {
                 ERROR(fsg, "invalid number of LUNs: %d\n", i);
                 rc = -EINVAL;
@@ -3944,21 +3909,23 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         intf_desc.bInterfaceProtocol = mod_data.transport_type;
         fs_function[i + FS_FUNCTION_PRE_EP_ENTRIES] = NULL;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        hs_function[i + HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
+        if (gadget_is_dualspeed(gadget)) {
+                hs_function[i + HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
 
-        /* Assume ep0 uses the same maxpacket value for both speeds */
-        dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
+                /* Assume ep0 uses the same maxpacket value for both speeds */
+                dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
 
-        /* Assume that all endpoint addresses are the same for both speeds */
-        hs_bulk_in_desc.bEndpointAddress = fs_bulk_in_desc.bEndpointAddress;
-        hs_bulk_out_desc.bEndpointAddress = fs_bulk_out_desc.bEndpointAddress;
-        hs_intr_in_desc.bEndpointAddress = fs_intr_in_desc.bEndpointAddress;
-#endif
+                /* Assume endpoint addresses are the same for both speeds */
+                hs_bulk_in_desc.bEndpointAddress =
+                                fs_bulk_in_desc.bEndpointAddress;
+                hs_bulk_out_desc.bEndpointAddress =
+                                fs_bulk_out_desc.bEndpointAddress;
+                hs_intr_in_desc.bEndpointAddress =
+                                fs_intr_in_desc.bEndpointAddress;
+        }
 
-        if (gadget->is_otg) {
+        if (gadget_is_otg(gadget))
                 otg_desc.bmAttributes |= USB_OTG_HNP;
-        }
 
         rc = -ENOMEM;
 
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index d57bcfbc08..9bb7f64a85 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -35,7 +35,7 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 #include <linux/usb/otg.h>
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
@@ -1090,14 +1090,11 @@ static int fsl_vbus_session(struct usb_gadget *gadget, int is_active)
  */
 static int fsl_vbus_draw(struct usb_gadget *gadget, unsigned mA)
 {
-#ifdef CONFIG_USB_OTG
         struct fsl_udc *udc;
 
         udc = container_of(gadget, struct fsl_udc, gadget);
-
         if (udc->transceiver)
                 return otg_set_power(udc->transceiver, mA);
-#endif
         return -ENOTSUPP;
 }
 
@@ -1120,7 +1117,7 @@ static int fsl_pullup(struct usb_gadget *gadget, int is_on)
         return 0;
 }
 
-/* defined in usb_gadget.h */
+/* defined in gadget.h */
 static struct usb_gadget_ops fsl_gadget_ops = {
         .get_frame = fsl_get_frame,
         .wakeup = fsl_wakeup,
@@ -1321,7 +1318,7 @@ static void setup_received_irq(struct fsl_udc *udc,
                                 | USB_TYPE_STANDARD)) {
                         /* Note: The driver has not include OTG support yet.
                          * This will be set when OTG support is added */
-                        if (!udc->gadget.is_otg)
+                        if (!gadget_is_otg(udc->gadget))
                                 break;
                         else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE)
                                 udc->gadget.b_hnp_enable = 1;
@@ -1330,6 +1327,8 @@ static void setup_received_irq(struct fsl_udc *udc,
                         else if (setup->bRequest ==
                                         USB_DEVICE_A_ALT_HNP_SUPPORT)
                                 udc->gadget.a_alt_hnp_support = 1;
+                        else
+                                break;
                         rc = 0;
                 } else
                         break;
@@ -1840,10 +1839,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         if (!driver || driver != udc_controller->driver || !driver->unbind)
                 return -EINVAL;
 
-#ifdef CONFIG_USB_OTG
         if (udc_controller->transceiver)
                 (void)otg_set_peripheral(udc_controller->transceiver, 0);
-#endif
 
         /* stop DR, disable intr */
         dr_controller_stop(udc_controller);
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 1c5aa49d74..0689189550 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -18,17 +18,11 @@
  * http://www.usb.org/developers/devclass_docs/midi10.pdf
  */
 
-#define DEBUG 1
-// #define VERBOSE
+/* #define VERBOSE_DEBUG */
 
-#include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/errno.h>
-#include <linux/init.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
-#include <linux/moduleparam.h>
 
 #include <sound/driver.h>
 #include <sound/core.h>
@@ -36,7 +30,7 @@
 #include <sound/rawmidi.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 #include <linux/usb/audio.h>
 #include <linux/usb/midi.h>
 
@@ -139,30 +133,16 @@ struct gmidi_device {
 static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req);
 
 
-#define xprintk(d,level,fmt,args...) \
-        dev_printk(level , &(d)->gadget->dev , fmt , ## args)
-
-#ifdef DEBUG
-#define DBG(dev,fmt,args...) \
-        xprintk(dev , KERN_DEBUG , fmt , ## args)
-#else
-#define DBG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE
-#define VDBG    DBG
-#else
-#define VDBG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* VERBOSE */
-
-#define ERROR(dev,fmt,args...) \
-        xprintk(dev , KERN_ERR , fmt , ## args)
-#define WARN(dev,fmt,args...) \
-        xprintk(dev , KERN_WARNING , fmt , ## args)
-#define INFO(dev,fmt,args...) \
-        xprintk(dev , KERN_INFO , fmt , ## args)
+#define DBG(d, fmt, args...) \
+        dev_dbg(&(d)->gadget->dev , fmt , ## args)
+#define VDBG(d, fmt, args...) \
+        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+#define ERROR(d, fmt, args...) \
+        dev_err(&(d)->gadget->dev , fmt , ## args)
+#define WARN(d, fmt, args...) \
+        dev_warn(&(d)->gadget->dev , fmt , ## args)
+#define INFO(d, fmt, args...) \
+        dev_info(&(d)->gadget->dev , fmt , ## args)
 
 
 static unsigned buflen = 256;
@@ -425,7 +405,7 @@ static int config_buf(struct usb_gadget *gadget,
         return len;
 }
 
-static struct usb_request* alloc_ep_req(struct usb_ep *ep, unsigned length)
+static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
 {
         struct usb_request      *req;
 
@@ -455,7 +435,7 @@ static const uint8_t gmidi_cin_length[] = {
  * Receives a chunk of MIDI data.
  */
 static void gmidi_read_data(struct usb_ep *ep, int cable,
-                                   uint8_t* data, int length)
+                                   uint8_t *data, int length)
 {
         struct gmidi_device *dev = ep->driver_data;
         /* cable is ignored, because for now we only have one. */
@@ -541,7 +521,7 @@ static int set_gmidi_config(struct gmidi_device *dev, gfp_t gfp_flags)
 {
         int err = 0;
         struct usb_request *req;
-        struct usb_ep* ep;
+        struct usb_ep *ep;
         unsigned i;
 
         err = usb_ep_enable(dev->in_ep, &bulk_in_desc);
@@ -628,7 +608,7 @@ gmidi_set_config(struct gmidi_device *dev, unsigned number, gfp_t gfp_flags)
 
         if (gadget_is_sa1100(gadget) && dev->config) {
                 /* tx fifo is full, but we can't clear it...*/
-                INFO(dev, "can't change configurations\n");
+                ERROR(dev, "can't change configurations\n");
                 return -ESPIPE;
         }
         gmidi_reset_config(dev);
@@ -843,7 +823,7 @@ static void gmidi_disconnect(struct usb_gadget *gadget)
 static void /* __init_or_exit */ gmidi_unbind(struct usb_gadget *gadget)
 {
         struct gmidi_device *dev = get_gadget_data(gadget);
-        struct snd_card* card;
+        struct snd_card *card;
 
         DBG(dev, "unbind\n");
 
@@ -867,12 +847,12 @@ static int gmidi_snd_free(struct snd_device *device)
         return 0;
 }
 
-static void gmidi_transmit_packet(struct usb_request* req, uint8_t p0,
+static void gmidi_transmit_packet(struct usb_request *req, uint8_t p0,
                                         uint8_t p1, uint8_t p2, uint8_t p3)
 {
         unsigned length = req->length;
+        u8 *buf = (u8 *)req->buf + length;
 
-        uint8_t* buf = (uint8_t*)req->buf + length;
         buf[0] = p0;
         buf[1] = p1;
         buf[2] = p2;
@@ -883,8 +863,8 @@ static void gmidi_transmit_packet(struct usb_request* req, uint8_t p0,
 /*
  * Converts MIDI commands to USB MIDI packets.
  */
-static void gmidi_transmit_byte(struct usb_request* req,
-                                struct gmidi_in_port* port, uint8_t b)
+static void gmidi_transmit_byte(struct usb_request *req,
+                                struct gmidi_in_port *port, uint8_t b)
 {
         uint8_t p0 = port->cable;
 
@@ -981,10 +961,10 @@ static void gmidi_transmit_byte(struct usb_request* req,
         }
 }
 
-static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req)
+static void gmidi_transmit(struct gmidi_device *dev, struct usb_request *req)
 {
-        struct usb_ep* ep = dev->in_ep;
-        struct gmidi_in_port* port = &dev->in_port;
+        struct usb_ep *ep = dev->in_ep;
+        struct gmidi_in_port *port = &dev->in_port;
 
         if (!ep) {
                 return;
@@ -1020,14 +1000,14 @@ static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req)
 
 static void gmidi_in_tasklet(unsigned long data)
 {
-        struct gmidi_device* dev = (struct gmidi_device*)data;
+        struct gmidi_device *dev = (struct gmidi_device *)data;
 
         gmidi_transmit(dev, NULL);
 }
 
 static int gmidi_in_open(struct snd_rawmidi_substream *substream)
 {
-        struct gmidi_device* dev = substream->rmidi->private_data;
+        struct gmidi_device *dev = substream->rmidi->private_data;
 
         VDBG(dev, "gmidi_in_open\n");
         dev->in_substream = substream;
@@ -1037,13 +1017,15 @@ static int gmidi_in_open(struct snd_rawmidi_substream *substream)
 
 static int gmidi_in_close(struct snd_rawmidi_substream *substream)
 {
+        struct gmidi_device *dev = substream->rmidi->private_data;
+
         VDBG(dev, "gmidi_in_close\n");
         return 0;
 }
 
 static void gmidi_in_trigger(struct snd_rawmidi_substream *substream, int up)
 {
-        struct gmidi_device* dev = substream->rmidi->private_data;
+        struct gmidi_device *dev = substream->rmidi->private_data;
 
         VDBG(dev, "gmidi_in_trigger %d\n", up);
         dev->in_port.active = up;
@@ -1054,7 +1036,7 @@ static void gmidi_in_trigger(struct snd_rawmidi_substream *substream, int up)
 
 static int gmidi_out_open(struct snd_rawmidi_substream *substream)
 {
-        struct gmidi_device* dev = substream->rmidi->private_data;
+        struct gmidi_device *dev = substream->rmidi->private_data;
 
         VDBG(dev, "gmidi_out_open\n");
         dev->out_substream = substream;
@@ -1063,13 +1045,15 @@ static int gmidi_out_open(struct snd_rawmidi_substream *substream)
 
 static int gmidi_out_close(struct snd_rawmidi_substream *substream)
 {
+        struct gmidi_device *dev = substream->rmidi->private_data;
+
         VDBG(dev, "gmidi_out_close\n");
         return 0;
 }
 
 static void gmidi_out_trigger(struct snd_rawmidi_substream *substream, int up)
 {
-        struct gmidi_device* dev = substream->rmidi->private_data;
+        struct gmidi_device *dev = substream->rmidi->private_data;
 
         VDBG(dev, "gmidi_out_trigger %d\n", up);
         if (up) {
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 349b8166f3..2ec9d196a8 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -37,7 +37,7 @@
 #include <linux/proc_fs.h>
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index 173004f60f..47ef8bd58a 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -20,8 +20,7 @@
  */
 
 
-// #define      DEBUG                   /* data to help fault diagnosis */
-// #define      VERBOSE         /* extra debug messages (success too) */
+/* #define VERBOSE_DEBUG */
 
 #include <linux/init.h>
 #include <linux/module.h>
@@ -38,7 +37,7 @@
 #include <linux/moduleparam.h>
 
 #include <linux/usb/gadgetfs.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 
 /*
@@ -253,7 +252,7 @@ static const char *CHIP;
         do { } while (0)
 #endif /* DEBUG */
 
-#ifdef VERBOSE
+#ifdef VERBOSE_DEBUG
 #define VDEBUG  DBG
 #else
 #define VDEBUG(dev,fmt,args...) \
@@ -1010,11 +1009,12 @@ ep0_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
                         /* assume that was SET_CONFIGURATION */
                         if (dev->current_config) {
                                 unsigned power;
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-                                if (dev->gadget->speed == USB_SPEED_HIGH)
+
+                                if (gadget_is_dualspeed(dev->gadget)
+                                                && (dev->gadget->speed
+                                                        == USB_SPEED_HIGH))
                                         power = dev->hs_config->bMaxPower;
                                 else
-#endif
                                         power = dev->config->bMaxPower;
                                 usb_gadget_vbus_draw(dev->gadget, 2 * power);
                         }
@@ -1355,24 +1355,21 @@ static int
 config_buf (struct dev_data *dev, u8 type, unsigned index)
 {
         int             len;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        int             hs;
-#endif
+        int             hs = 0;
 
         /* only one configuration */
         if (index > 0)
                 return -EINVAL;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        hs = (dev->gadget->speed == USB_SPEED_HIGH);
-        if (type == USB_DT_OTHER_SPEED_CONFIG)
-                hs = !hs;
+        if (gadget_is_dualspeed(dev->gadget)) {
+                hs = (dev->gadget->speed == USB_SPEED_HIGH);
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        hs = !hs;
+        }
         if (hs) {
                 dev->req->buf = dev->hs_config;
                 len = le16_to_cpu(dev->hs_config->wTotalLength);
-        } else
-#endif
-        {
+        } else {
                 dev->req->buf = dev->config;
                 len = le16_to_cpu(dev->config->wTotalLength);
         }
@@ -1393,13 +1390,13 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
         spin_lock (&dev->lock);
         dev->setup_abort = 0;
         if (dev->state == STATE_DEV_UNCONNECTED) {
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-                if (gadget->speed == USB_SPEED_HIGH && dev->hs_config == NULL) {
+                if (gadget_is_dualspeed(gadget)
+                                && gadget->speed == USB_SPEED_HIGH
+                                && dev->hs_config == NULL) {
                         spin_unlock(&dev->lock);
                         ERROR (dev, "no high speed config??\n");
                         return -EINVAL;
                 }
-#endif  /* CONFIG_USB_GADGET_DUALSPEED */
 
                 dev->state = STATE_DEV_CONNECTED;
                 dev->dev->bMaxPacketSize0 = gadget->ep0->maxpacket;
@@ -1469,13 +1466,12 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         // user mode expected to disable endpoints
                 } else {
                         u8      config, power;
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-                        if (gadget->speed == USB_SPEED_HIGH) {
+
+                        if (gadget_is_dualspeed(gadget)
+                                        && gadget->speed == USB_SPEED_HIGH) {
                                 config = dev->hs_config->bConfigurationValue;
                                 power = dev->hs_config->bMaxPower;
-                        } else
-#endif
-                        {
+                        } else {
                                 config = dev->config->bConfigurationValue;
                                 power = dev->config->bMaxPower;
                         }
diff --git a/drivers/usb/gadget/lh7a40x_udc.h b/drivers/usb/gadget/lh7a40x_udc.h
index b3fe197e1e..1ecfd6366b 100644
--- a/drivers/usb/gadget/lh7a40x_udc.h
+++ b/drivers/usb/gadget/lh7a40x_udc.h
@@ -50,7 +50,7 @@
 #include <asm/hardware.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 /*
  * Memory map
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 4b27d12f04..ebc5536aa2 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -27,7 +27,7 @@
 #include <linux/platform_device.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include "m66592-udc.h"
 
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index c3d364ecd4..d5d473f814 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -62,7 +62,7 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 9b0f0925dd..87c4f50dfb 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -38,7 +38,7 @@
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 #include <linux/usb/otg.h>
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
@@ -1241,19 +1241,15 @@ static void pullup_enable(struct omap_udc *udc)
         udc->gadget.dev.parent->power.power_state = PMSG_ON;
         udc->gadget.dev.power.power_state = PMSG_ON;
         UDC_SYSCON1_REG |= UDC_PULLUP_EN;
-#ifndef CONFIG_USB_OTG
-        if (!cpu_is_omap15xx())
+        if (!gadget_is_otg(udc->gadget) && !cpu_is_omap15xx())
                 OTG_CTRL_REG |= OTG_BSESSVLD;
-#endif
         UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
 }
 
 static void pullup_disable(struct omap_udc *udc)
 {
-#ifndef CONFIG_USB_OTG
-        if (!cpu_is_omap15xx())
+        if (!gadget_is_otg(udc->gadget) && !cpu_is_omap15xx())
                 OTG_CTRL_REG &= ~OTG_BSESSVLD;
-#endif
         UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
         UDC_SYSCON1_REG &= ~UDC_PULLUP_EN;
 }
@@ -1390,7 +1386,7 @@ static void update_otg(struct omap_udc *udc)
 {
         u16     devstat;
 
-        if (!udc->gadget.is_otg)
+        if (!gadget_is_otg(udc->gadget))
                 return;
 
         if (OTG_CTRL_REG & OTG_ID)
diff --git a/drivers/usb/gadget/pxa2xx_udc.c b/drivers/usb/gadget/pxa2xx_udc.c
index 1407ad1c81..3e715082de 100644
--- a/drivers/usb/gadget/pxa2xx_udc.c
+++ b/drivers/usb/gadget/pxa2xx_udc.c
@@ -54,7 +54,7 @@
 #include <asm/hardware.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/mach/udc_pxa2xx.h>
 
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 0be80c635c..e3e90f8a75 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -42,7 +42,7 @@
 #include <linux/seq_file.h>
 
 #include <linux/usb.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index ce4d2e0963..f5738eb8e7 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -17,34 +17,15 @@
  *
  */
 
-#include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
 #include <linux/utsname.h>
-#include <linux/wait.h>
-#include <linux/proc_fs.h>
 #include <linux/device.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
-#include <linux/mutex.h>
-
-#include <asm/byteorder.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-#include <asm/unaligned.h>
-#include <asm/uaccess.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/cdc.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
@@ -89,30 +70,29 @@
 #define GS_DEFAULT_PARITY               USB_CDC_NO_PARITY
 #define GS_DEFAULT_CHAR_FORMAT          USB_CDC_1_STOP_BITS
 
-/* select highspeed/fullspeed, hiding highspeed if not configured */
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-#define GS_SPEED_SELECT(is_hs,hs,fs) ((is_hs) ? (hs) : (fs))
-#else
-#define GS_SPEED_SELECT(is_hs,hs,fs) (fs)
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
+/* maxpacket and other transfer characteristics vary by speed. */
+static inline struct usb_endpoint_descriptor *
+choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+                struct usb_endpoint_descriptor *fs)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
+}
+
 
 /* debug settings */
-#ifdef GS_DEBUG
+#ifdef DEBUG
 static int debug = 1;
+#else
+#define debug 0
+#endif
 
 #define gs_debug(format, arg...) \
         do { if (debug) printk(KERN_DEBUG format, ## arg); } while(0)
 #define gs_debug_level(level, format, arg...) \
         do { if (debug>=level) printk(KERN_DEBUG format, ## arg); } while(0)
 
-#else
-
-#define gs_debug(format, arg...) \
-        do { } while(0)
-#define gs_debug_level(level, format, arg...) \
-        do { } while(0)
-
-#endif /* GS_DEBUG */
 
 /* Thanks to NetChip Technologies for donating this product ID.
  *
@@ -147,10 +127,10 @@ struct gs_req_entry {
 
 /* the port structure holds info for each port, one for each minor number */
 struct gs_port {
-        struct gs_dev           *port_dev;      /* pointer to device struct */
+        struct gs_dev           *port_dev;      /* pointer to device struct */
         struct tty_struct       *port_tty;      /* pointer to tty struct */
         spinlock_t              port_lock;
-        int                     port_num;
+        int                     port_num;
         int                     port_open_count;
         int                     port_in_use;    /* open/close in progress */
         wait_queue_head_t       port_write_wait;/* waiting to write */
@@ -188,7 +168,7 @@ static void __exit gs_module_exit(void);
 /* tty driver */
 static int gs_open(struct tty_struct *tty, struct file *file);
 static void gs_close(struct tty_struct *tty, struct file *file);
-static int gs_write(struct tty_struct *tty, 
+static int gs_write(struct tty_struct *tty,
         const unsigned char *buf, int count);
 static void gs_put_char(struct tty_struct *tty, unsigned char ch);
 static void gs_flush_chars(struct tty_struct *tty);
@@ -222,7 +202,7 @@ static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req);
 static void gs_disconnect(struct usb_gadget *gadget);
 static int gs_set_config(struct gs_dev *dev, unsigned config);
 static void gs_reset_config(struct gs_dev *dev);
-static int gs_build_config_buf(u8 *buf, enum usb_device_speed speed,
+static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
                 u8 type, unsigned int index, int is_otg);
 
 static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
@@ -415,18 +395,18 @@ static const struct usb_cdc_header_desc gs_header_desc = {
 };
 
 static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
-        .bLength =              sizeof(gs_call_mgmt_descriptor),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
-        .bmCapabilities =       0,
-        .bDataInterface =       1,      /* index of data interface */
+        .bLength =              sizeof(gs_call_mgmt_descriptor),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
+        .bmCapabilities =       0,
+        .bDataInterface =       1,      /* index of data interface */
 };
 
 static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
-        .bLength =              sizeof(gs_acm_descriptor),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
-        .bmCapabilities =       0,
+        .bLength =              sizeof(gs_acm_descriptor),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
+        .bmCapabilities =       0,
 };
 
 static const struct usb_cdc_union_desc gs_union_desc = {
@@ -436,7 +416,7 @@ static const struct usb_cdc_union_desc gs_union_desc = {
         .bMasterInterface0 =    0,      /* index of control interface */
         .bSlaveInterface0 =     1,      /* index of data interface */
 };
- 
+
 static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
@@ -482,7 +462,6 @@ static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = {
         NULL,
 };
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
 static struct usb_endpoint_descriptor gs_highspeed_notify_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
@@ -536,15 +515,13 @@ static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
         NULL,
 };
 
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
-
 
 /* Module */
 MODULE_DESCRIPTION(GS_LONG_NAME);
 MODULE_AUTHOR("Al Borchers");
 MODULE_LICENSE("GPL");
 
-#ifdef GS_DEBUG
+#ifdef DEBUG
 module_param(debug, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
 #endif
@@ -915,7 +892,8 @@ static void gs_put_char(struct tty_struct *tty, unsigned char ch)
                 return;
         }
 
-        gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p, %p, %p\n", port->port_num, tty, ch, __builtin_return_address(0), __builtin_return_address(1), __builtin_return_address(2));
+        gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
+                port->port_num, tty, ch, __builtin_return_address(0));
 
         spin_lock_irqsave(&port->port_lock, flags);
 
@@ -1116,7 +1094,11 @@ static int gs_send(struct gs_dev *dev)
                 len = gs_send_packet(dev, req->buf, ep->maxpacket);
 
                 if (len > 0) {
-gs_debug_level(3, "gs_send: len=%d, 0x%2.2x 0x%2.2x 0x%2.2x ...\n", len, *((unsigned char *)req->buf), *((unsigned char *)req->buf+1), *((unsigned char *)req->buf+2));
+                        gs_debug_level(3, "gs_send: len=%d, 0x%2.2x "
+                                        "0x%2.2x 0x%2.2x ...\n", len,
+                                        *((unsigned char *)req->buf),
+                                        *((unsigned char *)req->buf+1),
+                                        *((unsigned char *)req->buf+2));
                         list_del(&req_entry->re_entry);
                         req->length = len;
                         spin_unlock_irqrestore(&dev->dev_lock, flags);
@@ -1269,7 +1251,7 @@ static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
 
         switch(req->status) {
         case 0:
-                /* normal completion */
+                /* normal completion */
                 gs_recv_packet(dev, req->buf, req->actual);
 requeue:
                 req->length = ep->maxpacket;
@@ -1406,23 +1388,24 @@ static int __init gs_bind(struct usb_gadget *gadget)
                 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
         gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        gs_qualifier_desc.bDeviceClass = use_acm
-                ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
-        /* assume ep0 uses the same packet size for both speeds */
-        gs_qualifier_desc.bMaxPacketSize0 = gs_device_desc.bMaxPacketSize0;
-        /* assume endpoints are dual-speed */
-        gs_highspeed_notify_desc.bEndpointAddress =
-                gs_fullspeed_notify_desc.bEndpointAddress;
-        gs_highspeed_in_desc.bEndpointAddress =
-                gs_fullspeed_in_desc.bEndpointAddress;
-        gs_highspeed_out_desc.bEndpointAddress =
-                gs_fullspeed_out_desc.bEndpointAddress;
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
+        if (gadget_is_dualspeed(gadget)) {
+                gs_qualifier_desc.bDeviceClass = use_acm
+                        ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
+                /* assume ep0 uses the same packet size for both speeds */
+                gs_qualifier_desc.bMaxPacketSize0 =
+                        gs_device_desc.bMaxPacketSize0;
+                /* assume endpoints are dual-speed */
+                gs_highspeed_notify_desc.bEndpointAddress =
+                        gs_fullspeed_notify_desc.bEndpointAddress;
+                gs_highspeed_in_desc.bEndpointAddress =
+                        gs_fullspeed_in_desc.bEndpointAddress;
+                gs_highspeed_out_desc.bEndpointAddress =
+                        gs_fullspeed_out_desc.bEndpointAddress;
+        }
 
         usb_gadget_set_selfpowered(gadget);
 
-        if (gadget->is_otg) {
+        if (gadget_is_otg(gadget)) {
                 gs_otg_descriptor.bmAttributes |= USB_OTG_HNP,
                 gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
                 gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
@@ -1487,6 +1470,12 @@ static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
                         dev->dev_ctrl_req = NULL;
                 }
                 gs_free_ports(dev);
+                if (dev->dev_notify_ep)
+                        usb_ep_disable(dev->dev_notify_ep);
+                if (dev->dev_in_ep)
+                        usb_ep_disable(dev->dev_in_ep);
+                if (dev->dev_out_ep)
+                        usb_ep_disable(dev->dev_out_ep);
                 kfree(dev);
                 set_gadget_data(gadget, NULL);
         }
@@ -1570,9 +1559,8 @@ static int gs_setup_standard(struct usb_gadget *gadget,
                         memcpy(req->buf, &gs_device_desc, ret);
                         break;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
                 case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         ret = min(wLength,
                                 (u16)sizeof(struct usb_qualifier_descriptor));
@@ -1580,14 +1568,13 @@ static int gs_setup_standard(struct usb_gadget *gadget,
                         break;
 
                 case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         /* fall through */
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
                 case USB_DT_CONFIG:
-                        ret = gs_build_config_buf(req->buf, gadget->speed,
+                        ret = gs_build_config_buf(req->buf, gadget,
                                 wValue >> 8, wValue & 0xff,
-                                gadget->is_otg);
+                                gadget_is_otg(gadget));
                         if (ret >= 0)
                                 ret = min(wLength, (u16)ret);
                         break;
@@ -1827,8 +1814,7 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
 
                 if (EP_NOTIFY_NAME
                 && strcmp(ep->name, EP_NOTIFY_NAME) == 0) {
-                        ep_desc = GS_SPEED_SELECT(
-                                gadget->speed == USB_SPEED_HIGH,
+                        ep_desc = choose_ep_desc(gadget,
                                 &gs_highspeed_notify_desc,
                                 &gs_fullspeed_notify_desc);
                         ret = usb_ep_enable(ep,ep_desc);
@@ -1844,9 +1830,8 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
                 }
 
                 else if (strcmp(ep->name, EP_IN_NAME) == 0) {
-                        ep_desc = GS_SPEED_SELECT(
-                                gadget->speed == USB_SPEED_HIGH,
-                                &gs_highspeed_in_desc,
+                        ep_desc = choose_ep_desc(gadget,
+                                &gs_highspeed_in_desc,
                                 &gs_fullspeed_in_desc);
                         ret = usb_ep_enable(ep,ep_desc);
                         if (ret == 0) {
@@ -1861,8 +1846,7 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
                 }
 
                 else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
-                        ep_desc = GS_SPEED_SELECT(
-                                gadget->speed == USB_SPEED_HIGH,
+                        ep_desc = choose_ep_desc(gadget,
                                 &gs_highspeed_out_desc,
                                 &gs_fullspeed_out_desc);
                         ret = usb_ep_enable(ep,ep_desc);
@@ -1981,11 +1965,11 @@ static void gs_reset_config(struct gs_dev *dev)
  * Builds the config descriptors in the given buffer and returns the
  * length, or a negative error number.
  */
-static int gs_build_config_buf(u8 *buf, enum usb_device_speed speed,
+static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
         u8 type, unsigned int index, int is_otg)
 {
         int len;
-        int high_speed;
+        int high_speed = 0;
         const struct usb_config_descriptor *config_desc;
         const struct usb_descriptor_header **function;
 
@@ -1993,20 +1977,22 @@ static int gs_build_config_buf(u8 *buf, enum usb_device_speed speed,
                 return -EINVAL;
 
         /* other speed switches high and full speed */
-        high_speed = (speed == USB_SPEED_HIGH);
-        if (type == USB_DT_OTHER_SPEED_CONFIG)
-                high_speed = !high_speed;
+        if (gadget_is_dualspeed(g)) {
+                high_speed = (g->speed == USB_SPEED_HIGH);
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        high_speed = !high_speed;
+        }
 
         if (use_acm) {
                 config_desc = &gs_acm_config_desc;
-                function = GS_SPEED_SELECT(high_speed,
-                        gs_acm_highspeed_function,
-                        gs_acm_fullspeed_function);
+                function = high_speed
+                        ? gs_acm_highspeed_function
+                        : gs_acm_fullspeed_function;
         } else {
                 config_desc = &gs_bulk_config_desc;
-                function = GS_SPEED_SELECT(high_speed,
-                        gs_bulk_highspeed_function,
-                        gs_bulk_fullspeed_function);
+                function = high_speed
+                        ? gs_bulk_highspeed_function
+                        : gs_bulk_fullspeed_function;
         }
 
         /* for now, don't advertise srp-only devices */
diff --git a/drivers/usb/gadget/usbstring.c b/drivers/usb/gadget/usbstring.c
index 3459ea6c6c..878e428a0e 100644
--- a/drivers/usb/gadget/usbstring.c
+++ b/drivers/usb/gadget/usbstring.c
@@ -15,7 +15,7 @@
 #include <linux/init.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include <asm/unaligned.h>
 
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index fcfe869acb..fcde5d9c87 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -1,38 +1,22 @@
 /*
  * zero.c -- Gadget Zero, for USB development
  *
- * Copyright (C) 2003-2004 David Brownell
+ * Copyright (C) 2003-2007 David Brownell
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions, and the following disclaimer,
- *    without modification.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The names of the above-listed copyright holders may not be used
- *    to endorse or promote products derived from this software without
- *    specific prior written permission.
+ * 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.
  *
- * ALTERNATIVELY, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") as published by the Free Software
- * Foundation, either version 2 of that 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 SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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
  */
 
 
@@ -57,40 +41,28 @@
  * Many drivers will only have one configuration, letting them be much
  * simpler if they also don't support high speed operation (like this
  * driver does).
+ *
+ * Why is *this* driver using two configurations, rather than setting up
+ * two interfaces with different functions?  To help verify that multiple
+ * configuration infrastucture is working correctly; also, so that it can
+ * work with low capability USB controllers without four bulk endpoints.
  */
 
-#define DEBUG 1
-// #define VERBOSE
+/* #define VERBOSE_DEBUG */
 
-#include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
-#include <linux/moduleparam.h>
-
-#include <asm/byteorder.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-#include <asm/unaligned.h>
 
 #include <linux/usb/ch9.h>
-#include <linux/usb_gadget.h>
+#include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
 
 /*-------------------------------------------------------------------------*/
 
-#define DRIVER_VERSION          "St Patrick's Day 2004"
+#define DRIVER_VERSION          "Lughnasadh, 2007"
 
 static const char shortname [] = "zero";
 static const char longname [] = "Gadget Zero";
@@ -131,30 +103,16 @@ struct zero_dev {
         struct timer_list       resume;
 };
 
-#define xprintk(d,level,fmt,args...) \
-        dev_printk(level , &(d)->gadget->dev , fmt , ## args)
-
-#ifdef DEBUG
-#define DBG(dev,fmt,args...) \
-        xprintk(dev , KERN_DEBUG , fmt , ## args)
-#else
-#define DBG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE
-#define VDBG    DBG
-#else
-#define VDBG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* VERBOSE */
-
-#define ERROR(dev,fmt,args...) \
-        xprintk(dev , KERN_ERR , fmt , ## args)
-#define WARN(dev,fmt,args...) \
-        xprintk(dev , KERN_WARNING , fmt , ## args)
-#define INFO(dev,fmt,args...) \
-        xprintk(dev , KERN_INFO , fmt , ## args)
+#define DBG(d, fmt, args...) \
+        dev_dbg(&(d)->gadget->dev , fmt , ## args)
+#define VDBG(d, fmt, args...) \
+        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+#define ERROR(d, fmt, args...) \
+        dev_err(&(d)->gadget->dev , fmt , ## args)
+#define WARN(d, fmt, args...) \
+        dev_warn(&(d)->gadget->dev , fmt , ## args)
+#define INFO(d, fmt, args...) \
+        dev_info(&(d)->gadget->dev , fmt , ## args)
 
 /*-------------------------------------------------------------------------*/
 
@@ -326,8 +284,6 @@ static const struct usb_descriptor_header *fs_loopback_function [] = {
         NULL,
 };
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-
 /*
  * usb 2.0 devices need to expose both high speed and full speed
  * descriptors, unless they only run at full speed.
@@ -383,17 +339,20 @@ static const struct usb_descriptor_header *hs_loopback_function [] = {
 };
 
 /* maxpacket and other transfer characteristics vary by speed. */
-#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
-
-#else
+static inline struct usb_endpoint_descriptor *
+ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+                struct usb_endpoint_descriptor *fs)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
+}
 
-/* if there's no high speed support, maxpacket doesn't change. */
-#define ep_desc(g,hs,fs) fs
+static char manufacturer[50];
 
-#endif  /* !CONFIG_USB_GADGET_DUALSPEED */
+/* default serial number takes at least two packets */
+static char serial[] = "0123456789.0123456789.0123456789";
 
-static char                             manufacturer [50];
-static char                             serial [40];
 
 /* static strings, in UTF-8 */
 static struct usb_string                strings [] = {
@@ -435,30 +394,29 @@ config_buf (struct usb_gadget *gadget,
         int                             is_source_sink;
         int                             len;
         const struct usb_descriptor_header **function;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        int                             hs = (gadget->speed == USB_SPEED_HIGH);
-#endif
+        int                             hs = 0;
 
         /* two configurations will always be index 0 and index 1 */
         if (index > 1)
                 return -EINVAL;
         is_source_sink = loopdefault ? (index == 1) : (index == 0);
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        if (type == USB_DT_OTHER_SPEED_CONFIG)
-                hs = !hs;
+        if (gadget_is_dualspeed(gadget)) {
+                hs = (gadget->speed == USB_SPEED_HIGH);
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        hs = !hs;
+        }
         if (hs)
                 function = is_source_sink
                         ? hs_source_sink_function
                         : hs_loopback_function;
         else
-#endif
                 function = is_source_sink
                         ? fs_source_sink_function
                         : fs_loopback_function;
 
         /* for now, don't advertise srp-only devices */
-        if (!gadget->is_otg)
+        if (!gadget_is_otg(gadget))
                 function++;
 
         len = usb_gadget_config_buf (is_source_sink
@@ -498,6 +456,19 @@ static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
 
 /*-------------------------------------------------------------------------*/
 
+/*
+ * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripherals,
+ * this just sinks bulk packets OUT to the peripheral and sources them IN
+ * to the host, optionally with specific data patterns.
+ *
+ * In terms of control messaging, this supports all the standard requests
+ * plus two that support control-OUT tests.
+ *
+ * Note that because this doesn't queue more than one request at a time,
+ * some other function must be used to test queueing logic.  The network
+ * link (g_ether) is probably the best option for that.
+ */
+
 /* optionally require specific source/sink data patterns  */
 
 static int
@@ -534,12 +505,7 @@ check_read_data (
         return 0;
 }
 
-static void
-reinit_write_data (
-        struct zero_dev         *dev,
-        struct usb_ep           *ep,
-        struct usb_request      *req
-)
+static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
 {
         unsigned        i;
         u8              *buf = req->buf;
@@ -566,16 +532,16 @@ static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
 
         switch (status) {
 
-        case 0:                         /* normal completion? */
+        case 0:                         /* normal completion? */
                 if (ep == dev->out_ep) {
                         check_read_data (dev, ep, req);
                         memset (req->buf, 0x55, req->length);
                 } else
-                        reinit_write_data (dev, ep, req);
+                        reinit_write_data(ep, req);
                 break;
 
         /* this endpoint is normally active while we're configured */
-        case -ECONNABORTED:             /* hardware forced ep reset */
+        case -ECONNABORTED:             /* hardware forced ep reset */
         case -ECONNRESET:               /* request dequeued */
         case -ESHUTDOWN:                /* disconnect from host */
                 VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
@@ -607,8 +573,7 @@ static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
         }
 }
 
-static struct usb_request *
-source_sink_start_ep (struct usb_ep *ep, gfp_t gfp_flags)
+static struct usb_request *source_sink_start_ep(struct usb_ep *ep)
 {
         struct usb_request      *req;
         int                     status;
@@ -621,11 +586,11 @@ source_sink_start_ep (struct usb_ep *ep, gfp_t gfp_flags)
         req->complete = source_sink_complete;
 
         if (strcmp (ep->name, EP_IN_NAME) == 0)
-                reinit_write_data (ep->driver_data, ep, req);
+                reinit_write_data(ep, req);
         else
                 memset (req->buf, 0x55, req->length);
 
-        status = usb_ep_queue (ep, req, gfp_flags);
+        status = usb_ep_queue(ep, req, GFP_ATOMIC);
         if (status) {
                 struct zero_dev *dev = ep->driver_data;
 
@@ -637,8 +602,7 @@ source_sink_start_ep (struct usb_ep *ep, gfp_t gfp_flags)
         return req;
 }
 
-static int
-set_source_sink_config (struct zero_dev *dev, gfp_t gfp_flags)
+static int set_source_sink_config(struct zero_dev *dev)
 {
         int                     result = 0;
         struct usb_ep           *ep;
@@ -653,8 +617,7 @@ set_source_sink_config (struct zero_dev *dev, gfp_t gfp_flags)
                         result = usb_ep_enable (ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
-                                if (source_sink_start_ep(ep, gfp_flags)
-                                                != NULL) {
+                                if (source_sink_start_ep(ep) != NULL) {
                                         dev->in_ep = ep;
                                         continue;
                                 }
@@ -668,8 +631,7 @@ set_source_sink_config (struct zero_dev *dev, gfp_t gfp_flags)
                         result = usb_ep_enable (ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
-                                if (source_sink_start_ep(ep, gfp_flags)
-                                                != NULL) {
+                                if (source_sink_start_ep(ep) != NULL) {
                                         dev->out_ep = ep;
                                         continue;
                                 }
@@ -701,7 +663,7 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
 
         switch (status) {
 
-        case 0:                         /* normal completion? */
+        case 0:                         /* normal completion? */
                 if (ep == dev->out_ep) {
                         /* loop this OUT packet back IN to the host */
                         req->zero = (req->actual < req->length);
@@ -735,7 +697,7 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
          * rely on the hardware driver to clean up on disconnect or
          * endpoint disable.
          */
-        case -ECONNABORTED:             /* hardware forced ep reset */
+        case -ECONNABORTED:             /* hardware forced ep reset */
         case -ECONNRESET:               /* request dequeued */
         case -ESHUTDOWN:                /* disconnect from host */
                 free_ep_req (ep, req);
@@ -743,8 +705,7 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
         }
 }
 
-static int
-set_loopback_config (struct zero_dev *dev, gfp_t gfp_flags)
+static int set_loopback_config(struct zero_dev *dev)
 {
         int                     result = 0;
         struct usb_ep           *ep;
@@ -844,8 +805,7 @@ static void zero_reset_config (struct zero_dev *dev)
  * code can do, perhaps by disallowing more than one configuration or
  * by limiting configuration choices (like the pxa2xx).
  */
-static int
-zero_set_config (struct zero_dev *dev, unsigned number, gfp_t gfp_flags)
+static int zero_set_config(struct zero_dev *dev, unsigned number)
 {
         int                     result = 0;
         struct usb_gadget       *gadget = dev->gadget;
@@ -855,17 +815,17 @@ zero_set_config (struct zero_dev *dev, unsigned number, gfp_t gfp_flags)
 
         if (gadget_is_sa1100 (gadget) && dev->config) {
                 /* tx fifo is full, but we can't clear it...*/
-                INFO (dev, "can't change configurations\n");
+                ERROR(dev, "can't change configurations\n");
                 return -ESPIPE;
         }
         zero_reset_config (dev);
 
         switch (number) {
         case CONFIG_SOURCE_SINK:
-                result = set_source_sink_config (dev, gfp_flags);
+                result = set_source_sink_config(dev);
                 break;
         case CONFIG_LOOPBACK:
-                result = set_loopback_config (dev, gfp_flags);
+                result = set_loopback_config(dev);
                 break;
         default:
                 result = -EINVAL;
@@ -885,7 +845,7 @@ zero_set_config (struct zero_dev *dev, unsigned number, gfp_t gfp_flags)
                 case USB_SPEED_LOW:     speed = "low"; break;
                 case USB_SPEED_FULL:    speed = "full"; break;
                 case USB_SPEED_HIGH:    speed = "high"; break;
-                default:                speed = "?"; break;
+                default:                speed = "?"; break;
                 }
 
                 dev->config = number;
@@ -938,19 +898,17 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         value = min (w_length, (u16) sizeof device_desc);
                         memcpy (req->buf, &device_desc, value);
                         break;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
                 case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         value = min (w_length, (u16) sizeof dev_qualifier);
                         memcpy (req->buf, &dev_qualifier, value);
                         break;
 
                 case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget->is_dualspeed)
+                        if (!gadget_is_dualspeed(gadget))
                                 break;
                         // FALLTHROUGH
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
                 case USB_DT_CONFIG:
                         value = config_buf (gadget, req->buf,
                                         w_value >> 8,
@@ -984,7 +942,7 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 else
                         VDBG (dev, "HNP inactive\n");
                 spin_lock (&dev->lock);
-                value = zero_set_config (dev, w_value, GFP_ATOMIC);
+                value = zero_set_config(dev, w_value);
                 spin_unlock (&dev->lock);
                 break;
         case USB_REQ_GET_CONFIGURATION:
@@ -1013,7 +971,7 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                          * use this "reset the config" shortcut.
                          */
                         zero_reset_config (dev);
-                        zero_set_config (dev, config, GFP_ATOMIC);
+                        zero_set_config(dev, config);
                         value = 0;
                 }
                 spin_unlock (&dev->lock);
@@ -1163,7 +1121,7 @@ autoconf_fail:
         }
         EP_IN_NAME = ep->name;
         ep->driver_data = ep;   /* claim */
-        
+
         ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
         if (!ep)
                 goto autoconf_fail;
@@ -1207,16 +1165,18 @@ autoconf_fail:
 
         device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
 
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        /* assume ep0 uses the same value for both speeds ... */
-        dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
+        if (gadget_is_dualspeed(gadget)) {
+                /* assume ep0 uses the same value for both speeds ... */
+                dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
 
-        /* and that all endpoints are dual-speed */
-        hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
-        hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
-#endif
+                /* and that all endpoints are dual-speed */
+                hs_source_desc.bEndpointAddress =
+                                fs_source_desc.bEndpointAddress;
+                hs_sink_desc.bEndpointAddress =
+                                fs_sink_desc.bEndpointAddress;
+        }
 
-        if (gadget->is_otg) {
+        if (gadget_is_otg(gadget)) {
                 otg_descriptor.bmAttributes |= USB_OTG_HNP,
                 source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
                 loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
@@ -1294,23 +1254,18 @@ static struct usb_gadget_driver zero_driver = {
         .suspend        = zero_suspend,
         .resume         = zero_resume,
 
-        .driver         = {
+        .driver         = {
                 .name           = (char *) shortname,
                 .owner          = THIS_MODULE,
         },
 };
 
-MODULE_AUTHOR ("David Brownell");
-MODULE_LICENSE ("Dual BSD/GPL");
+MODULE_AUTHOR("David Brownell");
+MODULE_LICENSE("GPL");
 
 
 static int __init init (void)
 {
-        /* a real value would likely come through some id prom
-         * or module option.  this one takes at least two packets.
-         */
-        strlcpy (serial, "0123456789.0123456789.0123456789", sizeof serial);
-
         return usb_gadget_register_driver (&zero_driver);
 }
 module_init (init);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 565d6ef4c4..c978d622fa 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -154,6 +154,19 @@ config USB_OHCI_HCD_PCI
           Enables support for PCI-bus plug-in USB controller cards.
           If unsure, say Y.
 
+config USB_OHCI_HCD_SSB
+        bool "OHCI support for Broadcom SSB OHCI core"
+        depends on USB_OHCI_HCD && SSB && EXPERIMENTAL
+        default n
+        ---help---
+          Support for the Sonics Silicon Backplane (SSB) attached
+          Broadcom USB OHCI core.
+
+          This device is present in some embedded devices with
+          Broadcom based SSB bus.
+
+          If unsure, say N.
+
 config USB_OHCI_BIG_ENDIAN_DESC
         bool
         depends on USB_OHCI_HCD
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index b1d19268cb..766ef68a0b 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -220,10 +220,8 @@ static const struct hc_driver ehci_au1xxx_hc_driver = {
          */
         .hub_status_data = ehci_hub_status_data,
         .hub_control = ehci_hub_control,
-#ifdef  CONFIG_PM
-        .hub_suspend = ehci_hub_suspend,
-        .hub_resume = ehci_hub_resume,
-#endif
+        .bus_suspend = ehci_bus_suspend,
+        .bus_resume = ehci_bus_resume,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 35cdba1041..c151444288 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -570,10 +570,18 @@ static int ehci_run (struct usb_hcd *hcd)
          * are explicitly handed to companion controller(s), so no TT is
          * involved with the root hub.  (Except where one is integrated,
          * and there's no companion controller unless maybe for USB OTG.)
+         *
+         * Turning on the CF flag will transfer ownership of all ports
+         * from the companions to the EHCI controller.  If any of the
+         * companions are in the middle of a port reset at the time, it
+         * could cause trouble.  Write-locking ehci_cf_port_reset_rwsem
+         * guarantees that no resets are in progress.
          */
+        down_write(&ehci_cf_port_reset_rwsem);
         hcd->state = HC_STATE_RUNNING;
         ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
         ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+        up_write(&ehci_cf_port_reset_rwsem);
 
         temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci_info (ehci,
@@ -719,7 +727,6 @@ dead:
  */
 static int ehci_urb_enqueue (
         struct usb_hcd  *hcd,
-        struct usb_host_endpoint *ep,
         struct urb      *urb,
         gfp_t           mem_flags
 ) {
@@ -734,12 +741,12 @@ static int ehci_urb_enqueue (
         default:
                 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
                         return -ENOMEM;
-                return submit_async (ehci, ep, urb, &qtd_list, mem_flags);
+                return submit_async(ehci, urb, &qtd_list, mem_flags);
 
         case PIPE_INTERRUPT:
                 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
                         return -ENOMEM;
-                return intr_submit (ehci, ep, urb, &qtd_list, mem_flags);
+                return intr_submit(ehci, urb, &qtd_list, mem_flags);
 
         case PIPE_ISOCHRONOUS:
                 if (urb->dev->speed == USB_SPEED_HIGH)
@@ -777,13 +784,18 @@ static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
  * completions normally happen asynchronously
  */
 
-static int ehci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
+static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         struct ehci_qh          *qh;
         unsigned long           flags;
+        int                     rc;
 
         spin_lock_irqsave (&ehci->lock, flags);
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
+                goto done;
+
         switch (usb_pipetype (urb->pipe)) {
         // case PIPE_CONTROL:
         // case PIPE_BULK:
@@ -838,7 +850,7 @@ static int ehci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
         }
 done:
         spin_unlock_irqrestore (&ehci->lock, flags);
-        return 0;
+        return rc;
 }
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index a7816e392a..ad0d4965f2 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -58,8 +58,6 @@ static int ehci_pci_reinit(struct ehci_hcd *ehci, struct pci_dev *pdev)
         if (!retval)
                 ehci_dbg(ehci, "MWI active\n");
 
-        ehci_port_power(ehci, 0);
-
         return 0;
 }
 
@@ -156,8 +154,7 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 break;
         }
 
-        if (ehci_is_TDI(ehci))
-                ehci_reset(ehci);
+        ehci_reset(ehci);
 
         /* at least the Genesys GL880S needs fixup here */
         temp = HCS_N_CC(ehci->hcs_params) * HCS_N_PCC(ehci->hcs_params);
diff --git a/drivers/usb/host/ehci-ppc-soc.c b/drivers/usb/host/ehci-ppc-soc.c
index 4f99b0eb27..452d4b1bc8 100644
--- a/drivers/usb/host/ehci-ppc-soc.c
+++ b/drivers/usb/host/ehci-ppc-soc.c
@@ -160,10 +160,8 @@ static const struct hc_driver ehci_ppc_soc_hc_driver = {
          */
         .hub_status_data = ehci_hub_status_data,
         .hub_control = ehci_hub_control,
-#ifdef  CONFIG_PM
-        .hub_suspend = ehci_hub_suspend,
-        .hub_resume = ehci_hub_resume,
-#endif
+        .bus_suspend = ehci_bus_suspend,
+        .bus_resume = ehci_bus_resume,
 };
 
 static int ehci_hcd_ppc_soc_drv_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 829fe649a9..03a6b2f4e6 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -47,7 +47,7 @@ static int ps3_ehci_hc_reset(struct usb_hcd *hcd)
         if (result)
                 return result;
 
-        ehci_port_power(ehci, 0);
+        ehci_reset(ehci);
 
         return result;
 }
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 140bfa423e..b10f39c047 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -139,63 +139,65 @@ qh_refresh (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
 /*-------------------------------------------------------------------------*/
 
-static void qtd_copy_status (
+static int qtd_copy_status (
         struct ehci_hcd *ehci,
         struct urb *urb,
         size_t length,
         u32 token
 )
 {
+        int     status = -EINPROGRESS;
+
         /* count IN/OUT bytes, not SETUP (even short packets) */
         if (likely (QTD_PID (token) != 2))
                 urb->actual_length += length - QTD_LENGTH (token);
 
         /* don't modify error codes */
-        if (unlikely (urb->status != -EINPROGRESS))
-                return;
+        if (unlikely(urb->unlinked))
+                return status;
 
         /* force cleanup after short read; not always an error */
         if (unlikely (IS_SHORT_READ (token)))
-                urb->status = -EREMOTEIO;
+                status = -EREMOTEIO;
 
         /* serious "can't proceed" faults reported by the hardware */
         if (token & QTD_STS_HALT) {
                 if (token & QTD_STS_BABBLE) {
                         /* FIXME "must" disable babbling device's port too */
-                        urb->status = -EOVERFLOW;
+                        status = -EOVERFLOW;
                 } else if (token & QTD_STS_MMF) {
                         /* fs/ls interrupt xfer missed the complete-split */
-                        urb->status = -EPROTO;
+                        status = -EPROTO;
                 } else if (token & QTD_STS_DBE) {
-                        urb->status = (QTD_PID (token) == 1) /* IN ? */
+                        status = (QTD_PID (token) == 1) /* IN ? */
                                 ? -ENOSR  /* hc couldn't read data */
                                 : -ECOMM; /* hc couldn't write data */
                 } else if (token & QTD_STS_XACT) {
                         /* timeout, bad crc, wrong PID, etc; retried */
                         if (QTD_CERR (token))
-                                urb->status = -EPIPE;
+                                status = -EPIPE;
                         else {
                                 ehci_dbg (ehci, "devpath %s ep%d%s 3strikes\n",
                                         urb->dev->devpath,
                                         usb_pipeendpoint (urb->pipe),
                                         usb_pipein (urb->pipe) ? "in" : "out");
-                                urb->status = -EPROTO;
+                                status = -EPROTO;
                         }
                 /* CERR nonzero + no errors + halt --> stall */
                 } else if (QTD_CERR (token))
-                        urb->status = -EPIPE;
+                        status = -EPIPE;
                 else    /* unknown */
-                        urb->status = -EPROTO;
+                        status = -EPROTO;
 
                 ehci_vdbg (ehci,
                         "dev%d ep%d%s qtd token %08x --> status %d\n",
                         usb_pipedevice (urb->pipe),
                         usb_pipeendpoint (urb->pipe),
                         usb_pipein (urb->pipe) ? "in" : "out",
-                        token, urb->status);
+                        token, status);
 
                 /* if async CSPLIT failed, try cleaning out the TT buffer */
-                if (urb->status != -EPIPE
+                if (status != -EPIPE
                                 && urb->dev->tt && !usb_pipeint (urb->pipe)
                                 && ((token & QTD_STS_MMF) != 0
                                         || QTD_CERR(token) == 0)
@@ -212,10 +214,12 @@ static void qtd_copy_status (
                         usb_hub_tt_clear_buffer (urb->dev, urb->pipe);
                 }
         }
+
+        return status;
 }
 
 static void
-ehci_urb_done (struct ehci_hcd *ehci, struct urb *urb)
+ehci_urb_done(struct ehci_hcd *ehci, struct urb *urb, int status)
 __releases(ehci->lock)
 __acquires(ehci->lock)
 {
@@ -231,25 +235,13 @@ __acquires(ehci->lock)
                 qh_put (qh);
         }
 
-        spin_lock (&urb->lock);
-        urb->hcpriv = NULL;
-        switch (urb->status) {
-        case -EINPROGRESS:              /* success */
-                urb->status = 0;
-        default:                        /* fault */
-                COUNT (ehci->stats.complete);
-                break;
-        case -EREMOTEIO:                /* fault or normal */
-                if (!(urb->transfer_flags & URB_SHORT_NOT_OK))
-                        urb->status = 0;
-                COUNT (ehci->stats.complete);
-                break;
-        case -ECONNRESET:               /* canceled */
-        case -ENOENT:
-                COUNT (ehci->stats.unlink);
-                break;
+        if (unlikely(urb->unlinked)) {
+                COUNT(ehci->stats.unlink);
+        } else {
+                if (likely(status == -EINPROGRESS))
+                        status = 0;
+                COUNT(ehci->stats.complete);
         }
-        spin_unlock (&urb->lock);
 
 #ifdef EHCI_URB_TRACE
         ehci_dbg (ehci,
@@ -257,13 +249,14 @@ __acquires(ehci->lock)
                 __FUNCTION__, urb->dev->devpath, urb,
                 usb_pipeendpoint (urb->pipe),
                 usb_pipein (urb->pipe) ? "in" : "out",
-                urb->status,
+                status,
                 urb->actual_length, urb->transfer_buffer_length);
 #endif
 
         /* complete() can reenter this HCD */
+        usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
         spin_unlock (&ehci->lock);
-        usb_hcd_giveback_urb (ehci_to_hcd(ehci), urb);
+        usb_hcd_giveback_urb(ehci_to_hcd(ehci), urb, status);
         spin_lock (&ehci->lock);
 }
 
@@ -283,6 +276,7 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
         struct ehci_qtd         *last = NULL, *end = qh->dummy;
         struct list_head        *entry, *tmp;
+        int                     last_status = -EINPROGRESS;
         int                     stopped;
         unsigned                count = 0;
         int                     do_status = 0;
@@ -311,6 +305,7 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 struct ehci_qtd *qtd;
                 struct urb      *urb;
                 u32             token = 0;
+                int             qtd_status;
 
                 qtd = list_entry (entry, struct ehci_qtd, qtd_list);
                 urb = qtd->urb;
@@ -318,11 +313,12 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 /* clean up any state from previous QTD ...*/
                 if (last) {
                         if (likely (last->urb != urb)) {
-                                ehci_urb_done (ehci, last->urb);
+                                ehci_urb_done(ehci, last->urb, last_status);
                                 count++;
                         }
                         ehci_qtd_free (ehci, last);
                         last = NULL;
+                        last_status = -EINPROGRESS;
                 }
 
                 /* ignore urbs submitted during completions we reported */
@@ -358,13 +354,14 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         stopped = 1;
 
                         if (unlikely (!HC_IS_RUNNING (ehci_to_hcd(ehci)->state)))
-                                urb->status = -ESHUTDOWN;
+                                last_status = -ESHUTDOWN;
 
                         /* ignore active urbs unless some previous qtd
                          * for the urb faulted (including short read) or
                          * its urb was canceled.  we may patch qh or qtds.
                          */
-                        if (likely (urb->status == -EINPROGRESS))
+                        if (likely(last_status == -EINPROGRESS &&
+                                        !urb->unlinked))
                                 continue;
 
                         /* issue status after short control reads */
@@ -392,11 +389,14 @@ halt:
                 }
 
                 /* remove it from the queue */
-                spin_lock (&urb->lock);
-                qtd_copy_status (ehci, urb, qtd->length, token);
-                do_status = (urb->status == -EREMOTEIO)
-                                && usb_pipecontrol (urb->pipe);
-                spin_unlock (&urb->lock);
+                qtd_status = qtd_copy_status(ehci, urb, qtd->length, token);
+                if (unlikely(qtd_status == -EREMOTEIO)) {
+                        do_status = (!urb->unlinked &&
+                                        usb_pipecontrol(urb->pipe));
+                        qtd_status = 0;
+                }
+                if (likely(last_status == -EINPROGRESS))
+                        last_status = qtd_status;
 
                 if (stopped && qtd->qtd_list.prev != &qh->qtd_list) {
                         last = list_entry (qtd->qtd_list.prev,
@@ -409,7 +409,7 @@ halt:
 
         /* last urb's completion might still need calling */
         if (likely (last != NULL)) {
-                ehci_urb_done (ehci, last->urb);
+                ehci_urb_done(ehci, last->urb, last_status);
                 count++;
                 ehci_qtd_free (ehci, last);
         }
@@ -913,7 +913,6 @@ static struct ehci_qh *qh_append_tds (
 static int
 submit_async (
         struct ehci_hcd         *ehci,
-        struct usb_host_endpoint *ep,
         struct urb              *urb,
         struct list_head        *qtd_list,
         gfp_t                   mem_flags
@@ -922,10 +921,10 @@ submit_async (
         int                     epnum;
         unsigned long           flags;
         struct ehci_qh          *qh = NULL;
-        int                     rc = 0;
+        int                     rc;
 
         qtd = list_entry (qtd_list->next, struct ehci_qtd, qtd_list);
-        epnum = ep->desc.bEndpointAddress;
+        epnum = urb->ep->desc.bEndpointAddress;
 
 #ifdef EHCI_URB_TRACE
         ehci_dbg (ehci,
@@ -933,7 +932,7 @@ submit_async (
                 __FUNCTION__, urb->dev->devpath, urb,
                 epnum & 0x0f, (epnum & USB_DIR_IN) ? "in" : "out",
                 urb->transfer_buffer_length,
-                qtd, ep->hcpriv);
+                qtd, urb->ep->hcpriv);
 #endif
 
         spin_lock_irqsave (&ehci->lock, flags);
@@ -942,9 +941,13 @@ submit_async (
                 rc = -ESHUTDOWN;
                 goto done;
         }
+        rc = usb_hcd_link_urb_to_ep(ehci_to_hcd(ehci), urb);
+        if (unlikely(rc))
+                goto done;
 
-        qh = qh_append_tds (ehci, urb, qtd_list, epnum, &ep->hcpriv);
+        qh = qh_append_tds(ehci, urb, qtd_list, epnum, &urb->ep->hcpriv);
         if (unlikely(qh == NULL)) {
+                usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
                 rc = -ENOMEM;
                 goto done;
         }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index e682f2342e..80d99bce2b 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -797,7 +797,6 @@ done:
 
 static int intr_submit (
         struct ehci_hcd         *ehci,
-        struct usb_host_endpoint *ep,
         struct urb              *urb,
         struct list_head        *qtd_list,
         gfp_t                   mem_flags
@@ -805,23 +804,26 @@ static int intr_submit (
         unsigned                epnum;
         unsigned long           flags;
         struct ehci_qh          *qh;
-        int                     status = 0;
+        int                     status;
         struct list_head        empty;
 
         /* get endpoint and transfer/schedule data */
-        epnum = ep->desc.bEndpointAddress;
+        epnum = urb->ep->desc.bEndpointAddress;
 
         spin_lock_irqsave (&ehci->lock, flags);
 
         if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE,
                         &ehci_to_hcd(ehci)->flags))) {
                 status = -ESHUTDOWN;
-                goto done;
+                goto done_not_linked;
         }
+        status = usb_hcd_link_urb_to_ep(ehci_to_hcd(ehci), urb);
+        if (unlikely(status))
+                goto done_not_linked;
 
         /* get qh and force any scheduling errors */
         INIT_LIST_HEAD (&empty);
-        qh = qh_append_tds (ehci, urb, &empty, epnum, &ep->hcpriv);
+        qh = qh_append_tds(ehci, urb, &empty, epnum, &urb->ep->hcpriv);
         if (qh == NULL) {
                 status = -ENOMEM;
                 goto done;
@@ -832,13 +834,16 @@ static int intr_submit (
         }
 
         /* then queue the urb's tds to the qh */
-        qh = qh_append_tds (ehci, urb, qtd_list, epnum, &ep->hcpriv);
+        qh = qh_append_tds(ehci, urb, qtd_list, epnum, &urb->ep->hcpriv);
         BUG_ON (qh == NULL);
 
         /* ... update usbfs periodic stats */
         ehci_to_hcd(ehci)->self.bandwidth_int_reqs++;
 
 done:
+        if (unlikely(status))
+                usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
         if (status)
                 qtd_list_free (ehci, urb, qtd_list);
@@ -1622,7 +1627,7 @@ itd_complete (
 
         /* give urb back to the driver ... can be out-of-order */
         dev = urb->dev;
-        ehci_urb_done (ehci, urb);
+        ehci_urb_done(ehci, urb, 0);
         urb = NULL;
 
         /* defer stopping schedule; completion can submit */
@@ -1686,12 +1691,19 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
         /* schedule ... need to lock */
         spin_lock_irqsave (&ehci->lock, flags);
         if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE,
-                               &ehci_to_hcd(ehci)->flags)))
+                               &ehci_to_hcd(ehci)->flags))) {
                 status = -ESHUTDOWN;
-        else
-                status = iso_stream_schedule (ehci, urb, stream);
+                goto done_not_linked;
+        }
+        status = usb_hcd_link_urb_to_ep(ehci_to_hcd(ehci), urb);
+        if (unlikely(status))
+                goto done_not_linked;
+        status = iso_stream_schedule(ehci, urb, stream);
         if (likely (status == 0))
                 itd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
+        else
+                usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
 
 done:
@@ -1988,7 +2000,7 @@ sitd_complete (
 
         /* give urb back to the driver */
         dev = urb->dev;
-        ehci_urb_done (ehci, urb);
+        ehci_urb_done(ehci, urb, 0);
         urb = NULL;
 
         /* defer stopping schedule; completion can submit */
@@ -2049,12 +2061,19 @@ static int sitd_submit (struct ehci_hcd *ehci, struct urb *urb,
         /* schedule ... need to lock */
         spin_lock_irqsave (&ehci->lock, flags);
         if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE,
-                               &ehci_to_hcd(ehci)->flags)))
+                               &ehci_to_hcd(ehci)->flags))) {
                 status = -ESHUTDOWN;
-        else
-                status = iso_stream_schedule (ehci, urb, stream);
+                goto done_not_linked;
+        }
+        status = usb_hcd_link_urb_to_ep(ehci_to_hcd(ehci), urb);
+        if (unlikely(status))
+                goto done_not_linked;
+        status = iso_stream_schedule(ehci, urb, stream);
         if (status == 0)
                 sitd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
+        else
+                usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
 
 done:
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 5c851a36de..c27417f5b9 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -277,12 +277,11 @@ static void preproc_atl_queue(struct isp116x *isp116x)
   processed urbs.
 */
 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
-                           struct urb *urb)
+                           struct urb *urb, int status)
 __releases(isp116x->lock) __acquires(isp116x->lock)
 {
         unsigned i;
 
-        urb->hcpriv = NULL;
         ep->error_count = 0;
 
         if (usb_pipecontrol(urb->pipe))
@@ -290,8 +289,9 @@ __releases(isp116x->lock) __acquires(isp116x->lock)
 
         urb_dbg(urb, "Finish");
 
+        usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
         spin_unlock(&isp116x->lock);
-        usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb);
+        usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
         spin_lock(&isp116x->lock);
 
         /* take idle endpoints out of the schedule */
@@ -445,12 +445,7 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                         if (PTD_GET_ACTIVE(ptd)
                             || (cc != TD_CC_NOERROR && cc < 0x0E))
                                 break;
-                        if ((urb->transfer_flags & URB_SHORT_NOT_OK) &&
-                                        urb->actual_length <
-                                                urb->transfer_buffer_length)
-                                status = -EREMOTEIO;
-                        else
-                                status = 0;
+                        status = 0;
                         ep->nextpid = 0;
                         break;
                 default:
@@ -458,14 +453,8 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                 }
 
  done:
-                if (status != -EINPROGRESS) {
-                        spin_lock(&urb->lock);
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = status;
-                        spin_unlock(&urb->lock);
-                }
-                if (urb->status != -EINPROGRESS)
-                        finish_request(isp116x, ep, urb);
+                if (status != -EINPROGRESS || urb->unlinked)
+                        finish_request(isp116x, ep, urb, status);
         }
 }
 
@@ -673,7 +662,7 @@ static int balance(struct isp116x *isp116x, u16 period, u16 load)
 /*-----------------------------------------------------------------*/
 
 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
-                               struct usb_host_endpoint *hep, struct urb *urb,
+                               struct urb *urb,
                                gfp_t mem_flags)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
@@ -682,6 +671,7 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
         int is_out = !usb_pipein(pipe);
         int type = usb_pipetype(pipe);
         int epnum = usb_pipeendpoint(pipe);
+        struct usb_host_endpoint *hep = urb->ep;
         struct isp116x_ep *ep = NULL;
         unsigned long flags;
         int i;
@@ -705,7 +695,12 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
         if (!HC_IS_RUNNING(hcd->state)) {
                 kfree(ep);
                 ret = -ENODEV;
-                goto fail;
+                goto fail_not_linked;
+        }
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret) {
+                kfree(ep);
+                goto fail_not_linked;
         }
 
         if (hep->hcpriv)
@@ -808,16 +803,13 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
                 }
         }
 
-        /* in case of unlink-during-submit */
-        if (urb->status != -EINPROGRESS) {
-                finish_request(isp116x, ep, urb);
-                ret = 0;
-                goto fail;
-        }
         urb->hcpriv = hep;
         start_atl_transfers(isp116x);
 
       fail:
+        if (ret)
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+      fail_not_linked:
         spin_unlock_irqrestore(&isp116x->lock, flags);
         return ret;
 }
@@ -825,20 +817,21 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
 /*
    Dequeue URBs.
 */
-static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+                int status)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
         struct usb_host_endpoint *hep;
         struct isp116x_ep *ep, *ep_act;
         unsigned long flags;
+        int rc;
 
         spin_lock_irqsave(&isp116x->lock, flags);
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
+                goto done;
+
         hep = urb->hcpriv;
-        /* URB already unlinked (or never linked)? */
-        if (!hep) {
-                spin_unlock_irqrestore(&isp116x->lock, flags);
-                return 0;
-        }
         ep = hep->hcpriv;
         WARN_ON(hep != ep->hep);
 
@@ -855,10 +848,10 @@ static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
                         }
 
         if (urb)
-                finish_request(isp116x, ep, urb);
-
+                finish_request(isp116x, ep, urb, status);
+ done:
         spin_unlock_irqrestore(&isp116x->lock, flags);
-        return 0;
+        return rc;
 }
 
 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index f61c6cdd06..ebab5ce8f5 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -24,7 +24,7 @@
  * small: 0) header + data packets 1) just header
  */
 static void __maybe_unused
-urb_print (struct urb * urb, char * str, int small)
+urb_print(struct urb * urb, char * str, int small, int status)
 {
         unsigned int pipe= urb->pipe;
 
@@ -34,7 +34,7 @@ urb_print (struct urb * urb, char * str, int small)
         }
 
 #ifndef OHCI_VERBOSE_DEBUG
-        if (urb->status != 0)
+        if (status != 0)
 #endif
         dbg("%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d",
                     str,
@@ -46,7 +46,7 @@ urb_print (struct urb * urb, char * str, int small)
                     urb->transfer_flags,
                     urb->actual_length,
                     urb->transfer_buffer_length,
-                    urb->status);
+                    status);
 
 #ifdef  OHCI_VERBOSE_DEBUG
         if (!small) {
@@ -66,7 +66,7 @@ urb_print (struct urb * urb, char * str, int small)
                                                 urb->transfer_buffer_length: urb->actual_length;
                         for (i = 0; i < 16 && i < len; i++)
                                 printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
-                        printk ("%s stat:%d\n", i < len? "...": "", urb->status);
+                        printk ("%s stat:%d\n", i < len? "...": "", status);
                 }
         }
 #endif
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 6edf4097d2..240c7f5075 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -81,7 +81,6 @@ static void ohci_dump (struct ohci_hcd *ohci, int verbose);
 static int ohci_init (struct ohci_hcd *ohci);
 static void ohci_stop (struct usb_hcd *hcd);
 static int ohci_restart (struct ohci_hcd *ohci);
-static void ohci_quirk_nec_worker (struct work_struct *work);
 
 #include "ohci-hub.c"
 #include "ohci-dbg.c"
@@ -118,7 +117,6 @@ MODULE_PARM_DESC (no_handshake, "true (not default) disables BIOS handshake");
  */
 static int ohci_urb_enqueue (
         struct usb_hcd  *hcd,
-        struct usb_host_endpoint *ep,
         struct urb      *urb,
         gfp_t           mem_flags
 ) {
@@ -131,11 +129,11 @@ static int ohci_urb_enqueue (
         int             retval = 0;
 
 #ifdef OHCI_VERBOSE_DEBUG
-        urb_print (urb, "SUB", usb_pipein (pipe));
+        urb_print(urb, "SUB", usb_pipein(pipe), -EINPROGRESS);
 #endif
 
         /* every endpoint has a ed, locate and maybe (re)initialize it */
-        if (! (ed = ed_get (ohci, ep, urb->dev, pipe, urb->interval)))
+        if (! (ed = ed_get (ohci, urb->ep, urb->dev, pipe, urb->interval)))
                 return -ENOMEM;
 
         /* for the private part of the URB we need the number of TDs (size) */
@@ -200,22 +198,17 @@ static int ohci_urb_enqueue (
                 retval = -ENODEV;
                 goto fail;
         }
-
-        /* in case of unlink-during-submit */
-        spin_lock (&urb->lock);
-        if (urb->status != -EINPROGRESS) {
-                spin_unlock (&urb->lock);
-                urb->hcpriv = urb_priv;
-                finish_urb (ohci, urb);
-                retval = 0;
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval)
                 goto fail;
-        }
 
         /* schedule the ed if needed */
         if (ed->state == ED_IDLE) {
                 retval = ed_schedule (ohci, ed);
-                if (retval < 0)
-                        goto fail0;
+                if (retval < 0) {
+                        usb_hcd_unlink_urb_from_ep(hcd, urb);
+                        goto fail;
+                }
                 if (ed->type == PIPE_ISOCHRONOUS) {
                         u16     frame = ohci_frame_no(ohci);
 
@@ -239,8 +232,6 @@ static int ohci_urb_enqueue (
         urb->hcpriv = urb_priv;
         td_submit_urb (ohci, urb);
 
-fail0:
-        spin_unlock (&urb->lock);
 fail:
         if (retval)
                 urb_free_priv (ohci, urb_priv);
@@ -249,22 +240,26 @@ fail:
 }
 
 /*
- * decouple the URB from the HC queues (TDs, urb_priv); it's
- * already marked using urb->status.  reporting is always done
+ * decouple the URB from the HC queues (TDs, urb_priv).
+ * reporting is always done
  * asynchronously, and we might be dealing with an urb that's
  * partially transferred, or an ED with other urbs being unlinked.
  */
-static int ohci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
+static int ohci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
         unsigned long           flags;
+        int                     rc;
 
 #ifdef OHCI_VERBOSE_DEBUG
-        urb_print (urb, "UNLINK", 1);
+        urb_print(urb, "UNLINK", 1, status);
 #endif
 
         spin_lock_irqsave (&ohci->lock, flags);
-        if (HC_IS_RUNNING(hcd->state)) {
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc) {
+                ;       /* Do nothing */
+        } else if (HC_IS_RUNNING(hcd->state)) {
                 urb_priv_t  *urb_priv;
 
                 /* Unless an IRQ completed the unlink while it was being
@@ -282,10 +277,10 @@ static int ohci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
                  * any more ... just clean up every urb's memory.
                  */
                 if (urb->hcpriv)
-                        finish_urb (ohci, urb);
+                        finish_urb(ohci, urb, status);
         }
         spin_unlock_irqrestore (&ohci->lock, flags);
-        return 0;
+        return rc;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -314,6 +309,8 @@ rescan:
         if (!HC_IS_RUNNING (hcd->state)) {
 sanitize:
                 ed->state = ED_IDLE;
+                if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT)
+                        ohci->eds_scheduled--;
                 finish_unlinks (ohci, 0);
         }
 
@@ -321,7 +318,12 @@ sanitize:
         case ED_UNLINK:         /* wait for hw to finish? */
                 /* major IRQ delivery trouble loses INTR_SF too... */
                 if (limit-- == 0) {
-                        ohci_warn (ohci, "IRQ INTR_SF lossage\n");
+                        ohci_warn(ohci, "ED unlink timeout\n");
+                        if (quirk_zfmicro(ohci)) {
+                                ohci_warn(ohci, "Attempting ZF TD recovery\n");
+                                ohci->ed_to_check = ed;
+                                ohci->zf_delay = 2;
+                        }
                         goto sanitize;
                 }
                 spin_unlock_irqrestore (&ohci->lock, flags);
@@ -379,6 +381,93 @@ ohci_shutdown (struct usb_hcd *hcd)
         (void) ohci_readl (ohci, &ohci->regs->control);
 }
 
+static int check_ed(struct ohci_hcd *ohci, struct ed *ed)
+{
+        return (hc32_to_cpu(ohci, ed->hwINFO) & ED_IN) != 0
+                && (hc32_to_cpu(ohci, ed->hwHeadP) & TD_MASK)
+                        == (hc32_to_cpu(ohci, ed->hwTailP) & TD_MASK)
+                && !list_empty(&ed->td_list);
+}
+
+/* ZF Micro watchdog timer callback. The ZF Micro chipset sometimes completes
+ * an interrupt TD but neglects to add it to the donelist.  On systems with
+ * this chipset, we need to periodically check the state of the queues to look
+ * for such "lost" TDs.
+ */
+static void unlink_watchdog_func(unsigned long _ohci)
+{
+        long            flags;
+        unsigned        max;
+        unsigned        seen_count = 0;
+        unsigned        i;
+        struct ed       **seen = NULL;
+        struct ohci_hcd *ohci = (struct ohci_hcd *) _ohci;
+
+        spin_lock_irqsave(&ohci->lock, flags);
+        max = ohci->eds_scheduled;
+        if (!max)
+                goto done;
+
+        if (ohci->ed_to_check)
+                goto out;
+
+        seen = kcalloc(max, sizeof *seen, GFP_ATOMIC);
+        if (!seen)
+                goto out;
+
+        for (i = 0; i < NUM_INTS; i++) {
+                struct ed       *ed = ohci->periodic[i];
+
+                while (ed) {
+                        unsigned        temp;
+
+                        /* scan this branch of the periodic schedule tree */
+                        for (temp = 0; temp < seen_count; temp++) {
+                                if (seen[temp] == ed) {
+                                        /* we've checked it and what's after */
+                                        ed = NULL;
+                                        break;
+                                }
+                        }
+                        if (!ed)
+                                break;
+                        seen[seen_count++] = ed;
+                        if (!check_ed(ohci, ed)) {
+                                ed = ed->ed_next;
+                                continue;
+                        }
+
+                        /* HC's TD list is empty, but HCD sees at least one
+                         * TD that's not been sent through the donelist.
+                         */
+                        ohci->ed_to_check = ed;
+                        ohci->zf_delay = 2;
+
+                        /* The HC may wait until the next frame to report the
+                         * TD as done through the donelist and INTR_WDH.  (We
+                         * just *assume* it's not a multi-TD interrupt URB;
+                         * those could defer the IRQ more than one frame, using
+                         * DI...)  Check again after the next INTR_SF.
+                         */
+                        ohci_writel(ohci, OHCI_INTR_SF,
+                                        &ohci->regs->intrstatus);
+                        ohci_writel(ohci, OHCI_INTR_SF,
+                                        &ohci->regs->intrenable);
+
+                        /* flush those writes */
+                        (void) ohci_readl(ohci, &ohci->regs->control);
+
+                        goto out;
+                }
+        }
+out:
+        kfree(seen);
+        if (ohci->eds_scheduled)
+                mod_timer(&ohci->unlink_watchdog, round_jiffies_relative(HZ));
+done:
+        spin_unlock_irqrestore(&ohci->lock, flags);
+}
+
 /*-------------------------------------------------------------------------*
  * HC functions
  *-------------------------------------------------------------------------*/
@@ -616,6 +705,15 @@ retry:
         mdelay ((temp >> 23) & 0x1fe);
         hcd->state = HC_STATE_RUNNING;
 
+        if (quirk_zfmicro(ohci)) {
+                /* Create timer to watch for bad queue state on ZF Micro */
+                setup_timer(&ohci->unlink_watchdog, unlink_watchdog_func,
+                                (unsigned long) ohci);
+
+                ohci->eds_scheduled = 0;
+                ohci->ed_to_check = NULL;
+        }
+
         ohci_dump (ohci, 1);
 
         return 0;
@@ -629,10 +727,11 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
 {
         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
         struct ohci_regs __iomem *regs = ohci->regs;
-        int                     ints; 
+        int                     ints;
 
         /* we can eliminate a (slow) ohci_readl()
-           if _only_ WDH caused this irq */
+         * if _only_ WDH caused this irq
+         */
         if ((ohci->hcca->done_head != 0)
                         && ! (hc32_to_cpup (ohci, &ohci->hcca->done_head)
                                 & 0x01)) {
@@ -651,7 +750,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
 
         if (ints & OHCI_INTR_UE) {
                 // e.g. due to PCI Master/Target Abort
-                if (ohci->flags & OHCI_QUIRK_NEC) {
+                if (quirk_nec(ohci)) {
                         /* Workaround for a silicon bug in some NEC chips used
                          * in Apple's PowerBooks. Adapted from Darwin code.
                          */
@@ -713,6 +812,31 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
                         ohci_writel (ohci, OHCI_INTR_WDH, &regs->intrenable);
         }
 
+        if (quirk_zfmicro(ohci) && (ints & OHCI_INTR_SF)) {
+                spin_lock(&ohci->lock);
+                if (ohci->ed_to_check) {
+                        struct ed *ed = ohci->ed_to_check;
+
+                        if (check_ed(ohci, ed)) {
+                                /* HC thinks the TD list is empty; HCD knows
+                                 * at least one TD is outstanding
+                                 */
+                                if (--ohci->zf_delay == 0) {
+                                        struct td *td = list_entry(
+                                                ed->td_list.next,
+                                                struct td, td_list);
+                                        ohci_warn(ohci,
+                                                  "Reclaiming orphan TD %p\n",
+                                                  td);
+                                        takeback_td(ohci, td);
+                                        ohci->ed_to_check = NULL;
+                                }
+                        } else
+                                ohci->ed_to_check = NULL;
+                }
+                spin_unlock(&ohci->lock);
+        }
+
         /* could track INTR_SO to reduce available PCI/... bandwidth */
 
         /* handle any pending URB/ED unlinks, leaving INTR_SF enabled
@@ -721,7 +845,9 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         spin_lock (&ohci->lock);
         if (ohci->ed_rm_list)
                 finish_unlinks (ohci, ohci_frame_no(ohci));
-        if ((ints & OHCI_INTR_SF) != 0 && !ohci->ed_rm_list
+        if ((ints & OHCI_INTR_SF) != 0
+                        && !ohci->ed_rm_list
+                        && !ohci->ed_to_check
                         && HC_IS_RUNNING(hcd->state))
                 ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable);
         spin_unlock (&ohci->lock);
@@ -751,6 +877,9 @@ static void ohci_stop (struct usb_hcd *hcd)
         free_irq(hcd->irq, hcd);
         hcd->irq = -1;
 
+        if (quirk_zfmicro(ohci))
+                del_timer(&ohci->unlink_watchdog);
+
         remove_debug_files (ohci);
         ohci_mem_cleanup (ohci);
         if (ohci->hcca) {
@@ -798,9 +927,8 @@ static int ohci_restart (struct ohci_hcd *ohci)
                                         ed, ed->state);
                 }
 
-                spin_lock (&urb->lock);
-                urb->status = -ESHUTDOWN;
-                spin_unlock (&urb->lock);
+                if (!urb->unlinked)
+                        urb->unlinked = -ESHUTDOWN;
         }
         finish_unlinks (ohci, 0);
         spin_unlock_irq(&ohci->lock);
@@ -828,27 +956,6 @@ static int ohci_restart (struct ohci_hcd *ohci)
 
 /*-------------------------------------------------------------------------*/
 
-/* NEC workaround */
-static void ohci_quirk_nec_worker(struct work_struct *work)
-{
-        struct ohci_hcd *ohci = container_of(work, struct ohci_hcd, nec_work);
-        int status;
-
-        status = ohci_init(ohci);
-        if (status != 0) {
-                ohci_err(ohci, "Restarting NEC controller failed "
-                         "in ohci_init, %d\n", status);
-                return;
-        }
-
-        status = ohci_restart(ohci);
-        if (status != 0)
-                ohci_err(ohci, "Restarting NEC controller failed "
-                         "in ohci_restart, %d\n", status);
-}
-
-/*-------------------------------------------------------------------------*/
-
 #define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
 
 MODULE_AUTHOR (DRIVER_AUTHOR);
@@ -926,11 +1033,17 @@ MODULE_LICENSE ("GPL");
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
 #endif
 
+#ifdef CONFIG_USB_OHCI_HCD_SSB
+#include "ohci-ssb.c"
+#define SSB_OHCI_DRIVER         ssb_ohci_driver
+#endif
+
 #if     !defined(PCI_DRIVER) &&         \
         !defined(PLATFORM_DRIVER) &&    \
         !defined(OF_PLATFORM_DRIVER) && \
         !defined(SA1111_DRIVER) &&      \
-        !defined(PS3_SYSTEM_BUS_DRIVER)
+        !defined(PS3_SYSTEM_BUS_DRIVER) && \
+        !defined(SSB_OHCI_DRIVER)
 #error "missing bus glue for ohci-hcd"
 #endif
 
@@ -975,10 +1088,20 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_pci;
 #endif
 
+#ifdef SSB_OHCI_DRIVER
+        retval = ssb_driver_register(&SSB_OHCI_DRIVER);
+        if (retval)
+                goto error_ssb;
+#endif
+
         return retval;
 
         /* Error path */
+#ifdef SSB_OHCI_DRIVER
+ error_ssb:
+#endif
 #ifdef PCI_DRIVER
+        pci_unregister_driver(&PCI_DRIVER);
  error_pci:
 #endif
 #ifdef SA1111_DRIVER
@@ -1003,6 +1126,9 @@ module_init(ohci_hcd_mod_init);
 
 static void __exit ohci_hcd_mod_exit(void)
 {
+#ifdef SSB_OHCI_DRIVER
+        ssb_driver_unregister(&SSB_OHCI_DRIVER);
+#endif
 #ifdef PCI_DRIVER
         pci_unregister_driver(&PCI_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-mem.c b/drivers/usb/host/ohci-mem.c
index 450c7b460c..2f20d3dc89 100644
--- a/drivers/usb/host/ohci-mem.c
+++ b/drivers/usb/host/ohci-mem.c
@@ -28,7 +28,6 @@ static void ohci_hcd_init (struct ohci_hcd *ohci)
         ohci->next_statechange = jiffies;
         spin_lock_init (&ohci->lock);
         INIT_LIST_HEAD (&ohci->pending);
-        INIT_WORK (&ohci->nec_work, ohci_quirk_nec_worker);
 }
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index a5e2eb85d0..d0360f65eb 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -84,7 +84,7 @@ static int ohci_quirk_zfmicro(struct usb_hcd *hcd)
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
 
         ohci->flags |= OHCI_QUIRK_ZFMICRO;
-        ohci_dbg (ohci, "enabled Compaq ZFMicro chipset quirk\n");
+        ohci_dbg(ohci, "enabled Compaq ZFMicro chipset quirks\n");
 
         return 0;
 }
@@ -113,11 +113,31 @@ static int ohci_quirk_toshiba_scc(struct usb_hcd *hcd)
 
 /* Check for NEC chip and apply quirk for allegedly lost interrupts.
  */
+
+static void ohci_quirk_nec_worker(struct work_struct *work)
+{
+        struct ohci_hcd *ohci = container_of(work, struct ohci_hcd, nec_work);
+        int status;
+
+        status = ohci_init(ohci);
+        if (status != 0) {
+                ohci_err(ohci, "Restarting NEC controller failed in %s, %d\n",
+                         "ohci_init", status);
+                return;
+        }
+
+        status = ohci_restart(ohci);
+        if (status != 0)
+                ohci_err(ohci, "Restarting NEC controller failed in %s, %d\n",
+                         "ohci_restart", status);
+}
+
 static int ohci_quirk_nec(struct usb_hcd *hcd)
 {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
 
         ohci->flags |= OHCI_QUIRK_NEC;
+        INIT_WORK(&ohci->nec_work, ohci_quirk_nec_worker);
         ohci_dbg (ohci, "enabled NEC chipset lost interrupt quirk\n");
 
         return 0;
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index c43b66acd4..0a74269201 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -134,8 +134,11 @@ ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
         }
 
         ohci = hcd_to_ohci(hcd);
-        if (is_bigendian)
+        if (is_bigendian) {
                 ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;
+                if (of_device_is_compatible(dn, "mpc5200-ohci"))
+                        ohci->flags |= OHCI_QUIRK_FRAME_NO;
+        }
 
         ohci_hcd_init(ohci);
 
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 1a2e1777ca..f95be1896b 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -73,6 +73,11 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
 
         ohci = hcd_to_ohci(hcd);
         ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;
+
+#ifdef CONFIG_PPC_MPC52xx
+        /* MPC52xx doesn't need frame_no shift */
+        ohci->flags |= OHCI_QUIRK_FRAME_NO;
+#endif
         ohci_hcd_init(ohci);
 
         retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 830a3fe861..5181732223 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -36,29 +36,15 @@ static void urb_free_priv (struct ohci_hcd *hc, urb_priv_t *urb_priv)
  * PRECONDITION:  ohci lock held, irqs blocked.
  */
 static void
-finish_urb (struct ohci_hcd *ohci, struct urb *urb)
+finish_urb(struct ohci_hcd *ohci, struct urb *urb, int status)
 __releases(ohci->lock)
 __acquires(ohci->lock)
 {
         // ASSERT (urb->hcpriv != 0);
 
         urb_free_priv (ohci, urb->hcpriv);
-        urb->hcpriv = NULL;
-
-        spin_lock (&urb->lock);
-        if (likely (urb->status == -EINPROGRESS))
-                urb->status = 0;
-        /* report short control reads right even though the data TD always
-         * has TD_R set.  (much simpler, but creates the 1-td limit.)
-         */
-        if (unlikely (urb->transfer_flags & URB_SHORT_NOT_OK)
-                        && unlikely (usb_pipecontrol (urb->pipe))
-                        && urb->actual_length < urb->transfer_buffer_length
-                        && usb_pipein (urb->pipe)
-                        && urb->status == 0) {
-                urb->status = -EREMOTEIO;
-        }
-        spin_unlock (&urb->lock);
+        if (likely(status == -EINPROGRESS))
+                status = 0;
 
         switch (usb_pipetype (urb->pipe)) {
         case PIPE_ISOCHRONOUS:
@@ -70,12 +56,13 @@ __acquires(ohci->lock)
         }
 
 #ifdef OHCI_VERBOSE_DEBUG
-        urb_print (urb, "RET", usb_pipeout (urb->pipe));
+        urb_print(urb, "RET", usb_pipeout (urb->pipe), status);
 #endif
 
         /* urb->complete() can reenter this HCD */
+        usb_hcd_unlink_urb_from_ep(ohci_to_hcd(ohci), urb);
         spin_unlock (&ohci->lock);
-        usb_hcd_giveback_urb (ohci_to_hcd(ohci), urb);
+        usb_hcd_giveback_urb(ohci_to_hcd(ohci), urb, status);
         spin_lock (&ohci->lock);
 
         /* stop periodic dma if it's not needed */
@@ -179,6 +166,10 @@ static int ed_schedule (struct ohci_hcd *ohci, struct ed *ed)
         ed->ed_prev = NULL;
         ed->ed_next = NULL;
         ed->hwNextED = 0;
+        if (quirk_zfmicro(ohci)
+                        && (ed->type == PIPE_INTERRUPT)
+                        && !(ohci->eds_scheduled++))
+                mod_timer(&ohci->unlink_watchdog, round_jiffies_relative(HZ));
         wmb ();
 
         /* we care about rm_list when setting CLE/BLE in case the HC was at
@@ -708,19 +699,18 @@ static void td_submit_urb (
  * Done List handling functions
  *-------------------------------------------------------------------------*/
 
-/* calculate transfer length/status and update the urb
- * PRECONDITION:  irqsafe (only for urb->status locking)
- */
-static void td_done (struct ohci_hcd *ohci, struct urb *urb, struct td *td)
+/* calculate transfer length/status and update the urb */
+static int td_done(struct ohci_hcd *ohci, struct urb *urb, struct td *td)
 {
         u32     tdINFO = hc32_to_cpup (ohci, &td->hwINFO);
         int     cc = 0;
+        int     status = -EINPROGRESS;
 
         list_del (&td->td_list);
 
         /* ISO ... drivers see per-TD length/status */
         if (tdINFO & TD_ISO) {
-                u16     tdPSW = ohci_hwPSW (ohci, td, 0);
+                u16     tdPSW = ohci_hwPSW(ohci, td, 0);
                 int     dlen = 0;
 
                 /* NOTE:  assumes FC in tdINFO == 0, and that
@@ -729,7 +719,7 @@ static void td_done (struct ohci_hcd *ohci, struct urb *urb, struct td *td)
 
                 cc = (tdPSW >> 12) & 0xF;
                 if (tdINFO & TD_CC)     /* hc didn't touch? */
-                        return;
+                        return status;
 
                 if (usb_pipeout (urb->pipe))
                         dlen = urb->iso_frame_desc [td->index].length;
@@ -762,12 +752,8 @@ static void td_done (struct ohci_hcd *ohci, struct urb *urb, struct td *td)
                 if (cc == TD_DATAUNDERRUN
                                 && !(urb->transfer_flags & URB_SHORT_NOT_OK))
                         cc = TD_CC_NOERROR;
-                if (cc != TD_CC_NOERROR && cc < 0x0E) {
-                        spin_lock (&urb->lock);
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = cc_to_error [cc];
-                        spin_unlock (&urb->lock);
-                }
+                if (cc != TD_CC_NOERROR && cc < 0x0E)
+                        status = cc_to_error[cc];
 
                 /* count all non-empty packets except control SETUP packet */
                 if ((type != PIPE_CONTROL || td->index != 0) && tdBE != 0) {
@@ -786,14 +772,15 @@ static void td_done (struct ohci_hcd *ohci, struct urb *urb, struct td *td)
                                 urb->actual_length,
                                 urb->transfer_buffer_length);
         }
+        return status;
 }
 
 /*-------------------------------------------------------------------------*/
 
-static inline struct td *
-ed_halted (struct ohci_hcd *ohci, struct td *td, int cc, struct td *rev)
+static void ed_halted(struct ohci_hcd *ohci, struct td *td, int cc)
 {
         struct urb              *urb = td->urb;
+        urb_priv_t              *urb_priv = urb->hcpriv;
         struct ed               *ed = td->ed;
         struct list_head        *tmp = td->td_list.next;
         __hc32                  toggle = ed->hwHeadP & cpu_to_hc32 (ohci, ED_C);
@@ -805,13 +792,12 @@ ed_halted (struct ohci_hcd *ohci, struct td *td, int cc, struct td *rev)
         wmb ();
         ed->hwHeadP &= ~cpu_to_hc32 (ohci, ED_H);
 
-        /* put any later tds from this urb onto the donelist, after 'td',
-         * order won't matter here: no errors, and nothing was transferred.
-         * also patch the ed so it looks as if those tds completed normally.
+        /* Get rid of all later tds from this urb.  We don't have
+         * to be careful: no errors and nothing was transferred.
+         * Also patch the ed so it looks as if those tds completed normally.
          */
         while (tmp != &ed->td_list) {
                 struct td       *next;
-                __hc32          info;
 
                 next = list_entry (tmp, struct td, td_list);
                 tmp = next->td_list.next;
@@ -826,14 +812,9 @@ ed_halted (struct ohci_hcd *ohci, struct td *td, int cc, struct td *rev)
                  * then we need to leave the control STATUS packet queued
                  * and clear ED_SKIP.
                  */
-                info = next->hwINFO;
-                info |= cpu_to_hc32 (ohci, TD_DONE);
-                info &= ~cpu_to_hc32 (ohci, TD_CC);
-                next->hwINFO = info;
-
-                next->next_dl_td = rev;
-                rev = next;
 
+                list_del(&next->td_list);
+                urb_priv->td_cnt++;
                 ed->hwHeadP = next->hwNextTD | toggle;
         }
 
@@ -859,8 +840,6 @@ ed_halted (struct ohci_hcd *ohci, struct td *td, int cc, struct td *rev)
                         hc32_to_cpu (ohci, td->hwINFO),
                         cc, cc_to_error [cc]);
         }
-
-        return rev;
 }
 
 /* replies to the request have to be on a FIFO basis so
@@ -897,7 +876,7 @@ static struct td *dl_reverse_done_list (struct ohci_hcd *ohci)
                  */
                 if (cc != TD_CC_NOERROR
                                 && (td->ed->hwHeadP & cpu_to_hc32 (ohci, ED_H)))
-                        td_rev = ed_halted (ohci, td, cc, td_rev);
+                        ed_halted(ohci, td, cc);
 
                 td->next_dl_td = td_rev;
                 td_rev = td;
@@ -940,8 +919,12 @@ skip_ed:
                                                                 TD_MASK;
 
                                 /* INTR_WDH may need to clean up first */
-                                if (td->td_dma != head)
-                                        goto skip_ed;
+                                if (td->td_dma != head) {
+                                        if (ed == ohci->ed_to_check)
+                                                ohci->ed_to_check = NULL;
+                                        else
+                                                goto skip_ed;
+                                }
                         }
                 }
 
@@ -974,7 +957,7 @@ rescan_this:
                         urb = td->urb;
                         urb_priv = td->urb->hcpriv;
 
-                        if (urb->status == -EINPROGRESS) {
+                        if (!urb->unlinked) {
                                 prev = &td->hwNextTD;
                                 continue;
                         }
@@ -990,7 +973,7 @@ rescan_this:
                         /* if URB is done, clean up */
                         if (urb_priv->td_cnt == urb_priv->length) {
                                 modified = completed = 1;
-                                finish_urb (ohci, urb);
+                                finish_urb(ohci, urb, 0);
                         }
                 }
                 if (completed && !list_empty (&ed->td_list))
@@ -998,6 +981,8 @@ rescan_this:
 
                 /* ED's now officially unlinked, hc doesn't see */
                 ed->state = ED_IDLE;
+                if (quirk_zfmicro(ohci) && ed->type == PIPE_INTERRUPT)
+                        ohci->eds_scheduled--;
                 ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_H);
                 ed->hwNextED = 0;
                 wmb ();
@@ -1021,7 +1006,7 @@ rescan_this:
 
                 if (ohci->ed_controltail) {
                         command |= OHCI_CLF;
-                        if (ohci->flags & OHCI_QUIRK_ZFMICRO)
+                        if (quirk_zfmicro(ohci))
                                 mdelay(1);
                         if (!(ohci->hc_control & OHCI_CTRL_CLE)) {
                                 control |= OHCI_CTRL_CLE;
@@ -1031,7 +1016,7 @@ rescan_this:
                 }
                 if (ohci->ed_bulktail) {
                         command |= OHCI_BLF;
-                        if (ohci->flags & OHCI_QUIRK_ZFMICRO)
+                        if (quirk_zfmicro(ohci))
                                 mdelay(1);
                         if (!(ohci->hc_control & OHCI_CTRL_BLE)) {
                                 control |= OHCI_CTRL_BLE;
@@ -1043,13 +1028,13 @@ rescan_this:
                 /* CLE/BLE to enable, CLF/BLF to (maybe) kickstart */
                 if (control) {
                         ohci->hc_control |= control;
-                        if (ohci->flags & OHCI_QUIRK_ZFMICRO)
+                        if (quirk_zfmicro(ohci))
                                 mdelay(1);
                         ohci_writel (ohci, ohci->hc_control,
                                         &ohci->regs->control);
                 }
                 if (command) {
-                        if (ohci->flags & OHCI_QUIRK_ZFMICRO)
+                        if (quirk_zfmicro(ohci))
                                 mdelay(1);
                         ohci_writel (ohci, command, &ohci->regs->cmdstatus);
                 }
@@ -1061,11 +1046,60 @@ rescan_this:
 /*-------------------------------------------------------------------------*/
 
 /*
+ * Used to take back a TD from the host controller. This would normally be
+ * called from within dl_done_list, however it may be called directly if the
+ * HC no longer sees the TD and it has not appeared on the donelist (after
+ * two frames).  This bug has been observed on ZF Micro systems.
+ */
+static void takeback_td(struct ohci_hcd *ohci, struct td *td)
+{
+        struct urb      *urb = td->urb;
+        urb_priv_t      *urb_priv = urb->hcpriv;
+        struct ed       *ed = td->ed;
+        int             status;
+
+        /* update URB's length and status from TD */
+        status = td_done(ohci, urb, td);
+        urb_priv->td_cnt++;
+
+        /* If all this urb's TDs are done, call complete() */
+        if (urb_priv->td_cnt == urb_priv->length)
+                finish_urb(ohci, urb, status);
+
+        /* clean schedule:  unlink EDs that are no longer busy */
+        if (list_empty(&ed->td_list)) {
+                if (ed->state == ED_OPER)
+                        start_ed_unlink(ohci, ed);
+
+        /* ... reenabling halted EDs only after fault cleanup */
+        } else if ((ed->hwINFO & cpu_to_hc32(ohci, ED_SKIP | ED_DEQUEUE))
+                        == cpu_to_hc32(ohci, ED_SKIP)) {
+                td = list_entry(ed->td_list.next, struct td, td_list);
+                if (!(td->hwINFO & cpu_to_hc32(ohci, TD_DONE))) {
+                        ed->hwINFO &= ~cpu_to_hc32(ohci, ED_SKIP);
+                        /* ... hc may need waking-up */
+                        switch (ed->type) {
+                        case PIPE_CONTROL:
+                                ohci_writel(ohci, OHCI_CLF,
+                                                &ohci->regs->cmdstatus);
+                                break;
+                        case PIPE_BULK:
+                                ohci_writel(ohci, OHCI_BLF,
+                                                &ohci->regs->cmdstatus);
+                                break;
+                        }
+                }
+        }
+}
+
+/*
  * Process normal completions (error or success) and clean the schedules.
  *
  * This is the main path for handing urbs back to drivers.  The only other
- * path is finish_unlinks(), which unlinks URBs using ed_rm_list, instead of
- * scanning the (re-reversed) donelist as this does.
+ * normal path is finish_unlinks(), which unlinks URBs using ed_rm_list,
+ * instead of scanning the (re-reversed) donelist as this does.  There's
+ * an abnormal path too, handling a quirk in some Compaq silicon:  URBs
+ * with TDs that appear to be orphaned are directly reclaimed.
  */
 static void
 dl_done_list (struct ohci_hcd *ohci)
@@ -1074,44 +1108,7 @@ dl_done_list (struct ohci_hcd *ohci)
 
         while (td) {
                 struct td       *td_next = td->next_dl_td;
-                struct urb      *urb = td->urb;
-                urb_priv_t      *urb_priv = urb->hcpriv;
-                struct ed       *ed = td->ed;
-
-                /* update URB's length and status from TD */
-                td_done (ohci, urb, td);
-                urb_priv->td_cnt++;
-
-                /* If all this urb's TDs are done, call complete() */
-                if (urb_priv->td_cnt == urb_priv->length)
-                        finish_urb (ohci, urb);
-
-                /* clean schedule:  unlink EDs that are no longer busy */
-                if (list_empty (&ed->td_list)) {
-                        if (ed->state == ED_OPER)
-                                start_ed_unlink (ohci, ed);
-
-                /* ... reenabling halted EDs only after fault cleanup */
-                } else if ((ed->hwINFO & cpu_to_hc32 (ohci,
-                                                ED_SKIP | ED_DEQUEUE))
-                                        == cpu_to_hc32 (ohci, ED_SKIP)) {
-                        td = list_entry (ed->td_list.next, struct td, td_list);
-                        if (!(td->hwINFO & cpu_to_hc32 (ohci, TD_DONE))) {
-                                ed->hwINFO &= ~cpu_to_hc32 (ohci, ED_SKIP);
-                                /* ... hc may need waking-up */
-                                switch (ed->type) {
-                                case PIPE_CONTROL:
-                                        ohci_writel (ohci, OHCI_CLF,
-                                                &ohci->regs->cmdstatus);
-                                        break;
-                                case PIPE_BULK:
-                                        ohci_writel (ohci, OHCI_BLF,
-                                                &ohci->regs->cmdstatus);
-                                        break;
-                                }
-                        }
-                }
-
+                takeback_td(ohci, td);
                 td = td_next;
         }
 }
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
new file mode 100644
index 0000000000..bc3e785d8c
--- /dev/null
+++ b/drivers/usb/host/ohci-ssb.c
@@ -0,0 +1,247 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom USB-core OHCI driver
+ *
+ * Copyright 2007 Michael Buesch <mb@bu3sch.de>
+ *
+ * Derived from the OHCI-PCI driver
+ * Copyright 1999 Roman Weissgaerber
+ * Copyright 2000-2002 David Brownell
+ * Copyright 1999 Linus Torvalds
+ * Copyright 1999 Gregory P. Smith
+ *
+ * Derived from the USBcore related parts of Broadcom-SB
+ * Copyright 2005 Broadcom Corporation
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+#include <linux/ssb/ssb.h>
+
+
+#define SSB_OHCI_TMSLOW_HOSTMODE        (1 << 29)
+
+struct ssb_ohci_device {
+        struct ohci_hcd ohci; /* _must_ be at the beginning. */
+
+        u32 enable_flags;
+};
+
+static inline
+struct ssb_ohci_device *hcd_to_ssb_ohci(struct usb_hcd *hcd)
+{
+        return (struct ssb_ohci_device *)(hcd->hcd_priv);
+}
+
+
+static int ssb_ohci_reset(struct usb_hcd *hcd)
+{
+        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
+        struct ohci_hcd *ohci = &ohcidev->ohci;
+        int err;
+
+        ohci_hcd_init(ohci);
+        err = ohci_init(ohci);
+
+        return err;
+}
+
+static int ssb_ohci_start(struct usb_hcd *hcd)
+{
+        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
+        struct ohci_hcd *ohci = &ohcidev->ohci;
+        int err;
+
+        err = ohci_run(ohci);
+        if (err < 0) {
+                ohci_err(ohci, "can't start\n");
+                ohci_stop(hcd);
+        }
+
+        return err;
+}
+
+#ifdef CONFIG_PM
+static int ssb_ohci_hcd_suspend(struct usb_hcd *hcd, pm_message_t message)
+{
+        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
+        struct ohci_hcd *ohci = &ohcidev->ohci;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ohci->lock, flags);
+
+        ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
+        ohci_readl(ohci, &ohci->regs->intrdisable); /* commit write */
+
+        /* make sure snapshot being resumed re-enumerates everything */
+        if (message.event == PM_EVENT_PRETHAW)
+                ohci_usb_reset(ohci);
+
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        spin_unlock_irqrestore(&ohci->lock, flags);
+        return 0;
+}
+
+static int ssb_ohci_hcd_resume(struct usb_hcd *hcd)
+{
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        usb_hcd_resume_root_hub(hcd);
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static const struct hc_driver ssb_ohci_hc_driver = {
+        .description            = "ssb-usb-ohci",
+        .product_desc           = "SSB OHCI Controller",
+        .hcd_priv_size          = sizeof(struct ssb_ohci_device),
+
+        .irq                    = ohci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB11,
+
+        .reset                  = ssb_ohci_reset,
+        .start                  = ssb_ohci_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+
+#ifdef CONFIG_PM
+        .suspend                = ssb_ohci_hcd_suspend,
+        .resume                 = ssb_ohci_hcd_resume,
+#endif
+
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        .get_frame_number       = ohci_get_frame,
+
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+        .hub_irq_enable         = ohci_rhsc_enable,
+        .bus_suspend            = ohci_bus_suspend,
+        .bus_resume             = ohci_bus_resume,
+
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static void ssb_ohci_detach(struct ssb_device *dev)
+{
+        struct usb_hcd *hcd = ssb_get_drvdata(dev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        usb_put_hcd(hcd);
+        ssb_device_disable(dev, 0);
+}
+
+static int ssb_ohci_attach(struct ssb_device *dev)
+{
+        struct ssb_ohci_device *ohcidev;
+        struct usb_hcd *hcd;
+        int err = -ENOMEM;
+        u32 tmp, flags = 0;
+
+        if (dev->id.coreid == SSB_DEV_USB11_HOSTDEV)
+                flags |= SSB_OHCI_TMSLOW_HOSTMODE;
+
+        ssb_device_enable(dev, flags);
+
+        hcd = usb_create_hcd(&ssb_ohci_hc_driver, dev->dev,
+                        dev->dev->bus_id);
+        if (!hcd)
+                goto err_dev_disable;
+        ohcidev = hcd_to_ssb_ohci(hcd);
+        ohcidev->enable_flags = flags;
+
+        tmp = ssb_read32(dev, SSB_ADMATCH0);
+        hcd->rsrc_start = ssb_admatch_base(tmp);
+        hcd->rsrc_len = ssb_admatch_size(tmp);
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs)
+                goto err_put_hcd;
+        err = usb_add_hcd(hcd, dev->irq, IRQF_SHARED);
+        if (err)
+                goto err_iounmap;
+
+        ssb_set_drvdata(dev, hcd);
+
+        return err;
+
+err_iounmap:
+        iounmap(hcd->regs);
+err_put_hcd:
+        usb_put_hcd(hcd);
+err_dev_disable:
+        ssb_device_disable(dev, flags);
+        return err;
+}
+
+static int ssb_ohci_probe(struct ssb_device *dev,
+                const struct ssb_device_id *id)
+{
+        int err;
+        u16 chipid_top;
+
+        /* USBcores are only connected on embedded devices. */
+        chipid_top = (dev->bus->chip_id & 0xFF00);
+        if (chipid_top != 0x4700 && chipid_top != 0x5300)
+                return -ENODEV;
+
+        /* TODO: Probably need checks here; is the core connected? */
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        /* We currently always attach SSB_DEV_USB11_HOSTDEV
+         * as HOST OHCI. If we want to attach it as Client device,
+         * we must branch here and call into the (yet to
+         * be written) Client mode driver. Same for remove(). */
+
+        err = ssb_ohci_attach(dev);
+
+        return err;
+}
+
+static void ssb_ohci_remove(struct ssb_device *dev)
+{
+        ssb_ohci_detach(dev);
+}
+
+#ifdef CONFIG_PM
+
+static int ssb_ohci_suspend(struct ssb_device *dev, pm_message_t state)
+{
+        ssb_device_disable(dev, 0);
+
+        return 0;
+}
+
+static int ssb_ohci_resume(struct ssb_device *dev)
+{
+        struct usb_hcd *hcd = ssb_get_drvdata(dev);
+        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd);
+
+        ssb_device_enable(dev, ohcidev->enable_flags);
+
+        return 0;
+}
+
+#else /* !CONFIG_PM */
+#define ssb_ohci_suspend        NULL
+#define ssb_ohci_resume NULL
+#endif /* CONFIG_PM */
+
+static const struct ssb_device_id ssb_ohci_table[] = {
+        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOSTDEV, SSB_ANY_REV),
+        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB11_HOST, SSB_ANY_REV),
+        SSB_DEVTABLE_END
+};
+MODULE_DEVICE_TABLE(ssb, ssb_ohci_table);
+
+static struct ssb_driver ssb_ohci_driver = {
+        .name           = KBUILD_MODNAME,
+        .id_table       = ssb_ohci_table,
+        .probe          = ssb_ohci_probe,
+        .remove         = ssb_ohci_remove,
+        .suspend        = ssb_ohci_suspend,
+        .resume         = ssb_ohci_resume,
+};
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 4ada43cf13..47c5c66a28 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -398,11 +398,38 @@ struct ohci_hcd {
 #define OHCI_QUIRK_BE_MMIO      0x10                    /* BE registers */
 #define OHCI_QUIRK_ZFMICRO      0x20                    /* Compaq ZFMicro chipset*/
 #define OHCI_QUIRK_NEC          0x40                    /* lost interrupts */
+#define OHCI_QUIRK_FRAME_NO     0x80                    /* no big endian frame_no shift */
         // there are also chip quirks/bugs in init logic
 
         struct work_struct      nec_work;       /* Worker for NEC quirk */
+
+        /* Needed for ZF Micro quirk */
+        struct timer_list       unlink_watchdog;
+        unsigned                eds_scheduled;
+        struct ed               *ed_to_check;
+        unsigned                zf_delay;
 };
 
+#ifdef CONFIG_PCI
+static inline int quirk_nec(struct ohci_hcd *ohci)
+{
+        return ohci->flags & OHCI_QUIRK_NEC;
+}
+static inline int quirk_zfmicro(struct ohci_hcd *ohci)
+{
+        return ohci->flags & OHCI_QUIRK_ZFMICRO;
+}
+#else
+static inline int quirk_nec(struct ohci_hcd *ohci)
+{
+        return 0;
+}
+static inline int quirk_zfmicro(struct ohci_hcd *ohci)
+{
+        return 0;
+}
+#endif
+
 /* convert between an hcd pointer and the corresponding ohci_hcd */
 static inline struct ohci_hcd *hcd_to_ohci (struct usb_hcd *hcd)
 {
@@ -607,15 +634,12 @@ static inline u32 hc32_to_cpup (const struct ohci_hcd *ohci, const __hc32 *x)
 /* HCCA frame number is 16 bits, but is accessed as 32 bits since not all
  * hardware handles 16 bit reads.  That creates a different confusion on
  * some big-endian SOC implementations.  Same thing happens with PSW access.
- *
- * FIXME: Deal with that as a runtime quirk when STB03xxx is ported over
- * to arch/powerpc
  */
 
-#ifdef CONFIG_STB03xxx
-#define OHCI_BE_FRAME_NO_SHIFT  16
+#ifdef CONFIG_PPC_MPC52xx
+#define big_endian_frame_no_quirk(ohci) (ohci->flags & OHCI_QUIRK_FRAME_NO)
 #else
-#define OHCI_BE_FRAME_NO_SHIFT  0
+#define big_endian_frame_no_quirk(ohci) 0
 #endif
 
 static inline u16 ohci_frame_no(const struct ohci_hcd *ohci)
@@ -623,7 +647,8 @@ static inline u16 ohci_frame_no(const struct ohci_hcd *ohci)
         u32 tmp;
         if (big_endian_desc(ohci)) {
                 tmp = be32_to_cpup((__force __be32 *)&ohci->hcca->frame_no);
-                tmp >>= OHCI_BE_FRAME_NO_SHIFT;
+                if (!big_endian_frame_no_quirk(ohci))
+                        tmp >>= 16;
         } else
                 tmp = le32_to_cpup((__force __le32 *)&ohci->hcca->frame_no);
 
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 40a1de4c25..ae8ec4474e 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -782,10 +782,12 @@ static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
                 kfree(td);
 
                 if (urb) {
-                        urb->status = -ENODEV;
-                        urb->hcpriv = NULL;
+                        usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597),
+                                        urb);
+
                         spin_unlock(&r8a66597->lock);
-                        usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb);
+                        usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb,
+                                        -ENODEV);
                         spin_lock(&r8a66597->lock);
                 }
                 break;
@@ -832,7 +834,7 @@ 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.maxpacket = ep->wMaxPacketSize;
+        info.maxpacket = le16_to_cpu(ep->wMaxPacketSize);
         info.type = get_r8a66597_type(ep->bmAttributes
                                       & USB_ENDPOINT_XFERTYPE_MASK);
         info.bufnum = get_bufnum(info.pipenum);
@@ -923,7 +925,7 @@ static void prepare_setup_packet(struct r8a66597 *r8a66597,
         r8a66597_write(r8a66597, ~(SIGN | SACK), INTSTS1);
 
         for (i = 0; i < 4; i++) {
-                r8a66597_write(r8a66597, p[i], setup_addr);
+                r8a66597_write(r8a66597, cpu_to_le16(p[i]), setup_addr);
                 setup_addr += 2;
         }
         r8a66597_write(r8a66597, SUREQ, DCPCTR);
@@ -1032,6 +1034,15 @@ static void prepare_status_packet(struct r8a66597 *r8a66597,
         pipe_start(r8a66597, td->pipe);
 }
 
+static int is_set_address(unsigned char *setup_packet)
+{
+        if (((setup_packet[0] & USB_TYPE_MASK) == USB_TYPE_STANDARD) &&
+                        setup_packet[1] == USB_REQ_SET_ADDRESS)
+                return 1;
+        else
+                return 0;
+}
+
 /* this function must be called with interrupt disabled */
 static int start_transfer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
 {
@@ -1039,7 +1050,7 @@ static int start_transfer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
 
         switch (td->type) {
         case USB_PID_SETUP:
-                if (td->urb->setup_packet[1] == USB_REQ_SET_ADDRESS) {
+                if (is_set_address(td->urb->setup_packet)) {
                         td->set_address = 1;
                         td->urb->setup_packet[2] = alloc_usb_address(r8a66597,
                                                                      td->urb);
@@ -1106,8 +1117,9 @@ static void set_td_timer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
 }
 
 /* this function must be called with interrupt disabled */
-static void done(struct r8a66597 *r8a66597, struct r8a66597_td *td,
-                 u16 pipenum, struct urb *urb)
+static void finish_request(struct r8a66597 *r8a66597, struct r8a66597_td *td,
+                u16 pipenum, struct urb *urb, int status)
+__releases(r8a66597->lock) __acquires(r8a66597->lock)
 {
         int restart = 0;
         struct usb_hcd *hcd = r8a66597_to_hcd(r8a66597);
@@ -1115,7 +1127,7 @@ static void done(struct r8a66597 *r8a66597, struct r8a66597_td *td,
         r8a66597->timeout_map &= ~(1 << pipenum);
 
         if (likely(td)) {
-                if (td->set_address && urb->status != 0)
+                if (td->set_address && (status != 0 || urb->unlinked))
                         r8a66597->address_map &= ~(1 << urb->setup_packet[2]);
 
                 pipe_toggle_save(r8a66597, td->pipe, urb);
@@ -1130,9 +1142,9 @@ static void done(struct r8a66597 *r8a66597, struct r8a66597_td *td,
                 if (usb_pipeisoc(urb->pipe))
                         urb->start_frame = r8a66597_get_frame(hcd);
 
-                urb->hcpriv = NULL;
+                usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597), urb);
                 spin_unlock(&r8a66597->lock);
-                usb_hcd_giveback_urb(hcd, urb);
+                usb_hcd_giveback_urb(hcd, urb, status);
                 spin_lock(&r8a66597->lock);
         }
 
@@ -1146,14 +1158,6 @@ static void done(struct r8a66597 *r8a66597, struct r8a66597_td *td,
         }
 }
 
-/* this function must be called with interrupt disabled */
-static void finish_request(struct r8a66597 *r8a66597, struct r8a66597_td *td,
-                           u16 pipenum, struct urb *urb)
-__releases(r8a66597->lock) __acquires(r8a66597->lock)
-{
-        done(r8a66597, td, pipenum, urb);
-}
-
 static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
 {
         u16 tmp;
@@ -1162,6 +1166,7 @@ static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
         struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
         struct urb *urb;
         int finish = 0;
+        int status = 0;
 
         if (unlikely(!td))
                 return;
@@ -1170,17 +1175,15 @@ static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
         fifo_change_from_pipe(r8a66597, td->pipe);
         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
         if (unlikely((tmp & FRDY) == 0)) {
-                urb->status = -EPIPE;
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, pipenum);
                 err("in fifo not ready (%d)", pipenum);
-                finish_request(r8a66597, td, pipenum, td->urb);
+                finish_request(r8a66597, td, pipenum, td->urb, -EPIPE);
                 return;
         }
 
         /* prepare parameters */
         rcv_len = tmp & DTLN;
-        bufsize = td->maxpacket;
         if (usb_pipeisoc(urb->pipe)) {
                 buf = (u16 *)(urb->transfer_buffer +
                                 urb->iso_frame_desc[td->iso_cnt].offset);
@@ -1189,29 +1192,31 @@ static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
                 buf = (void *)urb->transfer_buffer + urb->actual_length;
                 urb_len = urb->transfer_buffer_length - urb->actual_length;
         }
-        if (rcv_len < bufsize)
-                size = min(rcv_len, urb_len);
-        else
-                size = min(bufsize, urb_len);
+        bufsize = min(urb_len, (int) td->maxpacket);
+        if (rcv_len <= bufsize) {
+                size = rcv_len;
+        } else {
+                size = bufsize;
+                status = -EOVERFLOW;
+                finish = 1;
+        }
 
         /* update parameters */
         urb->actual_length += size;
         if (rcv_len == 0)
                 td->zero_packet = 1;
-        if ((size % td->maxpacket) > 0) {
+        if (rcv_len < bufsize) {
                 td->short_packet = 1;
-                if (urb->transfer_buffer_length != urb->actual_length &&
-                    urb->transfer_flags & URB_SHORT_NOT_OK)
-                        td->urb->status = -EREMOTEIO;
         }
         if (usb_pipeisoc(urb->pipe)) {
                 urb->iso_frame_desc[td->iso_cnt].actual_length = size;
-                urb->iso_frame_desc[td->iso_cnt].status = 0;
+                urb->iso_frame_desc[td->iso_cnt].status = status;
                 td->iso_cnt++;
+                finish = 0;
         }
 
         /* check transfer finish */
-        if (check_transfer_finish(td, urb)) {
+        if (finish || check_transfer_finish(td, urb)) {
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, pipenum);
                 finish = 1;
@@ -1226,11 +1231,8 @@ static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
                                            buf, size);
         }
 
-        if (finish && pipenum != 0) {
-                if (td->urb->status == -EINPROGRESS)
-                        td->urb->status = 0;
-                finish_request(r8a66597, td, pipenum, urb);
-        }
+        if (finish && pipenum != 0)
+                finish_request(r8a66597, td, pipenum, urb, status);
 }
 
 static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
@@ -1248,11 +1250,10 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
         fifo_change_from_pipe(r8a66597, td->pipe);
         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
         if (unlikely((tmp & FRDY) == 0)) {
-                urb->status = -EPIPE;
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, pipenum);
                 err("out write fifo not ready. (%d)", pipenum);
-                finish_request(r8a66597, td, pipenum, td->urb);
+                finish_request(r8a66597, td, pipenum, urb, -EPIPE);
                 return;
         }
 
@@ -1297,7 +1298,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
 }
 
 
-static void check_next_phase(struct r8a66597 *r8a66597)
+static void check_next_phase(struct r8a66597 *r8a66597, int status)
 {
         struct r8a66597_td *td = r8a66597_get_td(r8a66597, 0);
         struct urb *urb;
@@ -1310,49 +1311,41 @@ static void check_next_phase(struct r8a66597 *r8a66597)
         switch (td->type) {
         case USB_PID_IN:
         case USB_PID_OUT:
-                if (urb->status != -EINPROGRESS) {
-                        finish = 1;
-                        break;
-                }
                 if (check_transfer_finish(td, urb))
                         td->type = USB_PID_ACK;
                 break;
         case USB_PID_SETUP:
-                if (urb->status != -EINPROGRESS)
-                        finish = 1;
-                else if (urb->transfer_buffer_length == urb->actual_length) {
+                if (urb->transfer_buffer_length == urb->actual_length)
                         td->type = USB_PID_ACK;
-                        urb->status = 0;
-                } else if (usb_pipeout(urb->pipe))
+                else if (usb_pipeout(urb->pipe))
                         td->type = USB_PID_OUT;
                 else
                         td->type = USB_PID_IN;
                 break;
         case USB_PID_ACK:
                 finish = 1;
-                if (urb->status == -EINPROGRESS)
-                        urb->status = 0;
                 break;
         }
 
-        if (finish)
-                finish_request(r8a66597, td, 0, urb);
+        if (finish || status != 0 || urb->unlinked)
+                finish_request(r8a66597, td, 0, urb, status);
         else
                 start_transfer(r8a66597, td);
 }
 
-static void set_urb_error(struct r8a66597 *r8a66597, u16 pipenum)
+static int get_urb_error(struct r8a66597 *r8a66597, u16 pipenum)
 {
         struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
 
-        if (td && td->urb) {
+        if (td) {
                 u16 pid = r8a66597_read(r8a66597, td->pipe->pipectr) & PID;
 
                 if (pid == PID_NAK)
-                        td->urb->status = -ECONNRESET;
+                        return -ECONNRESET;
                 else
-                        td->urb->status = -EPIPE;
+                        return -EPIPE;
         }
+        return 0;
 }
 
 static void irq_pipe_ready(struct r8a66597 *r8a66597)
@@ -1371,7 +1364,7 @@ static void irq_pipe_ready(struct r8a66597 *r8a66597)
                         packet_read(r8a66597, 0);
                 else
                         pipe_irq_disable(r8a66597, 0);
-                check_next_phase(r8a66597);
+                check_next_phase(r8a66597, 0);
         }
 
         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
@@ -1405,7 +1398,7 @@ static void irq_pipe_empty(struct r8a66597 *r8a66597)
                 td = r8a66597_get_td(r8a66597, 0);
                 if (td && td->type != USB_PID_OUT)
                         disable_irq_empty(r8a66597, 0);
-                check_next_phase(r8a66597);
+                check_next_phase(r8a66597, 0);
         }
 
         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
@@ -1420,9 +1413,8 @@ static void irq_pipe_empty(struct r8a66597 *r8a66597)
                         if ((tmp & INBUFM) == 0) {
                                 disable_irq_empty(r8a66597, pipenum);
                                 pipe_irq_disable(r8a66597, pipenum);
-                                if (td->urb->status == -EINPROGRESS)
-                                        td->urb->status = 0;
-                                finish_request(r8a66597, td, pipenum, td->urb);
+                                finish_request(r8a66597, td, pipenum, td->urb,
+                                                0);
                         }
                 }
         }
@@ -1433,15 +1425,16 @@ static void irq_pipe_nrdy(struct r8a66597 *r8a66597)
         u16 check;
         u16 pipenum;
         u16 mask;
+        int status;
 
         mask = r8a66597_read(r8a66597, NRDYSTS)
                & r8a66597_read(r8a66597, NRDYENB);
         r8a66597_write(r8a66597, ~mask, NRDYSTS);
         if (mask & NRDY0) {
                 cfifo_change(r8a66597, 0);
-                set_urb_error(r8a66597, 0);
+                status = get_urb_error(r8a66597, 0);
                 pipe_irq_disable(r8a66597, 0);
-                check_next_phase(r8a66597);
+                check_next_phase(r8a66597, status);
         }
 
         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
@@ -1452,10 +1445,10 @@ static void irq_pipe_nrdy(struct r8a66597 *r8a66597)
                         if (unlikely(!td))
                                 continue;
 
-                        set_urb_error(r8a66597, pipenum);
+                        status = get_urb_error(r8a66597, pipenum);
                         pipe_irq_disable(r8a66597, pipenum);
                         pipe_stop(r8a66597, td->pipe);
-                        finish_request(r8a66597, td, pipenum, td->urb);
+                        finish_request(r8a66597, td, pipenum, td->urb, status);
                 }
         }
 }
@@ -1475,6 +1468,7 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
         u16 intsts0, intsts1, intsts2;
         u16 intenb0, intenb1, intenb2;
         u16 mask0, mask1, mask2;
+        int status;
 
         spin_lock(&r8a66597->lock);
 
@@ -1518,12 +1512,12 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
                 }
                 if (mask1 & SIGN) {
                         r8a66597_write(r8a66597, ~SIGN, INTSTS1);
-                        set_urb_error(r8a66597, 0);
-                        check_next_phase(r8a66597);
+                        status = get_urb_error(r8a66597, 0);
+                        check_next_phase(r8a66597, status);
                 }
                 if (mask1 & SACK) {
                         r8a66597_write(r8a66597, ~SACK, INTSTS1);
-                        check_next_phase(r8a66597);
+                        check_next_phase(r8a66597, 0);
                 }
         }
         if (mask0) {
@@ -1722,21 +1716,25 @@ static struct r8a66597_td *r8a66597_make_td(struct r8a66597 *r8a66597,
 }
 
 static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
-                                struct usb_host_endpoint *hep,
                                 struct urb *urb,
                                 gfp_t mem_flags)
 {
+        struct usb_host_endpoint *hep = urb->ep;
         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
         struct r8a66597_td *td = NULL;
-        int ret = 0, request = 0;
+        int ret, request = 0;
         unsigned long flags;
 
         spin_lock_irqsave(&r8a66597->lock, flags);
         if (!get_urb_to_r8a66597_dev(r8a66597, urb)) {
                 ret = -ENODEV;
-                goto error;
+                goto error_not_linked;
         }
 
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret)
+                goto error_not_linked;
+
         if (!hep->hcpriv) {
                 hep->hcpriv = kzalloc(sizeof(struct r8a66597_pipe),
                                 GFP_ATOMIC);
@@ -1761,15 +1759,7 @@ static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
         if (list_empty(&r8a66597->pipe_queue[td->pipenum]))
                 request = 1;
         list_add_tail(&td->queue, &r8a66597->pipe_queue[td->pipenum]);
-
-        spin_lock(&urb->lock);
-        if (urb->status != -EINPROGRESS) {
-                spin_unlock(&urb->lock);
-                ret = -EPIPE;
-                goto error;
-        }
         urb->hcpriv = td;
-        spin_unlock(&urb->lock);
 
         if (request) {
                 ret = start_transfer(r8a66597, td);
@@ -1781,26 +1771,36 @@ static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
                 set_td_timer(r8a66597, td);
 
 error:
+        if (ret)
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+error_not_linked:
         spin_unlock_irqrestore(&r8a66597->lock, flags);
         return ret;
 }
 
-static int r8a66597_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int r8a66597_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+                int status)
 {
         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
         struct r8a66597_td *td;
         unsigned long flags;
+        int rc;
 
         spin_lock_irqsave(&r8a66597->lock, flags);
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
+                goto done;
+
         if (urb->hcpriv) {
                 td = urb->hcpriv;
                 pipe_stop(r8a66597, td->pipe);
                 pipe_irq_disable(r8a66597, td->pipenum);
                 disable_irq_empty(r8a66597, td->pipenum);
-                done(r8a66597, td, td->pipenum, urb);
+                finish_request(r8a66597, td, td->pipenum, urb, status);
         }
+ done:
         spin_unlock_irqrestore(&r8a66597->lock, flags);
-        return 0;
+        return rc;
 }
 
 static void r8a66597_endpoint_disable(struct usb_hcd *hcd,
@@ -1830,7 +1830,7 @@ static void r8a66597_endpoint_disable(struct usb_hcd *hcd,
         td = r8a66597_get_td(r8a66597, pipenum);
         if (td)
                 urb = td->urb;
-        done(r8a66597, td, pipenum, urb);
+        finish_request(r8a66597, td, pipenum, urb, -ESHUTDOWN);
         kfree(hep->hcpriv);
         hep->hcpriv = NULL;
         spin_unlock_irqrestore(&r8a66597->lock, flags);
@@ -2027,7 +2027,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         case GetPortStatus:
                 if (wIndex > R8A66597_MAX_ROOT_HUB)
                         goto error;
-                *(u32 *)buf = rh->port;
+                *(u32 *)buf = cpu_to_le32(rh->port);
                 break;
         case SetPortFeature:
                 if (wIndex > R8A66597_MAX_ROOT_HUB)
@@ -2126,8 +2126,8 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev)
         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
 
         del_timer_sync(&r8a66597->rh_timer);
-        iounmap((void *)r8a66597->reg);
         usb_remove_hcd(hcd);
+        iounmap((void *)r8a66597->reg);
         usb_put_hcd(hcd);
         return 0;
 }
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 4cfa3ff2c9..94d859aa73 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -435,14 +435,9 @@ static void finish_request(
         if (usb_pipecontrol(urb->pipe))
                 ep->nextpid = USB_PID_SETUP;
 
-        spin_lock(&urb->lock);
-        if (urb->status == -EINPROGRESS)
-                urb->status = status;
-        urb->hcpriv = NULL;
-        spin_unlock(&urb->lock);
-
+        usb_hcd_unlink_urb_from_ep(sl811_to_hcd(sl811), urb);
         spin_unlock(&sl811->lock);
-        usb_hcd_giveback_urb(sl811_to_hcd(sl811), urb);
+        usb_hcd_giveback_urb(sl811_to_hcd(sl811), urb, status);
         spin_lock(&sl811->lock);
 
         /* leave active endpoints in the schedule */
@@ -538,35 +533,21 @@ done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank)
                                                 bank + SL11H_XFERCNTREG);
                         if (len > ep->length) {
                                 len = ep->length;
-                                urb->status = -EOVERFLOW;
+                                urbstat = -EOVERFLOW;
                         }
                         urb->actual_length += len;
                         sl811_read_buf(sl811, SL811HS_PACKET_BUF(bank == 0),
                                         buf, len);
                         usb_dotoggle(udev, ep->epnum, 0);
-                        if (urb->actual_length == urb->transfer_buffer_length)
-                                urbstat = 0;
-                        else if (len < ep->maxpacket) {
-                                if (urb->transfer_flags & URB_SHORT_NOT_OK)
-                                        urbstat = -EREMOTEIO;
+                        if (urbstat == -EINPROGRESS &&
+                                        (len < ep->maxpacket ||
+                                                urb->actual_length ==
+                                                urb->transfer_buffer_length)) {
+                                if (usb_pipecontrol(urb->pipe))
+                                        ep->nextpid = USB_PID_ACK;
                                 else
                                         urbstat = 0;
                         }
-                        if (usb_pipecontrol(urb->pipe)
-                                        && (urbstat == -EREMOTEIO
-                                                || urbstat == 0)) {
-
-                                /* NOTE if the status stage STALLs (why?),
-                                 * this reports the wrong urb status.
-                                 */
-                                spin_lock(&urb->lock);
-                                if (urb->status == -EINPROGRESS)
-                                        urb->status = urbstat;
-                                spin_unlock(&urb->lock);
-
-                                urb = NULL;
-                                ep->nextpid = USB_PID_ACK;
-                        }
                         break;
                 case USB_PID_SETUP:
                         // PACKET("...ACK/setup_%02x qh%p\n", bank, ep);
@@ -605,7 +586,7 @@ done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank)
                                 bank, status, ep, urbstat);
         }
 
-        if (urb && (urbstat != -EINPROGRESS || urb->status != -EINPROGRESS))
+        if (urbstat != -EINPROGRESS || urb->unlinked)
                 finish_request(sl811, ep, urb, urbstat);
 }
 
@@ -807,7 +788,6 @@ static int balance(struct sl811 *sl811, u16 period, u16 load)
 
 static int sl811h_urb_enqueue(
         struct usb_hcd          *hcd,
-        struct usb_host_endpoint *hep,
         struct urb              *urb,
         gfp_t                   mem_flags
 ) {
@@ -820,7 +800,8 @@ static int sl811h_urb_enqueue(
         struct sl811h_ep        *ep = NULL;
         unsigned long           flags;
         int                     i;
-        int                     retval = 0;
+        int                     retval;
+        struct usb_host_endpoint        *hep = urb->ep;
 
 #ifdef  DISABLE_ISO
         if (type == PIPE_ISOCHRONOUS)
@@ -838,7 +819,12 @@ static int sl811h_urb_enqueue(
                         || !HC_IS_RUNNING(hcd->state)) {
                 retval = -ENODEV;
                 kfree(ep);
-                goto fail;
+                goto fail_not_linked;
+        }
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval) {
+                kfree(ep);
+                goto fail_not_linked;
         }
 
         if (hep->hcpriv) {
@@ -951,37 +937,31 @@ static int sl811h_urb_enqueue(
                 sofirq_on(sl811);
         }
 
-        /* in case of unlink-during-submit */
-        spin_lock(&urb->lock);
-        if (urb->status != -EINPROGRESS) {
-                spin_unlock(&urb->lock);
-                finish_request(sl811, ep, urb, 0);
-                retval = 0;
-                goto fail;
-        }
         urb->hcpriv = hep;
-        spin_unlock(&urb->lock);
-
         start_transfer(sl811);
         sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
 fail:
+        if (retval)
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+fail_not_linked:
         spin_unlock_irqrestore(&sl811->lock, flags);
         return retval;
 }
 
-static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct sl811            *sl811 = hcd_to_sl811(hcd);
         struct usb_host_endpoint *hep;
         unsigned long           flags;
         struct sl811h_ep        *ep;
-        int                     retval = 0;
+        int                     retval;
 
         spin_lock_irqsave(&sl811->lock, flags);
-        hep = urb->hcpriv;
-        if (!hep)
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval)
                 goto fail;
 
+        hep = urb->hcpriv;
         ep = hep->hcpriv;
         if (ep) {
                 /* finish right away if this urb can't be active ...
@@ -1029,8 +1009,8 @@ static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
                         VDBG("dequeue, urb %p active %s; wait4irq\n", urb,
                                 (sl811->active_a == ep) ? "A" : "B");
         } else
-fail:
                 retval = -EINVAL;
+ fail:
         spin_unlock_irqrestore(&sl811->lock, flags);
         return retval;
 }
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index b88eb3c62c..ac283b09a6 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -51,7 +51,6 @@
 #include <linux/usb.h>
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
-#include <linux/pci_ids.h>
 #include <linux/mutex.h>
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -184,7 +183,7 @@ struct u132_ring {
 struct u132 {
         struct kref kref;
         struct list_head u132_list;
-        struct semaphore sw_lock;
+        struct mutex sw_lock;
         struct semaphore scheduler_lock;
         struct u132_platform_data *board;
         struct platform_device *platform_dev;
@@ -493,20 +492,20 @@ static void u132_hcd_monitor_work(struct work_struct *work)
                 return;
         } else {
                 int retval;
-                down(&u132->sw_lock);
+                mutex_lock(&u132->sw_lock);
                 retval = read_roothub_info(u132);
                 if (retval) {
                         struct usb_hcd *hcd = u132_to_hcd(u132);
                         u132_disable(u132);
                         u132->going = 1;
-                        up(&u132->sw_lock);
+                        mutex_unlock(&u132->sw_lock);
                         usb_hc_died(hcd);
                         ftdi_elan_gone_away(u132->platform_dev);
                         u132_monitor_put_kref(u132);
                         return;
                 } else {
                         u132_monitor_requeue_work(u132, 500);
-                        up(&u132->sw_lock);
+                        mutex_unlock(&u132->sw_lock);
                         return;
                 }
         }
@@ -519,9 +518,8 @@ static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
         unsigned long irqs;
         struct usb_hcd *hcd = u132_to_hcd(u132);
         urb->error_count = 0;
-        urb->status = status;
-        urb->hcpriv = NULL;
         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
         endp->queue_next += 1;
         if (ENDP_QUEUE_SIZE > --endp->queue_size) {
                 endp->active = 0;
@@ -543,7 +541,7 @@ static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
         u132_ring_queue_work(u132, ring, 0);
         up(&u132->scheduler_lock);
         u132_endp_put_kref(u132, endp);
-        usb_hcd_giveback_urb(hcd, urb);
+        usb_hcd_giveback_urb(hcd, urb, status);
         return;
 }
 
@@ -559,9 +557,8 @@ static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
         unsigned long irqs;
         struct usb_hcd *hcd = u132_to_hcd(u132);
         urb->error_count = 0;
-        urb->status = status;
-        urb->hcpriv = NULL;
         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
         endp->queue_next += 1;
         if (ENDP_QUEUE_SIZE > --endp->queue_size) {
                 endp->active = 0;
@@ -576,7 +573,7 @@ static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
                 endp->active = 0;
                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
                 kfree(urbq);
-        } usb_hcd_giveback_urb(hcd, urb);
+        } usb_hcd_giveback_urb(hcd, urb, status);
         return;
 }
 
@@ -646,12 +643,12 @@ static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 struct u132_ring *ring = endp->ring;
                 u8 *u = urb->transfer_buffer + urb->actual_length;
                 u8 *b = buf;
@@ -717,10 +714,10 @@ static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
                         return;
                 }
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -745,12 +742,12 @@ static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 struct u132_ring *ring = endp->ring;
                 urb->actual_length += len;
                 endp->toggle_bits = toggle_bits;
@@ -769,10 +766,10 @@ static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
                         return;
                 }
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -798,12 +795,12 @@ static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 struct u132_ring *ring = endp->ring;
                 u8 *u = urb->transfer_buffer + urb->actual_length;
                 u8 *b = buf;
@@ -872,10 +869,10 @@ static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
                         return;
                 }
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -899,20 +896,20 @@ static void u132_hcd_configure_empty_sent(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -937,12 +934,12 @@ static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 struct u132_ring *ring = endp->ring;
                 u8 *u = urb->transfer_buffer;
                 u8 *b = buf;
@@ -981,10 +978,10 @@ static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
                         return;
                 }
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1008,20 +1005,20 @@ static void u132_hcd_configure_empty_recv(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1046,12 +1043,12 @@ static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 if (usb_pipein(urb->pipe)) {
                         int retval;
                         struct u132_ring *ring = endp->ring;
@@ -1078,10 +1075,10 @@ static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
                         return;
                 }
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1107,22 +1104,22 @@ static void u132_hcd_enumeration_empty_recv(void *data, struct urb *urb,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 u132->addr[0].address = 0;
                 endp->usb_addr = udev->usb_addr;
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1146,12 +1143,12 @@ static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 int retval;
                 struct u132_ring *ring = endp->ring;
                 up(&u132->scheduler_lock);
@@ -1163,10 +1160,10 @@ static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
                         u132_hcd_giveback_urb(u132, endp, urb, retval);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1190,20 +1187,20 @@ static void u132_hcd_initial_empty_sent(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1228,12 +1225,12 @@ static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 int retval;
                 struct u132_ring *ring = endp->ring;
                 u8 *u = urb->transfer_buffer;
@@ -1252,10 +1249,10 @@ static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
                         u132_hcd_giveback_urb(u132, endp, urb, retval);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1280,12 +1277,12 @@ static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
                 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
                 return;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 up(&u132->scheduler_lock);
                 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
                 return;
-        } else if (urb->status == -EINPROGRESS) {
+        } else if (!urb->unlinked) {
                 int retval;
                 struct u132_ring *ring = endp->ring;
                 up(&u132->scheduler_lock);
@@ -1297,10 +1294,10 @@ static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
                         u132_hcd_giveback_urb(u132, endp, urb, retval);
                 return;
         } else {
-                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
-                        "s=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
+                                "unlinked=%d\n", urb, urb->unlinked);
                 up(&u132->scheduler_lock);
-                u132_hcd_giveback_urb(u132, endp, urb, urb->status);
+                u132_hcd_giveback_urb(u132, endp, urb, 0);
                 return;
         }
 }
@@ -1805,10 +1802,10 @@ static void u132_hcd_stop(struct usb_hcd *hcd)
                 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
                         "ed\n", hcd);
         } else {
-                down(&u132->sw_lock);
+                mutex_lock(&u132->sw_lock);
                 msleep(100);
                 u132_power(u132, 0);
-                up(&u132->sw_lock);
+                mutex_unlock(&u132->sw_lock);
         }
 }
 
@@ -1830,7 +1827,7 @@ static int u132_hcd_start(struct usb_hcd *hcd)
                         (pdev->dev.platform_data))->vendor;
                 u16 device = ((struct u132_platform_data *)
                         (pdev->dev.platform_data))->device;
-                down(&u132->sw_lock);
+                mutex_lock(&u132->sw_lock);
                 msleep(10);
                 if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
                         u132->flags = OHCI_QUIRK_AMD756;
@@ -1845,7 +1842,7 @@ static int u132_hcd_start(struct usb_hcd *hcd)
                         u132->going = 1;
                 }
                 msleep(100);
-                up(&u132->sw_lock);
+                mutex_unlock(&u132->sw_lock);
                 return retval;
         } else {
                 dev_err(&u132->platform_dev->dev, "platform_device missing\n");
@@ -1865,32 +1862,44 @@ static int u132_hcd_reset(struct usb_hcd *hcd)
                 return -ESHUTDOWN;
         } else {
                 int retval;
-                down(&u132->sw_lock);
+                mutex_lock(&u132->sw_lock);
                 retval = u132_init(u132);
                 if (retval) {
                         u132_disable(u132);
                         u132->going = 1;
                 }
-                up(&u132->sw_lock);
+                mutex_unlock(&u132->sw_lock);
                 return retval;
         }
 }
 
 static int create_endpoint_and_queue_int(struct u132 *u132,
-        struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
+        struct u132_udev *udev, struct urb *urb,
         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
         gfp_t mem_flags)
 {
         struct u132_ring *ring;
         unsigned long irqs;
-        u8 endp_number = ++u132->num_endpoints;
-        struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
-                kmalloc(sizeof(struct u132_endp), mem_flags);
+        int rc;
+        u8 endp_number;
+        struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
+
         if (!endp) {
                 return -ENOMEM;
         }
+
+        spin_lock_init(&endp->queue_lock.slock);
+        spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
+        if (rc) {
+                spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
+                kfree(endp);
+                return rc;
+        }
+
+        endp_number = ++u132->num_endpoints;
+        urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
-        spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         ring = endp->ring = &u132->ring[0];
         if (ring->curr_endp) {
@@ -1906,7 +1915,7 @@ static int create_endpoint_and_queue_int(struct u132 *u132,
         endp->delayed = 0;
         endp->endp_number = endp_number;
         endp->u132 = u132;
-        endp->hep = hep;
+        endp->hep = urb->ep;
         endp->pipetype = usb_pipetype(urb->pipe);
         u132_endp_init_kref(u132, endp);
         if (usb_pipein(urb->pipe)) {
@@ -1925,7 +1934,6 @@ static int create_endpoint_and_queue_int(struct u132 *u132,
                 u132_udev_get_kref(u132, udev);
         }
         urb->hcpriv = u132;
-        spin_lock_irqsave(&endp->queue_lock.slock, irqs);
         endp->delayed = 1;
         endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
         endp->udev_number = address;
@@ -1940,8 +1948,8 @@ static int create_endpoint_and_queue_int(struct u132 *u132,
         return 0;
 }
 
-static int queue_int_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
-        struct usb_host_endpoint *hep, struct urb *urb,
+static int queue_int_on_old_endpoint(struct u132 *u132,
+        struct u132_udev *udev, struct urb *urb,
         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
         u8 usb_endp, u8 address)
 {
@@ -1965,21 +1973,33 @@ static int queue_int_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
 }
 
 static int create_endpoint_and_queue_bulk(struct u132 *u132,
-        struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
+        struct u132_udev *udev, struct urb *urb,
         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
         gfp_t mem_flags)
 {
         int ring_number;
         struct u132_ring *ring;
         unsigned long irqs;
-        u8 endp_number = ++u132->num_endpoints;
-        struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
-                kmalloc(sizeof(struct u132_endp), mem_flags);
+        int rc;
+        u8 endp_number;
+        struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
+
         if (!endp) {
                 return -ENOMEM;
         }
+
+        spin_lock_init(&endp->queue_lock.slock);
+        spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
+        if (rc) {
+                spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
+                kfree(endp);
+                return rc;
+        }
+
+        endp_number = ++u132->num_endpoints;
+        urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
-        spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         endp->dequeueing = 0;
         endp->edset_flush = 0;
@@ -1987,7 +2007,7 @@ static int create_endpoint_and_queue_bulk(struct u132 *u132,
         endp->delayed = 0;
         endp->endp_number = endp_number;
         endp->u132 = u132;
-        endp->hep = hep;
+        endp->hep = urb->ep;
         endp->pipetype = usb_pipetype(urb->pipe);
         u132_endp_init_kref(u132, endp);
         if (usb_pipein(urb->pipe)) {
@@ -2016,7 +2036,6 @@ static int create_endpoint_and_queue_bulk(struct u132 *u132,
         }
         ring->length += 1;
         urb->hcpriv = u132;
-        spin_lock_irqsave(&endp->queue_lock.slock, irqs);
         endp->udev_number = address;
         endp->usb_addr = usb_addr;
         endp->usb_endp = usb_endp;
@@ -2030,7 +2049,7 @@ static int create_endpoint_and_queue_bulk(struct u132 *u132,
 }
 
 static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
-         struct usb_host_endpoint *hep, struct urb *urb,
+        struct urb *urb,
         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
         u8 usb_endp, u8 address)
 {
@@ -2052,19 +2071,32 @@ static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
 }
 
 static int create_endpoint_and_queue_control(struct u132 *u132,
-        struct usb_host_endpoint *hep, struct urb *urb,
+        struct urb *urb,
         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
         gfp_t mem_flags)
 {
         struct u132_ring *ring;
-        u8 endp_number = ++u132->num_endpoints;
-        struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
-                kmalloc(sizeof(struct u132_endp), mem_flags);
+        unsigned long irqs;
+        int rc;
+        u8 endp_number;
+        struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
+
         if (!endp) {
                 return -ENOMEM;
         }
+
+        spin_lock_init(&endp->queue_lock.slock);
+        spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
+        if (rc) {
+                spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
+                kfree(endp);
+                return rc;
+        }
+
+        endp_number = ++u132->num_endpoints;
+        urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
-        spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         ring = endp->ring = &u132->ring[0];
         if (ring->curr_endp) {
@@ -2080,11 +2112,10 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
         endp->delayed = 0;
         endp->endp_number = endp_number;
         endp->u132 = u132;
-        endp->hep = hep;
+        endp->hep = urb->ep;
         u132_endp_init_kref(u132, endp);
         u132_endp_get_kref(u132, endp);
         if (usb_addr == 0) {
-                unsigned long irqs;
                 u8 address = u132->addr[usb_addr].address;
                 struct u132_udev *udev = &u132->udev[address];
                 endp->udev_number = address;
@@ -2098,7 +2129,6 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
                 udev->endp_number_in[usb_endp] = endp_number;
                 udev->endp_number_out[usb_endp] = endp_number;
                 urb->hcpriv = u132;
-                spin_lock_irqsave(&endp->queue_lock.slock, irqs);
                 endp->queue_size = 1;
                 endp->queue_last = 0;
                 endp->queue_next = 0;
@@ -2107,7 +2137,6 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
                 u132_endp_queue_work(u132, endp, 0);
                 return 0;
         } else {                /*(usb_addr > 0) */
-                unsigned long irqs;
                 u8 address = u132->addr[usb_addr].address;
                 struct u132_udev *udev = &u132->udev[address];
                 endp->udev_number = address;
@@ -2121,7 +2150,6 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
                 udev->endp_number_in[usb_endp] = endp_number;
                 udev->endp_number_out[usb_endp] = endp_number;
                 urb->hcpriv = u132;
-                spin_lock_irqsave(&endp->queue_lock.slock, irqs);
                 endp->queue_size = 1;
                 endp->queue_last = 0;
                 endp->queue_next = 0;
@@ -2133,7 +2161,7 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
 }
 
 static int queue_control_on_old_endpoint(struct u132 *u132,
-        struct usb_host_endpoint *hep, struct urb *urb,
+        struct urb *urb,
         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
         u8 usb_endp)
 {
@@ -2233,8 +2261,8 @@ static int queue_control_on_old_endpoint(struct u132 *u132,
         }
 }
 
-static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
-        struct urb *urb, gfp_t mem_flags)
+static int u132_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+                gfp_t mem_flags)
 {
         struct u132 *u132 = hcd_to_u132(hcd);
         if (irqs_disabled()) {
@@ -2249,8 +2277,8 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                         , u132->going);
                 return -ENODEV;
         } else if (u132->going > 0) {
-                dev_err(&u132->platform_dev->dev, "device is being removed urb="
-                        "%p status=%d\n", urb, urb->status);
+                dev_err(&u132->platform_dev->dev, "device is being removed "
+                                "urb=%p\n", urb);
                 return -ESHUTDOWN;
         } else {
                 u8 usb_addr = usb_pipedevice(urb->pipe);
@@ -2259,16 +2287,24 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                 if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
                         u8 address = u132->addr[usb_addr].address;
                         struct u132_udev *udev = &u132->udev[address];
-                        struct u132_endp *endp = hep->hcpriv;
+                        struct u132_endp *endp = urb->ep->hcpriv;
                         urb->actual_length = 0;
                         if (endp) {
                                 unsigned long irqs;
                                 int retval;
                                 spin_lock_irqsave(&endp->queue_lock.slock,
                                         irqs);
-                                retval = queue_int_on_old_endpoint(u132, udev,
-                                        hep, urb, usb_dev, endp, usb_addr,
-                                        usb_endp, address);
+                                retval = usb_hcd_link_urb_to_ep(hcd, urb);
+                                if (retval == 0) {
+                                        retval = queue_int_on_old_endpoint(
+                                                        u132, udev, urb,
+                                                        usb_dev, endp,
+                                                        usb_addr, usb_endp,
+                                                        address);
+                                        if (retval)
+                                                usb_hcd_unlink_urb_from_ep(
+                                                                hcd, urb);
+                                }
                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
                                         irqs);
                                 if (retval) {
@@ -2283,8 +2319,8 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                                 return -EINVAL;
                         } else {        /*(endp == NULL) */
                                 return create_endpoint_and_queue_int(u132, udev,
-                                         hep, urb, usb_dev, usb_addr, usb_endp,
-                                        address, mem_flags);
+                                                urb, usb_dev, usb_addr,
+                                                usb_endp, address, mem_flags);
                         }
                 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
                         dev_err(&u132->platform_dev->dev, "the hardware does no"
@@ -2293,16 +2329,24 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
                         u8 address = u132->addr[usb_addr].address;
                         struct u132_udev *udev = &u132->udev[address];
-                        struct u132_endp *endp = hep->hcpriv;
+                        struct u132_endp *endp = urb->ep->hcpriv;
                         urb->actual_length = 0;
                         if (endp) {
                                 unsigned long irqs;
                                 int retval;
                                 spin_lock_irqsave(&endp->queue_lock.slock,
                                         irqs);
-                                retval = queue_bulk_on_old_endpoint(u132, udev,
-                                        hep, urb, usb_dev, endp, usb_addr,
-                                        usb_endp, address);
+                                retval = usb_hcd_link_urb_to_ep(hcd, urb);
+                                if (retval == 0) {
+                                        retval = queue_bulk_on_old_endpoint(
+                                                        u132, udev, urb,
+                                                        usb_dev, endp,
+                                                        usb_addr, usb_endp,
+                                                        address);
+                                        if (retval)
+                                                usb_hcd_unlink_urb_from_ep(
+                                                                hcd, urb);
+                                }
                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
                                         irqs);
                                 if (retval) {
@@ -2315,10 +2359,10 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                                 return -EINVAL;
                         } else
                                 return create_endpoint_and_queue_bulk(u132,
-                                        udev, hep, urb, usb_dev, usb_addr,
+                                        udev, urb, usb_dev, usb_addr,
                                         usb_endp, address, mem_flags);
                 } else {
-                        struct u132_endp *endp = hep->hcpriv;
+                        struct u132_endp *endp = urb->ep->hcpriv;
                         u16 urb_size = 8;
                         u8 *b = urb->setup_packet;
                         int i = 0;
@@ -2341,9 +2385,16 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                                 int retval;
                                 spin_lock_irqsave(&endp->queue_lock.slock,
                                         irqs);
-                                retval = queue_control_on_old_endpoint(u132,
-                                        hep, urb, usb_dev, endp, usb_addr,
-                                        usb_endp);
+                                retval = usb_hcd_link_urb_to_ep(hcd, urb);
+                                if (retval == 0) {
+                                        retval = queue_control_on_old_endpoint(
+                                                        u132, urb, usb_dev,
+                                                        endp, usb_addr,
+                                                        usb_endp);
+                                        if (retval)
+                                                usb_hcd_unlink_urb_from_ep(
+                                                                hcd, urb);
+                                }
                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
                                         irqs);
                                 if (retval) {
@@ -2356,7 +2407,7 @@ static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
                                 return -EINVAL;
                         } else
                                 return create_endpoint_and_queue_control(u132,
-                                        hep, urb, usb_dev, usb_addr, usb_endp,
+                                        urb, usb_dev, usb_addr, usb_endp,
                                         mem_flags);
                 }
         }
@@ -2375,8 +2426,7 @@ static int dequeue_from_overflow_chain(struct u132 *u132,
                         list_del(scan);
                         endp->queue_size -= 1;
                         urb->error_count = 0;
-                        urb->hcpriv = NULL;
-                        usb_hcd_giveback_urb(hcd, urb);
+                        usb_hcd_giveback_urb(hcd, urb, 0);
                         return 0;
                 } else
                         continue;
@@ -2391,10 +2441,17 @@ static int dequeue_from_overflow_chain(struct u132 *u132,
 }
 
 static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
-        struct urb *urb)
+                struct urb *urb, int status)
 {
         unsigned long irqs;
+        int rc;
+
         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
+        rc = usb_hcd_check_unlink_urb(u132_to_hcd(u132), urb, status);
+        if (rc) {
+                spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
+                return rc;
+        }
         if (endp->queue_size == 0) {
                 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
                         "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
@@ -2410,11 +2467,10 @@ static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
                         endp->edset_flush = 1;
                         u132_endp_queue_work(u132, endp, 0);
                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
-                        urb->hcpriv = NULL;
                         return 0;
                 } else {
                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
-                        u132_hcd_abandon_urb(u132, endp, urb, urb->status);
+                        u132_hcd_abandon_urb(u132, endp, urb, status);
                         return 0;
                 }
         } else {
@@ -2439,6 +2495,8 @@ static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
                 }
                 if (urb_slot) {
                         struct usb_hcd *hcd = u132_to_hcd(u132);
+
+                        usb_hcd_unlink_urb_from_ep(hcd, urb);
                         endp->queue_size -= 1;
                         if (list_empty(&endp->urb_more)) {
                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
@@ -2453,8 +2511,7 @@ static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
                                         irqs);
                                 kfree(urbq);
                         } urb->error_count = 0;
-                        urb->hcpriv = NULL;
-                        usb_hcd_giveback_urb(hcd, urb);
+                        usb_hcd_giveback_urb(hcd, urb, status);
                         return 0;
                 } else if (list_empty(&endp->urb_more)) {
                         dev_err(&u132->platform_dev->dev, "urb=%p not found in "
@@ -2468,7 +2525,10 @@ static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
                         return -EINVAL;
                 } else {
-                        int retval = dequeue_from_overflow_chain(u132, endp,
+                        int retval;
+
+                        usb_hcd_unlink_urb_from_ep(u132_to_hcd(u132), urb);
+                        retval = dequeue_from_overflow_chain(u132, endp,
                                 urb);
                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
                         return retval;
@@ -2476,7 +2536,7 @@ static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
         }
 }
 
-static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct u132 *u132 = hcd_to_u132(hcd);
         if (u132->going > 2) {
@@ -2491,11 +2551,11 @@ static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
                 if (usb_pipein(urb->pipe)) {
                         u8 endp_number = udev->endp_number_in[usb_endp];
                         struct u132_endp *endp = u132->endp[endp_number - 1];
-                        return u132_endp_urb_dequeue(u132, endp, urb);
+                        return u132_endp_urb_dequeue(u132, endp, urb, status);
                 } else {
                         u8 endp_number = udev->endp_number_out[usb_endp];
                         struct u132_endp *endp = u132->endp[endp_number - 1];
-                        return u132_endp_urb_dequeue(u132, endp, urb);
+                        return u132_endp_urb_dequeue(u132, endp, urb, status);
                 }
         }
 }
@@ -2805,7 +2865,7 @@ static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 return -ESHUTDOWN;
         } else {
                 int retval = 0;
-                down(&u132->sw_lock);
+                mutex_lock(&u132->sw_lock);
                 switch (typeReq) {
                 case ClearHubFeature:
                         switch (wValue) {
@@ -2868,7 +2928,7 @@ static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                       stall:retval = -EPIPE;
                         break;
                 }
-                up(&u132->sw_lock);
+                mutex_unlock(&u132->sw_lock);
                 return retval;
         }
 }
@@ -3004,7 +3064,7 @@ static int __devexit u132_remove(struct platform_device *pdev)
                         dev_err(&u132->platform_dev->dev, "removing device u132"
                                 ".%d\n", u132->sequence_num);
                         msleep(100);
-                        down(&u132->sw_lock);
+                        mutex_lock(&u132->sw_lock);
                         u132_monitor_cancel_work(u132);
                         while (rings-- > 0) {
                                 struct u132_ring *ring = &u132->ring[rings];
@@ -3017,7 +3077,7 @@ static int __devexit u132_remove(struct platform_device *pdev)
                         u132->going += 1;
                         printk(KERN_INFO "removing device u132.%d\n",
                                 u132->sequence_num);
-                        up(&u132->sw_lock);
+                        mutex_unlock(&u132->sw_lock);
                         usb_remove_hcd(hcd);
                         u132_u132_put_kref(u132);
                         return 0;
@@ -3037,7 +3097,7 @@ static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
         u132->platform_dev = pdev;
         u132->power = 0;
         u132->reset = 0;
-        init_MUTEX(&u132->sw_lock);
+        mutex_init(&u132->sw_lock);
         init_MUTEX(&u132->scheduler_lock);
         while (rings-- > 0) {
                 struct u132_ring *ring = &u132->ring[rings];
@@ -3047,7 +3107,7 @@ static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
                 ring->curr_endp = NULL;
                 INIT_DELAYED_WORK(&ring->scheduler,
                                   u132_hcd_ring_work_scheduler);
-        } down(&u132->sw_lock);
+        } mutex_lock(&u132->sw_lock);
         INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
         while (ports-- > 0) {
                 struct u132_port *port = &u132->port[ports];
@@ -3077,7 +3137,7 @@ static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
         while (endps-- > 0) {
                 u132->endp[endps] = NULL;
         }
-        up(&u132->sw_lock);
+        mutex_unlock(&u132->sw_lock);
         return;
 }
 
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 1497371583..20cc58b978 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -120,8 +120,8 @@ 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);
 
-        if (urbp->urb->status != -EINPROGRESS)
-                out += sprintf(out, " Status=%d", urbp->urb->status);
+        if (urbp->urb->unlinked)
+                out += sprintf(out, " Unlinked=%d", urbp->urb->unlinked);
         out += sprintf(out, "\n");
 
         i = nactive = ninactive = 0;
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 1b3d23406a..340d6ed3e6 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -146,7 +146,6 @@ struct uhci_qh {
         short phase;                    /* Between 0 and period-1 */
         short load;                     /* Periodic time requirement, in us */
         unsigned int iso_frame;         /* Frame # for iso_packet_desc */
-        int iso_status;                 /* Status for Isochronous URBs */
 
         int state;                      /* QH_STATE_xxx; see above */
         int type;                       /* Queue type (control, bulk, etc) */
@@ -457,21 +456,6 @@ struct urb_priv {
 };
 
 
-/*
- * Locking in uhci.c
- *
- * Almost everything relating to the hardware schedule and processing
- * of URBs is protected by uhci->lock.  urb->status is protected by
- * urb->lock; that's the one exception.
- *
- * To prevent deadlocks, never lock uhci->lock while holding urb->lock.
- * The safe order of locking is:
- *
- * #1 uhci->lock
- * #2 urb->lock
- */
-
-
 /* Some special IDs */
 
 #define PCI_VENDOR_ID_GENESYS           0x17a0
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 3bb908ca38..e5d60d5b10 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -757,7 +757,6 @@ static void uhci_free_urb_priv(struct uhci_hcd *uhci,
                 uhci_free_td(uhci, td);
         }
 
-        urbp->urb->hcpriv = NULL;
         kmem_cache_free(uhci_up_cachep, urbp);
 }
 
@@ -1324,7 +1323,6 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
         if (list_empty(&qh->queue)) {
                 qh->iso_packet_desc = &urb->iso_frame_desc[0];
                 qh->iso_frame = urb->start_frame;
-                qh->iso_status = 0;
         }
 
         qh->skel = SKEL_ISO;
@@ -1361,22 +1359,18 @@ static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
                         qh->iso_packet_desc->actual_length = actlength;
                         qh->iso_packet_desc->status = status;
                 }
-
-                if (status) {
+                if (status)
                         urb->error_count++;
-                        qh->iso_status = status;
-                }
 
                 uhci_remove_td_from_urbp(td);
                 uhci_free_td(uhci, td);
                 qh->iso_frame += qh->period;
                 ++qh->iso_packet_desc;
         }
-        return qh->iso_status;
+        return 0;
 }
 
 static int uhci_urb_enqueue(struct usb_hcd *hcd,
-                struct usb_host_endpoint *hep,
                 struct urb *urb, gfp_t mem_flags)
 {
         int ret;
@@ -1387,19 +1381,19 @@ static int uhci_urb_enqueue(struct usb_hcd *hcd,
 
         spin_lock_irqsave(&uhci->lock, flags);
 
-        ret = urb->status;
-        if (ret != -EINPROGRESS)                /* URB already unlinked! */
-                goto done;
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret)
+                goto done_not_linked;
 
         ret = -ENOMEM;
         urbp = uhci_alloc_urb_priv(uhci, urb);
         if (!urbp)
                 goto done;
 
-        if (hep->hcpriv)
-                qh = (struct uhci_qh *) hep->hcpriv;
+        if (urb->ep->hcpriv)
+                qh = urb->ep->hcpriv;
         else {
-                qh = uhci_alloc_qh(uhci, urb->dev, hep);
+                qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
                 if (!qh)
                         goto err_no_qh;
         }
@@ -1440,27 +1434,29 @@ static int uhci_urb_enqueue(struct usb_hcd *hcd,
 err_submit_failed:
         if (qh->state == QH_STATE_IDLE)
                 uhci_make_qh_idle(uhci, qh);    /* Reclaim unused QH */
-
 err_no_qh:
         uhci_free_urb_priv(uhci, urbp);
-
 done:
+        if (ret)
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+done_not_linked:
         spin_unlock_irqrestore(&uhci->lock, flags);
         return ret;
 }
 
-static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 {
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
         unsigned long flags;
-        struct urb_priv *urbp;
         struct uhci_qh *qh;
+        int rc;
 
         spin_lock_irqsave(&uhci->lock, flags);
-        urbp = urb->hcpriv;
-        if (!urbp)                      /* URB was never linked! */
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
                 goto done;
-        qh = urbp->qh;
+
+        qh = ((struct urb_priv *) urb->hcpriv)->qh;
 
         /* Remove Isochronous TDs from the frame list ASAP */
         if (qh->type == USB_ENDPOINT_XFER_ISOC) {
@@ -1477,14 +1473,14 @@ static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
 
 done:
         spin_unlock_irqrestore(&uhci->lock, flags);
-        return 0;
+        return rc;
 }
 
 /*
  * Finish unlinking an URB and give it back
  */
 static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
-                struct urb *urb)
+                struct urb *urb, int status)
 __releases(uhci->lock)
 __acquires(uhci->lock)
 {
@@ -1497,13 +1493,6 @@ __acquires(uhci->lock)
                  * unlinked first.  Regardless, don't confuse people with a
                  * negative length. */
                 urb->actual_length = max(urb->actual_length, 0);
-
-                /* Report erroneous short transfers */
-                if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
-                                urb->actual_length <
-                                        urb->transfer_buffer_length &&
-                                urb->status == 0))
-                        urb->status = -EREMOTEIO;
         }
 
         /* When giving back the first URB in an Isochronous queue,
@@ -1516,7 +1505,6 @@ __acquires(uhci->lock)
 
                 qh->iso_packet_desc = &nurb->iso_frame_desc[0];
                 qh->iso_frame = nurb->start_frame;
-                qh->iso_status = 0;
         }
 
         /* Take the URB off the QH's queue.  If the queue is now empty,
@@ -1529,9 +1517,10 @@ __acquires(uhci->lock)
         }
 
         uhci_free_urb_priv(uhci, urbp);
+        usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
 
         spin_unlock(&uhci->lock);
-        usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb);
+        usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status);
         spin_lock(&uhci->lock);
 
         /* If the queue is now empty, we can unlink the QH and give up its
@@ -1567,24 +1556,17 @@ static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
                 if (status == -EINPROGRESS)
                         break;
 
-                spin_lock(&urb->lock);
-                if (urb->status == -EINPROGRESS)        /* Not dequeued */
-                        urb->status = status;
-                else
-                        status = ECONNRESET;            /* Not -ECONNRESET */
-                spin_unlock(&urb->lock);
-
                 /* Dequeued but completed URBs can't be given back unless
                  * the QH is stopped or has finished unlinking. */
-                if (status == ECONNRESET) {
+                if (urb->unlinked) {
                         if (QH_FINISHED_UNLINKING(qh))
                                 qh->is_stopped = 1;
                         else if (!qh->is_stopped)
                                 return;
                 }
 
-                uhci_giveback_urb(uhci, qh, urb);
-                if (status < 0 && qh->type != USB_ENDPOINT_XFER_ISOC)
+                uhci_giveback_urb(uhci, qh, urb, status);
+                if (status < 0)
                         break;
         }
 
@@ -1599,7 +1581,7 @@ static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
 restart:
         list_for_each_entry(urbp, &qh->queue, node) {
                 urb = urbp->urb;
-                if (urb->status != -EINPROGRESS) {
+                if (urb->unlinked) {
 
                         /* Fix up the TD links and save the toggles for
                          * non-Isochronous queues.  For Isochronous queues,
@@ -1608,7 +1590,7 @@ restart:
                                 qh->is_stopped = 0;
                                 return;
                         }
-                        uhci_giveback_urb(uhci, qh, urb);
+                        uhci_giveback_urb(uhci, qh, urb, 0);
                         goto restart;
                 }
         }
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index e9fdbc8997..5131cbfb2f 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -188,7 +188,8 @@ static void adu_interrupt_in_callback(struct urb *urb)
         spin_lock(&dev->buflock);
 
         if (status != 0) {
-                if ((status != -ENOENT) && (status != -ECONNRESET)) {
+                if ((status != -ENOENT) && (status != -ECONNRESET) &&
+                        (status != -ESHUTDOWN)) {
                         dbg(1," %s : nonzero status received: %d",
                             __FUNCTION__, status);
                 }
diff --git a/drivers/usb/misc/berry_charge.c b/drivers/usb/misc/berry_charge.c
index 92c1d2768d..24e2dc3148 100644
--- a/drivers/usb/misc/berry_charge.c
+++ b/drivers/usb/misc/berry_charge.c
@@ -71,7 +71,7 @@ static int magic_charge(struct usb_device *udev)
         if (retval != 2) {
                 dev_err(&udev->dev, "First magic command failed: %d.\n",
                         retval);
-                return retval;
+                goto exit;
         }
 
         dbg(&udev->dev, "Sending second magic command\n");
@@ -80,7 +80,7 @@ static int magic_charge(struct usb_device *udev)
         if (retval != 0) {
                 dev_err(&udev->dev, "Second magic command failed: %d.\n",
                         retval);
-                return retval;
+                goto exit;
         }
 
         dbg(&udev->dev, "Calling set_configuration\n");
@@ -88,6 +88,8 @@ static int magic_charge(struct usb_device *udev)
         if (retval)
                 dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
 
+exit:
+        kfree(dummy_buffer);
         return retval;
 }
 
@@ -112,6 +114,7 @@ static int magic_dual_mode(struct usb_device *udev)
         if (retval)
                 dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
 
+        kfree(dummy_buffer);
         return retval;
 }
 
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index 538b535e95..d3d8cd6ff1 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -2777,12 +2777,14 @@ static int ftdi_elan_probe(struct usb_interface *interface,
         size_t buffer_size;
         int i;
         int retval = -ENOMEM;
-        struct usb_ftdi *ftdi = kmalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
-        if (ftdi == NULL) {
+        struct usb_ftdi *ftdi;
+
+        ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
+        if (!ftdi) {
                 printk(KERN_ERR "Out of memory\n");
                 return -ENOMEM;
         }
-        memset(ftdi, 0x00, sizeof(struct usb_ftdi));
+
         mutex_lock(&ftdi_module_lock);
         list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
         ftdi->sequence_num = ++ftdi_instances;
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index b64ca91d9b..9244d067ce 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -32,7 +32,7 @@
  * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  *
  */
 
@@ -962,12 +962,12 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                            packet.address = 0x00000194;
                            packet.data    = addr;
                            ret = sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
+                                                                &packet, 0);
                            packet.header  = 0x001f;
                            packet.address = 0x00000190;
                            packet.data    = (length & ~3);
                            ret |= sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
+                                                                &packet, 0);
                            if (sisusb->flagb0 != 0x16) {
                                 packet.header  = 0x001f;
                                 packet.address = 0x00000180;
@@ -1003,23 +1003,17 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                         if (ret) {
                                 msgcount++;
                                 if (msgcount < 500)
-                                        printk(KERN_ERR
-                                                "sisusbvga[%d]: Wrote %zd of "
-                                                "%d bytes, error %d\n",
-                                                sisusb->minor, *bytes_written,
-                                                length, ret);
+                                        dev_err(&sisusb->sisusb_dev->dev, "Wrote %zd of %d bytes, error %d\n",
+                                                *bytes_written, length, ret);
                                 else if (msgcount == 500)
-                                        printk(KERN_ERR
-                                                "sisusbvga[%d]: Too many errors"
-                                                ", logging stopped\n",
-                                                sisusb->minor);
+                                        dev_err(&sisusb->sisusb_dev->dev, "Too many errors, logging stopped\n");
                         }
                         addr += (*bytes_written);
                         length -= (*bytes_written);
             }
 
             if (ret)
-                break;
+                break;
 
         }
 
@@ -1261,51 +1255,10 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                                 addr += 4;
                                 length -= 4;
                         }
-#if 0           /* That does not work, as EP 2 is an OUT EP! */
-                default:
-                        CLEARPACKET(&packet);
-                        packet.header  = 0x001f;
-                        packet.address = 0x000001a0;
-                        packet.data    = 0x00000006;
-                        ret |= sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
-                        packet.header  = 0x001f;
-                        packet.address = 0x000001b0;
-                        packet.data    = (length & ~3) | 0x40000000;
-                        ret |= sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
-                        packet.header  = 0x001f;
-                        packet.address = 0x000001b4;
-                        packet.data    = addr;
-                        ret |= sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
-                        packet.header  = 0x001f;
-                        packet.address = 0x000001a4;
-                        packet.data    = 0x00000001;
-                        ret |= sisusb_send_bridge_packet(sisusb, 10,
-                                                                &packet, 0);
-                        if (userbuffer) {
-                                ret |= sisusb_recv_bulk_msg(sisusb,
-                                                        SISUSB_EP_GFX_BULK_IN,
-                                                        (length & ~3),
-                                                        NULL, userbuffer,
-                                                        bytes_read, 0);
-                                if (!ret) userbuffer += (*bytes_read);
-                        } else {
-                                ret |= sisusb_recv_bulk_msg(sisusb,
-                                                        SISUSB_EP_GFX_BULK_IN,
-                                                        (length & ~3),
-                                                        kernbuffer, NULL,
-                                                        bytes_read, 0);
-                                if (!ret) kernbuffer += (*bytes_read);
-                        }
-                        addr += (*bytes_read);
-                        length -= (*bytes_read);
-#endif
             }
 
             if (ret)
-                break;
+                break;
         }
 
         return ret;
@@ -1401,22 +1354,6 @@ sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data)
         return(sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
 }
 
-#if 0
-
-int
-sisusb_writew(struct sisusb_usb_data *sisusb, u32 adr, u16 data)
-{
-        return(sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
-}
-
-int
-sisusb_readw(struct sisusb_usb_data *sisusb, u32 adr, u16 *data)
-{
-        return(sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
-}
-
-#endif  /*  0  */
-
 int
 sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
                         u32 dest, int length, size_t *bytes_written)
@@ -1446,10 +1383,10 @@ sisusb_testreadwrite(struct sisusb_usb_data *sisusb)
     sisusb_copy_memory(sisusb, srcbuffer, sisusb->vrambase, 7, &dummy);
 
     for(i = 1; i <= 7; i++) {
-        printk(KERN_DEBUG "sisusb: rwtest %d bytes\n", i);
+        dev_dbg(&sisusb->sisusb_dev->dev, "sisusb: rwtest %d bytes\n", i);
         sisusb_read_memory(sisusb, destbuffer, sisusb->vrambase, i, &dummy);
         for(j = 0; j < i; j++) {
-             printk(KERN_DEBUG "sisusb: rwtest read[%d] = %x\n", j, destbuffer[j]);
+             dev_dbg(&sisusb->sisusb_dev->dev, "rwtest read[%d] = %x\n", j, destbuffer[j]);
         }
     }
 }
@@ -1533,9 +1470,9 @@ sisusb_clear_vram(struct sisusb_usb_data *sisusb, u32 address, int length)
 #define SETIREGAND(r,i,a)       sisusb_setidxregand(sisusb, r, i, a)
 #define SETIREGANDOR(r,i,a,o)   sisusb_setidxregandor(sisusb, r, i, a, o)
 #define READL(a,d)      sisusb_read_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
-#define WRITEL(a,d)     sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
+#define WRITEL(a,d)     sisusb_write_memio_long(sisusb, SISUSB_TYPE_MEM, a, d)
 #define READB(a,d)      sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
-#define WRITEB(a,d)     sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
+#define WRITEB(a,d)     sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, a, d)
 
 static int
 sisusb_triggersr16(struct sisusb_usb_data *sisusb, u8 ramtype)
@@ -2008,7 +1945,7 @@ sisusb_set_default_mode(struct sisusb_usb_data *sisusb, int touchengines)
                 SETIREG(SISSR, 0x26, 0x00);
         }
 
-        SETIREG(SISCR, 0x34, 0x44);     /* we just set std mode #44 */
+        SETIREG(SISCR, 0x34, 0x44);     /* we just set std mode #44 */
 
         return ret;
 }
@@ -2168,17 +2105,12 @@ sisusb_init_gfxcore(struct sisusb_usb_data *sisusb)
                 if (ramtype <= 1) {
                         ret |= sisusb_get_sdram_size(sisusb, &iret, bw, chab);
                         if (iret) {
-                                printk(KERN_ERR "sisusbvga[%d]: RAM size "
-                                        "detection failed, "
-                                        "assuming 8MB video RAM\n",
-                                        sisusb->minor);
+                                dev_err(&sisusb->sisusb_dev->dev,"RAM size detection failed, assuming 8MB video RAM\n");
                                 ret |= SETIREG(SISSR,0x14,0x31);
                                 /* TODO */
                         }
                 } else {
-                        printk(KERN_ERR "sisusbvga[%d]: DDR RAM device found, "
-                                        "assuming 8MB video RAM\n",
-                                        sisusb->minor);
+                        dev_err(&sisusb->sisusb_dev->dev, "DDR RAM device found, assuming 8MB video RAM\n");
                         ret |= SETIREG(SISSR,0x14,0x31);
                         /* *** TODO *** */
                 }
@@ -2249,8 +2181,7 @@ sisusb_get_ramconfig(struct sisusb_usb_data *sisusb)
                 break;
         }
 
-        printk(KERN_INFO "sisusbvga[%d]: %dMB %s %s, bus width %d\n",
-                        sisusb->minor, (sisusb->vramsize >> 20), ramtypetext1,
+        dev_info(&sisusb->sisusb_dev->dev, "%dMB %s %s, bus width %d\n", (sisusb->vramsize >> 20), ramtypetext1,
                         ramtypetext2[ramtype], bw);
 }
 
@@ -2509,11 +2440,8 @@ sisusb_open(struct inode *inode, struct file *file)
         struct usb_interface *interface;
         int subminor = iminor(inode);
 
-        if (!(interface = usb_find_interface(&sisusb_driver, subminor))) {
-                printk(KERN_ERR "sisusb[%d]: Failed to find interface\n",
-                                subminor);
+        if (!(interface = usb_find_interface(&sisusb_driver, subminor)))
                 return -ENODEV;
-        }
 
         if (!(sisusb = usb_get_intfdata(interface)))
                 return -ENODEV;
@@ -2534,18 +2462,12 @@ sisusb_open(struct inode *inode, struct file *file)
                 if (sisusb->sisusb_dev->speed == USB_SPEED_HIGH) {
                         if (sisusb_init_gfxdevice(sisusb, 0)) {
                                 mutex_unlock(&sisusb->lock);
-                                printk(KERN_ERR
-                                        "sisusbvga[%d]: Failed to initialize "
-                                        "device\n",
-                                        sisusb->minor);
+                                dev_err(&sisusb->sisusb_dev->dev, "Failed to initialize device\n");
                                 return -EIO;
                         }
                 } else {
                         mutex_unlock(&sisusb->lock);
-                        printk(KERN_ERR
-                                "sisusbvga[%d]: Device not attached to "
-                                "USB 2.0 hub\n",
-                                sisusb->minor);
+                        dev_err(&sisusb->sisusb_dev->dev, "Device not attached to USB 2.0 hub\n");
                         return -EIO;
                 }
         }
@@ -2586,7 +2508,6 @@ static int
 sisusb_release(struct inode *inode, struct file *file)
 {
         struct sisusb_usb_data *sisusb;
-        int myminor;
 
         if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
                 return -ENODEV;
@@ -2599,8 +2520,6 @@ sisusb_release(struct inode *inode, struct file *file)
                         sisusb_kill_all_busy(sisusb);
         }
 
-        myminor = sisusb->minor;
-
         sisusb->isopen = 0;
         file->private_data = NULL;
 
@@ -2942,7 +2861,7 @@ static int
 sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
                                                         unsigned long arg)
 {
-        int     retval, port, length;
+        int     retval, port, length;
         u32     address;
 
         /* All our commands require the device
@@ -3065,12 +2984,12 @@ sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
 
 static int
 sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                                                        unsigned long arg)
+                                                        unsigned long arg)
 {
         struct sisusb_usb_data *sisusb;
         struct sisusb_info x;
         struct sisusb_command y;
-        int     retval = 0;
+        int     retval = 0;
         u32 __user *argp = (u32 __user *)arg;
 
         if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
@@ -3095,7 +3014,7 @@ sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
                 case SISUSB_GET_CONFIG:
 
-                        x.sisusb_id         = SISUSB_ID;
+                        x.sisusb_id         = SISUSB_ID;
                         x.sisusb_version    = SISUSB_VERSION;
                         x.sisusb_revision   = SISUSB_REVISION;
                         x.sisusb_patchlevel = SISUSB_PATCHLEVEL;
@@ -3164,7 +3083,7 @@ static const struct file_operations usb_sisusb_fops = {
         .release =      sisusb_release,
         .read =         sisusb_read,
         .write =        sisusb_write,
-        .llseek =       sisusb_lseek,
+        .llseek =       sisusb_lseek,
 #ifdef SISUSB_NEW_CONFIG_COMPAT
         .compat_ioctl = sisusb_compat_ioctl,
 #endif
@@ -3183,17 +3102,13 @@ static int sisusb_probe(struct usb_interface *intf,
         struct usb_device *dev = interface_to_usbdev(intf);
         struct sisusb_usb_data *sisusb;
         int retval = 0, i;
-        const char *memfail =
-                KERN_ERR
-                "sisusbvga[%d]: Failed to allocate memory for %s buffer\n";
 
-        printk(KERN_INFO "sisusb: USB2VGA dongle found at address %d\n",
+        dev_info(&dev->dev, "USB2VGA dongle found at address %d\n",
                 dev->devnum);
 
         /* Allocate memory for our private */
         if (!(sisusb = kzalloc(sizeof(*sisusb), GFP_KERNEL))) {
-                printk(KERN_ERR
-                        "sisusb: Failed to allocate memory for private data\n");
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for private data\n");
                 return -ENOMEM;
         }
         kref_init(&sisusb->kref);
@@ -3202,8 +3117,7 @@ static int sisusb_probe(struct usb_interface *intf,
 
         /* Register device */
         if ((retval = usb_register_dev(intf, &usb_sisusb_class))) {
-                printk(KERN_ERR
-                        "sisusb: Failed to get a minor for device %d\n",
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to get a minor for device %d\n",
                         dev->devnum);
                 retval = -ENODEV;
                 goto error_1;
@@ -3221,7 +3135,7 @@ static int sisusb_probe(struct usb_interface *intf,
         sisusb->ibufsize = SISUSB_IBUF_SIZE;
         if (!(sisusb->ibuf = usb_buffer_alloc(dev, SISUSB_IBUF_SIZE,
                                         GFP_KERNEL, &sisusb->transfer_dma_in))) {
-                printk(memfail, "input", sisusb->minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for input buffer");
                 retval = -ENOMEM;
                 goto error_2;
         }
@@ -3233,7 +3147,7 @@ static int sisusb_probe(struct usb_interface *intf,
                                         GFP_KERNEL,
                                         &sisusb->transfer_dma_out[i]))) {
                         if (i == 0) {
-                                printk(memfail, "output", sisusb->minor);
+                                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for output buffer\n");
                                 retval = -ENOMEM;
                                 goto error_3;
                         }
@@ -3245,9 +3159,7 @@ static int sisusb_probe(struct usb_interface *intf,
 
         /* Allocate URBs */
         if (!(sisusb->sisurbin = usb_alloc_urb(0, GFP_KERNEL))) {
-                printk(KERN_ERR
-                        "sisusbvga[%d]: Failed to allocate URBs\n",
-                        sisusb->minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate URBs\n");
                 retval = -ENOMEM;
                 goto error_3;
         }
@@ -3255,9 +3167,7 @@ static int sisusb_probe(struct usb_interface *intf,
 
         for (i = 0; i < sisusb->numobufs; i++) {
                 if (!(sisusb->sisurbout[i] = usb_alloc_urb(0, GFP_KERNEL))) {
-                        printk(KERN_ERR
-                                "sisusbvga[%d]: Failed to allocate URBs\n",
-                                sisusb->minor);
+                        dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate URBs\n");
                         retval = -ENOMEM;
                         goto error_4;
                 }
@@ -3266,15 +3176,12 @@ static int sisusb_probe(struct usb_interface *intf,
                 sisusb->urbstatus[i] = 0;
         }
 
-        printk(KERN_INFO "sisusbvga[%d]: Allocated %d output buffers\n",
-                                        sisusb->minor, sisusb->numobufs);
+        dev_info(&sisusb->sisusb_dev->dev, "Allocated %d output buffers\n", sisusb->numobufs);
 
 #ifdef INCL_SISUSB_CON
         /* Allocate our SiS_Pr */
         if (!(sisusb->SiS_Pr = kmalloc(sizeof(struct SiS_Private), GFP_KERNEL))) {
-                printk(KERN_ERR
-                        "sisusbvga[%d]: Failed to allocate SiS_Pr\n",
-                        sisusb->minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate SiS_Pr\n");
         }
 #endif
 
@@ -3296,10 +3203,7 @@ static int sisusb_probe(struct usb_interface *intf,
         ret |= register_ioctl32_conversion(SISUSB_GET_CONFIG,      NULL);
         ret |= register_ioctl32_conversion(SISUSB_COMMAND,         NULL);
         if (ret)
-                printk(KERN_ERR
-                        "sisusbvga[%d]: Error registering ioctl32 "
-                        "translations\n",
-                        sisusb->minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Error registering ioctl32 translations\n");
         else
                 sisusb->ioctl32registered = 1;
         }
@@ -3315,23 +3219,17 @@ static int sisusb_probe(struct usb_interface *intf,
                         initscreen = 0;
 #endif
                 if (sisusb_init_gfxdevice(sisusb, initscreen))
-                        printk(KERN_ERR
-                                "sisusbvga[%d]: Failed to early "
-                                "initialize device\n",
-                                sisusb->minor);
+                        dev_err(&sisusb->sisusb_dev->dev, "Failed to early initialize device\n");
 
         } else
-                printk(KERN_INFO
-                        "sisusbvga[%d]: Not attached to USB 2.0 hub, "
-                        "deferring init\n",
-                        sisusb->minor);
+                dev_info(&sisusb->sisusb_dev->dev, "Not attached to USB 2.0 hub, deferring init\n");
 
         sisusb->ready = 1;
 
 #ifdef SISUSBENDIANTEST
-        printk(KERN_DEBUG "sisusb: *** RWTEST ***\n");
+        dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST ***\n");
         sisusb_testreadwrite(sisusb);
-        printk(KERN_DEBUG "sisusb: *** RWTEST END ***\n");
+        dev_dbg(&sisusb->sisusb_dev->dev, "*** RWTEST END ***\n");
 #endif
 
 #ifdef INCL_SISUSB_CON
@@ -3354,7 +3252,6 @@ error_1:
 static void sisusb_disconnect(struct usb_interface *intf)
 {
         struct sisusb_usb_data *sisusb;
-        int minor;
 
         /* This should *not* happen */
         if (!(sisusb = usb_get_intfdata(intf)))
@@ -3364,8 +3261,6 @@ static void sisusb_disconnect(struct usb_interface *intf)
         sisusb_console_exit(sisusb);
 #endif
 
-        minor = sisusb->minor;
-
         usb_deregister_dev(intf, &usb_sisusb_class);
 
         mutex_lock(&sisusb->lock);
@@ -3384,10 +3279,7 @@ static void sisusb_disconnect(struct usb_interface *intf)
                 ret |= unregister_ioctl32_conversion(SISUSB_GET_CONFIG);
                 ret |= unregister_ioctl32_conversion(SISUSB_COMMAND);
                 if (ret) {
-                        printk(KERN_ERR
-                                "sisusbvga[%d]: Error unregistering "
-                                "ioctl32 translations\n",
-                                minor);
+                        dev_err(&sisusb->sisusb_dev->dev, "Error unregistering ioctl32 translations\n");
                 }
         }
 #endif
@@ -3400,7 +3292,7 @@ static void sisusb_disconnect(struct usb_interface *intf)
         /* decrement our usage count */
         kref_put(&sisusb->kref, sisusb_delete);
 
-        printk(KERN_INFO "sisusbvga[%d]: Disconnected\n", minor);
+        dev_info(&sisusb->sisusb_dev->dev, "Disconnected\n");
 }
 
 static struct usb_device_id sisusb_table [] = {
@@ -3424,22 +3316,12 @@ static struct usb_driver sisusb_driver = {
 
 static int __init usb_sisusb_init(void)
 {
-        int retval;
 
 #ifdef INCL_SISUSB_CON
         sisusb_init_concode();
 #endif
 
-        if (!(retval = usb_register(&sisusb_driver))) {
-
-                printk(KERN_INFO "sisusb: Driver version %d.%d.%d\n",
-                        SISUSB_VERSION, SISUSB_REVISION, SISUSB_PATCHLEVEL);
-                printk(KERN_INFO
-                        "sisusb: Copyright (C) 2005 Thomas Winischhofer\n");
-
-        }
-
-        return retval;
+        return usb_register(&sisusb_driver);
 }
 
 static void __exit usb_sisusb_exit(void)
diff --git a/drivers/usb/misc/sisusbvga/sisusb.h b/drivers/usb/misc/sisusbvga/sisusb.h
index 8e1120a648..d2d7872cd0 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.h
+++ b/drivers/usb/misc/sisusbvga/sisusb.h
@@ -8,29 +8,29 @@
  *
  * Otherwise, the following license terms apply:
  *
- * * Redistribution and use in source and binary forms, with or without
- * * modification, are permitted provided that the following conditions
- * * are met:
- * * 1) Redistributions of source code must retain the above copyright
- * *    notice, this list of conditions and the following disclaimer.
- * * 2) Redistributions in binary form must reproduce the above copyright
- * *    notice, this list of conditions and the following disclaimer in the
- * *    documentation and/or other materials provided with the distribution.
- * * 3) The name of the author may not be used to endorse or promote products
- * *    derived from this software without specific prior written permission.
- * *
- * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
- * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1) Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2) Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3) The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
  *
- * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  *
  */
 
@@ -44,16 +44,14 @@
 #include <linux/mutex.h>
 
 /* For older kernels, support for text consoles is by default
- * off. To ensable text console support, change the following:
+ * off. To enable text console support, change the following:
  */
-#if 0
-#define CONFIG_USB_SISUSBVGA_CON
-#endif
+/* #define CONFIG_USB_SISUSBVGA_CON */
 
 /* Version Information */
 
 #define SISUSB_VERSION          0
-#define SISUSB_REVISION         0
+#define SISUSB_REVISION         0
 #define SISUSB_PATCHLEVEL       8
 
 /* Include console and mode switching code? */
@@ -74,7 +72,7 @@
 #define SISUSB_IBUF_SIZE  0x01000
 #define SISUSB_OBUF_SIZE  0x10000       /* fixed */
 
-#define NUMOBUFS 8                      /* max number of output buffers/output URBs */
+#define NUMOBUFS 8              /* max number of output buffers/output URBs */
 
 /* About endianness:
  *
@@ -93,7 +91,7 @@
  */
 
 #ifdef __BIG_ENDIAN
-#define SISUSB_CORRECT_ENDIANNESS_PACKET(p)             \
+#define SISUSB_CORRECT_ENDIANNESS_PACKET(p)             \
         do {                                            \
                 p->header  = cpu_to_le16(p->header);    \
                 p->address = cpu_to_le32(p->address);   \
@@ -105,7 +103,7 @@
 
 struct sisusb_usb_data;
 
-struct sisusb_urb_context {             /* urb->context for outbound bulk URBs */
+struct sisusb_urb_context {     /* urb->context for outbound bulk URBs */
         struct sisusb_usb_data *sisusb;
         int urbindex;
         int *actual_length;
@@ -116,16 +114,16 @@ struct sisusb_usb_data {
         struct usb_interface *interface;
         struct kref kref;
         wait_queue_head_t wait_q;       /* for syncind and timeouts */
-        struct mutex lock;              /* general race avoidance */
-        unsigned int ifnum;             /* interface number of the USB device */
-        int minor;                      /* minor (for logging clarity) */
-        int isopen;                     /* !=0 if open */
-        int present;                    /* !=0 if device is present on the bus */
-        int ready;                      /* !=0 if device is ready for userland */
+        struct mutex lock;      /* general race avoidance */
+        unsigned int ifnum;     /* interface number of the USB device */
+        int minor;              /* minor (for logging clarity) */
+        int isopen;             /* !=0 if open */
+        int present;            /* !=0 if device is present on the bus */
+        int ready;              /* !=0 if device is ready for userland */
 #ifdef SISUSB_OLD_CONFIG_COMPAT
         int ioctl32registered;
 #endif
-        int numobufs;                   /* number of obufs = number of out urbs */
+        int numobufs;           /* number of obufs = number of out urbs */
         char *obuf[NUMOBUFS], *ibuf;    /* transfer buffers */
         int obufsize, ibufsize;
         dma_addr_t transfer_dma_out[NUMOBUFS];
@@ -136,13 +134,13 @@ struct sisusb_usb_data {
         unsigned char completein;
         struct sisusb_urb_context urbout_context[NUMOBUFS];
         unsigned long flagb0;
-        unsigned long vrambase;         /* framebuffer base */
-        unsigned int vramsize;          /* framebuffer size (bytes) */
+        unsigned long vrambase; /* framebuffer base */
+        unsigned int vramsize;  /* framebuffer size (bytes) */
         unsigned long mmiobase;
         unsigned int mmiosize;
         unsigned long ioportbase;
-        unsigned char devinit;          /* device initialized? */
-        unsigned char gfxinit;          /* graphics core initialized? */
+        unsigned char devinit;  /* device initialized? */
+        unsigned char gfxinit;  /* graphics core initialized? */
         unsigned short chipid, chipvendor;
         unsigned short chiprevision;
 #ifdef INCL_SISUSB_CON
@@ -152,7 +150,7 @@ struct sisusb_usb_data {
         int haveconsole, con_first, con_last;
         int havethisconsole[MAX_NR_CONSOLES];
         int textmodedestroyed;
-        unsigned int sisusb_num_columns; /* real number, not vt's idea */
+        unsigned int sisusb_num_columns;        /* real number, not vt's idea */
         int cur_start_addr, con_rolled_over;
         int sisusb_cursor_loc, bad_cursor_pos;
         int sisusb_cursor_size_from;
@@ -197,7 +195,7 @@ struct sisusb_packet {
         unsigned short header;
         u32 address;
         u32 data;
-} __attribute__((__packed__));
+} __attribute__ ((__packed__));
 
 #define CLEARPACKET(packet) memset(packet, 0, 10)
 
@@ -265,36 +263,36 @@ struct sisusb_packet {
 
 /* Structure argument for SISUSB_GET_INFO ioctl  */
 struct sisusb_info {
-        __u32   sisusb_id;              /* for identifying sisusb */
-#define SISUSB_ID  0x53495355           /* Identify myself with 'SISU' */
-        __u8    sisusb_version;
-        __u8    sisusb_revision;
-        __u8    sisusb_patchlevel;
-        __u8    sisusb_gfxinit;         /* graphics core initialized? */
+        __u32 sisusb_id;        /* for identifying sisusb */
+#define SISUSB_ID  0x53495355   /* Identify myself with 'SISU' */
+        __u8 sisusb_version;
+        __u8 sisusb_revision;
+        __u8 sisusb_patchlevel;
+        __u8 sisusb_gfxinit;    /* graphics core initialized? */
 
-        __u32   sisusb_vrambase;
-        __u32   sisusb_mmiobase;
-        __u32   sisusb_iobase;
-        __u32   sisusb_pcibase;
+        __u32 sisusb_vrambase;
+        __u32 sisusb_mmiobase;
+        __u32 sisusb_iobase;
+        __u32 sisusb_pcibase;
 
-        __u32   sisusb_vramsize;        /* framebuffer size in bytes */
+        __u32 sisusb_vramsize;  /* framebuffer size in bytes */
 
-        __u32   sisusb_minor;
+        __u32 sisusb_minor;
 
-        __u32   sisusb_fbdevactive;     /* != 0 if framebuffer device active */
+        __u32 sisusb_fbdevactive;       /* != 0 if framebuffer device active */
 
-        __u32   sisusb_conactive;       /* != 0 if console driver active */
+        __u32 sisusb_conactive; /* != 0 if console driver active */
 
-        __u8    sisusb_reserved[28];    /* for future use */
+        __u8 sisusb_reserved[28];       /* for future use */
 };
 
 struct sisusb_command {
-        __u8   operation;       /* see below */
-        __u8   data0;           /* operation dependent */
-        __u8   data1;           /* operation dependent */
-        __u8   data2;           /* operation dependent */
-        __u32  data3;           /* operation dependent */
-        __u32  data4;           /* for future use */
+        __u8 operation;         /* see below */
+        __u8 data0;             /* operation dependent */
+        __u8 data1;             /* operation dependent */
+        __u8 data2;             /* operation dependent */
+        __u32 data3;            /* operation dependent */
+        __u32 data4;            /* for future use */
 };
 
 #define SUCMD_GET       0x01    /* for all: data0 = index, data3 = port */
@@ -306,7 +304,7 @@ struct sisusb_command {
 
 #define SUCMD_CLRSCR    0x07    /* data0:1:2 = length, data3 = address */
 
-#define SUCMD_HANDLETEXTMODE 0x08 /* Reset/destroy text mode */
+#define SUCMD_HANDLETEXTMODE 0x08       /* Reset/destroy text mode */
 
 #define SUCMD_SETMODE   0x09    /* Set a display mode (data3 = SiS mode) */
 #define SUCMD_SETVESAMODE 0x0a  /* Set a display mode (data3 = VESA mode) */
@@ -315,6 +313,4 @@ struct sisusb_command {
 #define SISUSB_GET_CONFIG_SIZE  _IOR(0xF3,0x3E,__u32)
 #define SISUSB_GET_CONFIG       _IOR(0xF3,0x3F,struct sisusb_info)
 
-
 #endif /* SISUSB_H */
-
diff --git a/drivers/usb/misc/sisusbvga/sisusb_con.c b/drivers/usb/misc/sisusbvga/sisusb_con.c
index 8d0edc867f..43722e5a49 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_con.c
+++ b/drivers/usb/misc/sisusbvga/sisusb_con.c
@@ -52,6 +52,7 @@
 #include <linux/kernel.h>
 #include <linux/signal.h>
 #include <linux/fs.h>
+#include <linux/usb.h>
 #include <linux/tty.h>
 #include <linux/console.h>
 #include <linux/string.h>
@@ -373,14 +374,6 @@ sisusbcon_putc(struct vc_data *c, int ch, int y, int x)
                 return;
 
         /* sisusb->lock is down */
-
-        /* Don't need to put the character into buffer ourselves,
-         * because the vt does this BEFORE calling us.
-         */
-#if 0
-        sisusbcon_writew(ch, SISUSB_VADDR(x, y));
-#endif
-
         if (sisusb_is_inactive(c, sisusb)) {
                 mutex_unlock(&sisusb->lock);
                 return;
@@ -490,10 +483,6 @@ sisusbcon_bmove(struct vc_data *c, int sy, int sx,
         struct sisusb_usb_data *sisusb;
         ssize_t written;
         int cols, length;
-#if 0
-        u16 *src, *dest;
-        int i;
-#endif
 
         if (width <= 0 || height <= 0)
                 return;
@@ -505,41 +494,6 @@ sisusbcon_bmove(struct vc_data *c, int sy, int sx,
 
         cols = sisusb->sisusb_num_columns;
 
-        /* Don't need to move data outselves, because
-         * vt does this BEFORE calling us.
-         * This is only used by vt's insert/deletechar.
-         */
-#if 0
-        if (sx == 0 && dx == 0 && width >= c->vc_cols && width <= cols) {
-
-                sisusbcon_memmovew(SISUSB_VADDR(0, dy), SISUSB_VADDR(0, sy),
-                                        height * width * 2);
-
-        } else if (dy < sy || (dy == sy && dx < sx)) {
-
-                src  = SISUSB_VADDR(sx, sy);
-                dest = SISUSB_VADDR(dx, dy);
-
-                for (i = height; i > 0; i--) {
-                        sisusbcon_memmovew(dest, src, width * 2);
-                        src  += cols;
-                        dest += cols;
-                }
-
-        } else {
-
-                src  = SISUSB_VADDR(sx, sy + height - 1);
-                dest = SISUSB_VADDR(dx, dy + height - 1);
-
-                for (i = height; i > 0; i--) {
-                        sisusbcon_memmovew(dest, src, width * 2);
-                        src  -= cols;
-                        dest -= cols;
-                }
-
-        }
-#endif
-
         if (sisusb_is_inactive(c, sisusb)) {
                 mutex_unlock(&sisusb->lock);
                 return;
@@ -584,7 +538,7 @@ sisusbcon_switch(struct vc_data *c)
          */
         if (c->vc_origin == (unsigned long)c->vc_screenbuf) {
                 mutex_unlock(&sisusb->lock);
-                printk(KERN_DEBUG "sisusb: ASSERT ORIGIN != SCREENBUF!\n");
+                dev_dbg(&sisusb->sisusb_dev->dev, "ASSERT ORIGIN != SCREENBUF!\n");
                 return 0;
         }
 
@@ -1475,7 +1429,7 @@ static const struct consw sisusb_dummy_con = {
 int
 sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
 {
-        int i, ret, minor = sisusb->minor;
+        int i, ret;
 
         mutex_lock(&sisusb->lock);
 
@@ -1508,9 +1462,7 @@ sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
         /* Set up text mode (and upload  default font) */
         if (sisusb_reset_text_mode(sisusb, 1)) {
                 mutex_unlock(&sisusb->lock);
-                printk(KERN_ERR
-                        "sisusbvga[%d]: Failed to set up text mode\n",
-                        minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to set up text mode\n");
                 return 1;
         }
 
@@ -1531,9 +1483,7 @@ sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
         /* Allocate screen buffer */
         if (!(sisusb->scrbuf = (unsigned long)vmalloc(sisusb->scrbuf_size))) {
                 mutex_unlock(&sisusb->lock);
-                printk(KERN_ERR
-                        "sisusbvga[%d]: Failed to allocate screen buffer\n",
-                        minor);
+                dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate screen buffer\n");
                 return 1;
         }
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb_init.c b/drivers/usb/misc/sisusbvga/sisusb_init.c
index 9b30f89628..273de5d093 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_init.c
+++ b/drivers/usb/misc/sisusbvga/sisusb_init.c
@@ -32,7 +32,7 @@
  * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  *
  */
 
@@ -55,109 +55,18 @@
 /*         POINTER INITIALIZATION            */
 /*********************************************/
 
-static void
-SiSUSB_InitPtr(struct SiS_Private *SiS_Pr)
+static void SiSUSB_InitPtr(struct SiS_Private *SiS_Pr)
 {
-        SiS_Pr->SiS_ModeResInfo   = SiSUSB_ModeResInfo;
-        SiS_Pr->SiS_StandTable    = SiSUSB_StandTable;
-
-        SiS_Pr->SiS_SModeIDTable  = SiSUSB_SModeIDTable;
-        SiS_Pr->SiS_EModeIDTable  = SiSUSB_EModeIDTable;
-        SiS_Pr->SiS_RefIndex      = SiSUSB_RefIndex;
-        SiS_Pr->SiS_CRT1Table     = SiSUSB_CRT1Table;
-
-        SiS_Pr->SiS_VCLKData      = SiSUSB_VCLKData;
-}
-
-/*********************************************/
-/*            HELPER: Get ModeID             */
-/*********************************************/
+        SiS_Pr->SiS_ModeResInfo = SiSUSB_ModeResInfo;
+        SiS_Pr->SiS_StandTable = SiSUSB_StandTable;
 
-#if 0
-unsigned short
-SiSUSB_GetModeID(int HDisplay, int VDisplay, int Depth)
-{
-        unsigned short ModeIndex = 0;
-
-        switch (HDisplay)
-        {
-                case 320:
-                        if (VDisplay == 200)
-                                ModeIndex = ModeIndex_320x200[Depth];
-                        else if (VDisplay == 240)
-                                ModeIndex = ModeIndex_320x240[Depth];
-                        break;
-                case 400:
-                        if (VDisplay == 300)
-                                ModeIndex = ModeIndex_400x300[Depth];
-                        break;
-                case 512:
-                        if (VDisplay == 384)
-                                ModeIndex = ModeIndex_512x384[Depth];
-                        break;
-                case 640:
-                        if (VDisplay == 480)
-                                ModeIndex = ModeIndex_640x480[Depth];
-                        else if (VDisplay == 400)
-                                ModeIndex = ModeIndex_640x400[Depth];
-                        break;
-                case 720:
-                        if (VDisplay == 480)
-                                ModeIndex = ModeIndex_720x480[Depth];
-                        else if (VDisplay == 576)
-                                ModeIndex = ModeIndex_720x576[Depth];
-                        break;
-                case 768:
-                        if (VDisplay == 576)
-                                ModeIndex = ModeIndex_768x576[Depth];
-                        break;
-                case 800:
-                        if (VDisplay == 600)
-                                ModeIndex = ModeIndex_800x600[Depth];
-                        else if (VDisplay == 480)
-                                ModeIndex = ModeIndex_800x480[Depth];
-                        break;
-                case 848:
-                        if (VDisplay == 480)
-                                ModeIndex = ModeIndex_848x480[Depth];
-                        break;
-                case 856:
-                        if (VDisplay == 480)
-                                ModeIndex = ModeIndex_856x480[Depth];
-                        break;
-                case 960:
-                        if (VDisplay == 540)
-                                ModeIndex = ModeIndex_960x540[Depth];
-                        else if (VDisplay == 600)
-                                ModeIndex = ModeIndex_960x600[Depth];
-                        break;
-                case 1024:
-                        if (VDisplay == 576)
-                                ModeIndex = ModeIndex_1024x576[Depth];
-                        else if (VDisplay == 768)
-                                ModeIndex = ModeIndex_1024x768[Depth];
-                        break;
-                case 1152:
-                        if (VDisplay == 864)
-                                ModeIndex = ModeIndex_1152x864[Depth];
-                        break;
-                case 1280:
-                        switch (VDisplay) {
-                                case 720:
-                                        ModeIndex = ModeIndex_1280x720[Depth];
-                                        break;
-                                case 768:
-                                        ModeIndex = ModeIndex_1280x768[Depth];
-                                        break;
-                                case 1024:
-                                        ModeIndex = ModeIndex_1280x1024[Depth];
-                                        break;
-                        }
-        }
+        SiS_Pr->SiS_SModeIDTable = SiSUSB_SModeIDTable;
+        SiS_Pr->SiS_EModeIDTable = SiSUSB_EModeIDTable;
+        SiS_Pr->SiS_RefIndex = SiSUSB_RefIndex;
+        SiS_Pr->SiS_CRT1Table = SiSUSB_CRT1Table;
 
-        return ModeIndex;
+        SiS_Pr->SiS_VCLKData = SiSUSB_VCLKData;
 }
-#endif  /*  0  */
 
 /*********************************************/
 /*          HELPER: SetReg, GetReg           */
@@ -165,21 +74,20 @@ SiSUSB_GetModeID(int HDisplay, int VDisplay, int Depth)
 
 static void
 SiS_SetReg(struct SiS_Private *SiS_Pr, unsigned long port,
-                        unsigned short index, unsigned short data)
+           unsigned short index, unsigned short data)
 {
         sisusb_setidxreg(SiS_Pr->sisusb, port, index, data);
 }
 
 static void
 SiS_SetRegByte(struct SiS_Private *SiS_Pr, unsigned long port,
-                                                unsigned short data)
+               unsigned short data)
 {
         sisusb_setreg(SiS_Pr->sisusb, port, data);
 }
 
 static unsigned char
-SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port,
-                                                unsigned short index)
+SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port, unsigned short index)
 {
         u8 data;
 
@@ -200,22 +108,22 @@ SiS_GetRegByte(struct SiS_Private *SiS_Pr, unsigned long port)
 
 static void
 SiS_SetRegANDOR(struct SiS_Private *SiS_Pr, unsigned long port,
-                        unsigned short index, unsigned short DataAND,
-                                                unsigned short DataOR)
+                unsigned short index, unsigned short DataAND,
+                unsigned short DataOR)
 {
         sisusb_setidxregandor(SiS_Pr->sisusb, port, index, DataAND, DataOR);
 }
 
 static void
 SiS_SetRegAND(struct SiS_Private *SiS_Pr, unsigned long port,
-                        unsigned short index, unsigned short DataAND)
+              unsigned short index, unsigned short DataAND)
 {
         sisusb_setidxregand(SiS_Pr->sisusb, port, index, DataAND);
 }
 
 static void
-SiS_SetRegOR(struct SiS_Private *SiS_Pr,unsigned long port,
-                        unsigned short index, unsigned short DataOR)
+SiS_SetRegOR(struct SiS_Private *SiS_Pr, unsigned long port,
+             unsigned short index, unsigned short DataOR)
 {
         sisusb_setidxregor(SiS_Pr->sisusb, port, index, DataOR);
 }
@@ -224,8 +132,7 @@ SiS_SetRegOR(struct SiS_Private *SiS_Pr,unsigned long port,
 /*      HELPER: DisplayOn, DisplayOff        */
 /*********************************************/
 
-static void
-SiS_DisplayOn(struct SiS_Private *SiS_Pr)
+static void SiS_DisplayOn(struct SiS_Private *SiS_Pr)
 {
         SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0xDF);
 }
@@ -234,8 +141,7 @@ SiS_DisplayOn(struct SiS_Private *SiS_Pr)
 /*        HELPER: Init Port Addresses        */
 /*********************************************/
 
-static void
-SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
+static void SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
 {
         SiS_Pr->SiS_P3c4 = BaseAddr + 0x14;
         SiS_Pr->SiS_P3d4 = BaseAddr + 0x24;
@@ -258,8 +164,7 @@ SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
 /*             HELPER: GetSysFlags           */
 /*********************************************/
 
-static void
-SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
+static void SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
 {
         SiS_Pr->SiS_MyCR63 = 0x63;
 }
@@ -268,8 +173,7 @@ SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
 /*         HELPER: Init PCI & Engines        */
 /*********************************************/
 
-static void
-SiSInitPCIetc(struct SiS_Private *SiS_Pr)
+static void SiSInitPCIetc(struct SiS_Private *SiS_Pr)
 {
         SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x20, 0xa1);
         /*  - Enable 2D (0x40)
@@ -285,8 +189,7 @@ SiSInitPCIetc(struct SiS_Private *SiS_Pr)
 /*        HELPER: SET SEGMENT REGISTERS      */
 /*********************************************/
 
-static void
-SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
+static void SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
 {
         unsigned short temp;
 
@@ -299,8 +202,7 @@ SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
         SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
 }
 
-static void
-SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
+static void SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
 {
         unsigned short temp;
 
@@ -313,15 +215,13 @@ SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
         SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
 }
 
-static void
-SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value)
+static void SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value)
 {
         SiS_SetSegRegLower(SiS_Pr, value);
         SiS_SetSegRegUpper(SiS_Pr, value);
 }
 
-static void
-SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr)
+static void SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr)
 {
         SiS_SetSegmentReg(SiS_Pr, 0);
 }
@@ -337,14 +237,12 @@ SiS_SetSegmentRegOver(struct SiS_Private *SiS_Pr, unsigned short value)
         SiS_SetSegmentReg(SiS_Pr, value);
 }
 
-static void
-SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr)
+static void SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr)
 {
         SiS_SetSegmentRegOver(SiS_Pr, 0);
 }
 
-static void
-SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
+static void SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
 {
         SiS_ResetSegmentReg(SiS_Pr);
         SiS_ResetSegmentRegOver(SiS_Pr);
@@ -356,7 +254,7 @@ SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
 
 static int
 SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
-                                                unsigned short *ModeIdIndex)
+                 unsigned short *ModeIdIndex)
 {
         if ((*ModeNo) <= 0x13) {
 
@@ -367,12 +265,14 @@ SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
 
         } else {
 
-                for(*ModeIdIndex = 0; ;(*ModeIdIndex)++) {
+                for (*ModeIdIndex = 0;; (*ModeIdIndex)++) {
 
-                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == (*ModeNo))
+                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
+                            (*ModeNo))
                                 break;
 
-                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == 0xFF)
+                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID ==
+                            0xFF)
                                 return 0;
                 }
 
@@ -385,8 +285,7 @@ SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
 /*            HELPER: ENABLE CRT1            */
 /*********************************************/
 
-static void
-SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
+static void SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
 {
         /* Enable CRT1 gating */
         SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, SiS_Pr->SiS_MyCR63, 0xbf);
@@ -398,9 +297,9 @@ SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
 
 static unsigned short
 SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                unsigned short ModeIdIndex)
+                  unsigned short ModeIdIndex)
 {
-        static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8};
+        static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8 };
         unsigned short modeflag;
         short index;
 
@@ -411,7 +310,8 @@ SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
         }
 
         index = (modeflag & ModeTypeMask) - ModeEGA;
-        if (index < 0) index = 0;
+        if (index < 0)
+                index = 0;
         return ColorDepth[index];
 }
 
@@ -421,7 +321,7 @@ SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static unsigned short
 SiS_GetOffset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                unsigned short ModeIdIndex, unsigned short rrti)
+              unsigned short ModeIdIndex, unsigned short rrti)
 {
         unsigned short xres, temp, colordepth, infoflag;
 
@@ -458,8 +358,8 @@ SiS_SetSeqRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
         SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[0] | 0x20;
         SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, SRdata);
 
-        for(i = 2; i <= 4; i++) {
-                SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i-1];
+        for (i = 2; i <= 4; i++) {
+                SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i - 1];
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, SRdata);
         }
 }
@@ -488,7 +388,7 @@ SiS_SetCRTCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
 
         SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
 
-        for(i = 0; i <= 0x18; i++) {
+        for (i = 0; i <= 0x18; i++) {
                 CRTCdata = SiS_Pr->SiS_StandTable[StandTableIndex].CRTC[i];
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, i, CRTCdata);
         }
@@ -504,7 +404,7 @@ SiS_SetATTRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
         unsigned char ARdata;
         unsigned short i;
 
-        for(i = 0; i <= 0x13; i++) {
+        for (i = 0; i <= 0x13; i++) {
                 ARdata = SiS_Pr->SiS_StandTable[StandTableIndex].ATTR[i];
                 SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
                 SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, i);
@@ -529,7 +429,7 @@ SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
         unsigned char GRdata;
         unsigned short i;
 
-        for(i = 0; i <= 0x08; i++) {
+        for (i = 0; i <= 0x08; i++) {
                 GRdata = SiS_Pr->SiS_StandTable[StandTableIndex].GRC[i];
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3ce, i, GRdata);
         }
@@ -544,12 +444,11 @@ SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
 /*          CLEAR EXTENDED REGISTERS         */
 /*********************************************/
 
-static void
-SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
+static void SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
 {
         int i;
 
-        for(i = 0x0A; i <= 0x0E; i++) {
+        for (i = 0x0A; i <= 0x0E; i++) {
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, 0x00);
         }
 
@@ -562,15 +461,16 @@ SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
 
 static unsigned short
 SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                                        unsigned short ModeIdIndex)
+               unsigned short ModeIdIndex)
 {
         unsigned short rrti, i, index, temp;
 
         if (ModeNo <= 0x13)
                 return 0xFFFF;
 
-        index = SiS_GetReg(SiS_Pr,SiS_Pr->SiS_P3d4, 0x33) & 0x0F;
-        if (index > 0) index--;
+        index = SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x33) & 0x0F;
+        if (index > 0)
+                index--;
 
         rrti = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex;
         ModeNo = SiS_Pr->SiS_RefIndex[rrti].ModeID;
@@ -580,13 +480,14 @@ SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
                 if (SiS_Pr->SiS_RefIndex[rrti + i].ModeID != ModeNo)
                         break;
 
-                temp = SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask;
+                temp =
+                    SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask;
                 if (temp < SiS_Pr->SiS_ModeType)
                         break;
 
                 i++;
                 index--;
-        } while(index != 0xFFFF);
+        } while (index != 0xFFFF);
 
         i--;
 
@@ -597,8 +498,7 @@ SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 /*                  SYNC                     */
 /*********************************************/
 
-static void
-SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
+static void SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
 {
         unsigned short sync = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag >> 8;
         sync &= 0xC0;
@@ -612,39 +512,40 @@ SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
 
 static void
 SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                        unsigned short ModeIdIndex, unsigned short rrti)
+                unsigned short ModeIdIndex, unsigned short rrti)
 {
-        unsigned char  index;
+        unsigned char index;
         unsigned short temp, i, j, modeflag;
 
-        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4,0x11,0x7f);
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
 
         modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
 
         index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRT1CRTC;
 
-        for(i = 0,j = 0; i <= 7; i++, j++) {
+        for (i = 0, j = 0; i <= 7; i++, j++) {
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
-                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+                           SiS_Pr->SiS_CRT1Table[index].CR[i]);
         }
-        for(j = 0x10; i <= 10; i++, j++) {
+        for (j = 0x10; i <= 10; i++, j++) {
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
-                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+                           SiS_Pr->SiS_CRT1Table[index].CR[i]);
         }
-        for(j = 0x15; i <= 12; i++, j++) {
+        for (j = 0x15; i <= 12; i++, j++) {
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
-                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+                           SiS_Pr->SiS_CRT1Table[index].CR[i]);
         }
-        for(j = 0x0A; i <= 15; i++, j++) {
+        for (j = 0x0A; i <= 15; i++, j++) {
                 SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, j,
-                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+                           SiS_Pr->SiS_CRT1Table[index].CR[i]);
         }
 
         temp = SiS_Pr->SiS_CRT1Table[index].CR[16] & 0xE0;
-        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4, 0x0E, temp);
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, temp);
 
         temp = ((SiS_Pr->SiS_CRT1Table[index].CR[16]) & 0x01) << 5;
-        if (modeflag & DoubleScanMode)  temp |= 0x80;
+        if (modeflag & DoubleScanMode)
+                temp |= 0x80;
         SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x09, 0x5F, temp);
 
         if (SiS_Pr->SiS_ModeType > ModeVGA)
@@ -659,10 +560,10 @@ SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                        unsigned short ModeIdIndex, unsigned short rrti)
+                  unsigned short ModeIdIndex, unsigned short rrti)
 {
         unsigned short du = SiS_GetOffset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
-        unsigned short infoflag =  SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
+        unsigned short infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
         unsigned short temp;
 
         temp = (du >> 8) & 0x0f;
@@ -670,11 +571,13 @@ SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
         SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x13, (du & 0xFF));
 
-        if (infoflag & InterlaceMode) du >>= 1;
+        if (infoflag & InterlaceMode)
+                du >>= 1;
 
         du <<= 5;
         temp = (du >> 8) & 0xff;
-        if (du & 0xff) temp++;
+        if (du & 0xff)
+                temp++;
         temp++;
         SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x10, temp);
 }
@@ -685,17 +588,17 @@ SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                                                unsigned short rrti)
+                unsigned short rrti)
 {
         unsigned short index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
         unsigned short clka = SiS_Pr->SiS_VCLKData[index].SR2B;
         unsigned short clkb = SiS_Pr->SiS_VCLKData[index].SR2C;
 
-        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4,0x31,0xCF);
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xCF);
 
-        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2B,clka);
-        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2C,clkb);
-        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2D,0x01);
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2B, clka);
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2C, clkb);
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x2D, 0x01);
 }
 
 /*********************************************/
@@ -704,7 +607,7 @@ SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                                                        unsigned short mi)
+                    unsigned short mi)
 {
         unsigned short modeflag = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
 
@@ -729,7 +632,7 @@ SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                                                        unsigned short rrti)
+                 unsigned short rrti)
 {
         unsigned short data = 0, VCLK = 0, index = 0;
 
@@ -738,7 +641,8 @@ SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
                 VCLK = SiS_Pr->SiS_VCLKData[index].CLOCK;
         }
 
-        if (VCLK >= 166) data |= 0x0c;
+        if (VCLK >= 166)
+                data |= 0x0c;
         SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x32, 0xf3, data);
 
         if (VCLK >= 166)
@@ -758,7 +662,7 @@ SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                        unsigned short ModeIdIndex, unsigned short rrti)
+                    unsigned short ModeIdIndex, unsigned short rrti)
 {
         unsigned short data, infoflag = 0, modeflag;
 
@@ -778,17 +682,22 @@ SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
                         data |= 0x02;
                         data |= ((SiS_Pr->SiS_ModeType - ModeVGA) << 2);
                 }
-                if (infoflag & InterlaceMode) data |= 0x20;
+                if (infoflag & InterlaceMode)
+                        data |= 0x20;
         }
         SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x06, 0xC0, data);
 
         data = 0;
         if (infoflag & InterlaceMode) {
                 /* data = (Hsync / 8) - ((Htotal / 8) / 2) + 3 */
-                unsigned short hrs = (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) |
-                        ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2)) - 3;
-                unsigned short hto = (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) |
-                        ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8)) + 5;
+                unsigned short hrs =
+                    (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) |
+                     ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2))
+                    - 3;
+                unsigned short hto =
+                    (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) |
+                     ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8))
+                    + 5;
                 data = hrs - (hto >> 1) + 3;
         }
         SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x19, (data & 0xFF));
@@ -829,20 +738,26 @@ SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 
 static void
 SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData,
-                unsigned short shiftflag, unsigned short dl, unsigned short ah,
-                unsigned short al, unsigned short dh)
+             unsigned short shiftflag, unsigned short dl, unsigned short ah,
+             unsigned short al, unsigned short dh)
 {
         unsigned short d1, d2, d3;
 
         switch (dl) {
-                case  0:
-                        d1 = dh; d2 = ah; d3 = al;
-                        break;
-                case  1:
-                        d1 = ah; d2 = al; d3 = dh;
-                        break;
-                default:
-                        d1 = al; d2 = dh; d3 = ah;
+        case 0:
+                d1 = dh;
+                d2 = ah;
+                d3 = al;
+                break;
+        case 1:
+                d1 = ah;
+                d2 = al;
+                d3 = dh;
+                break;
+        default:
+                d1 = al;
+                d2 = dh;
+                d3 = ah;
         }
         SiS_SetRegByte(SiS_Pr, DACData, (d1 << shiftflag));
         SiS_SetRegByte(SiS_Pr, DACData, (d2 << shiftflag));
@@ -850,7 +765,8 @@ SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData,
 }
 
 static void
-SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short mi)
+SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+            unsigned short mi)
 {
         unsigned short data, data2, time, i, j, k, m, n, o;
         unsigned short si, di, bx, sf;
@@ -884,41 +800,45 @@ SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short mi
 
         SiS_SetRegByte(SiS_Pr, DACAddr, 0x00);
 
-        for(i = 0; i < j; i++) {
+        for (i = 0; i < j; i++) {
                 data = table[i];
-                for(k = 0; k < 3; k++) {
+                for (k = 0; k < 3; k++) {
                         data2 = 0;
-                        if (data & 0x01) data2 += 0x2A;
-                        if (data & 0x02) data2 += 0x15;
+                        if (data & 0x01)
+                                data2 += 0x2A;
+                        if (data & 0x02)
+                                data2 += 0x15;
                         SiS_SetRegByte(SiS_Pr, DACData, (data2 << sf));
                         data >>= 2;
                 }
         }
 
         if (time == 256) {
-                for(i = 16; i < 32; i++) {
+                for (i = 16; i < 32; i++) {
                         data = table[i] << sf;
-                        for(k = 0; k < 3; k++)
+                        for (k = 0; k < 3; k++)
                                 SiS_SetRegByte(SiS_Pr, DACData, data);
                 }
                 si = 32;
-                for(m = 0; m < 9; m++) {
+                for (m = 0; m < 9; m++) {
                         di = si;
                         bx = si + 4;
-                        for(n = 0; n < 3; n++) {
-                                for(o = 0; o < 5; o++) {
+                        for (n = 0; n < 3; n++) {
+                                for (o = 0; o < 5; o++) {
                                         SiS_WriteDAC(SiS_Pr, DACData, sf, n,
-                                                table[di], table[bx], table[si]);
+                                                     table[di], table[bx],
+                                                     table[si]);
                                         si++;
                                 }
                                 si -= 2;
-                                for(o = 0; o < 3; o++) {
+                                for (o = 0; o < 3; o++) {
                                         SiS_WriteDAC(SiS_Pr, DACData, sf, n,
-                                                table[di], table[si], table[bx]);
+                                                     table[di], table[si],
+                                                     table[bx]);
                                         si--;
                                 }
                         }
-                si += 5;
+                        si += 5;
                 }
         }
 }
@@ -929,7 +849,7 @@ SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short mi
 
 static void
 SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
-                                        unsigned short ModeIdIndex)
+                 unsigned short ModeIdIndex)
 {
         unsigned short StandTableIndex, rrti;
 
@@ -970,11 +890,10 @@ SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
 /*                 SiSSetMode()              */
 /*********************************************/
 
-int
-SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
+int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
 {
         unsigned short ModeIdIndex;
-        unsigned long  BaseAddr = SiS_Pr->IOAddress;
+        unsigned long BaseAddr = SiS_Pr->IOAddress;
 
         SiSUSB_InitPtr(SiS_Pr);
         SiSUSBRegInit(SiS_Pr, BaseAddr);
@@ -990,7 +909,7 @@ SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
         ModeNo &= 0x7f;
 
         SiS_Pr->SiS_ModeType =
-                SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask;
+            SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask;
 
         SiS_Pr->SiS_SetFlag = LowModeTests;
 
@@ -1008,8 +927,7 @@ SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
         return 1;
 }
 
-int
-SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
+int SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
 {
         unsigned short ModeNo = 0;
         int i;
@@ -1041,7 +959,3 @@ SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
 }
 
 #endif /* INCL_SISUSB_CON */
-
-
-
-
diff --git a/drivers/usb/misc/sisusbvga/sisusb_init.h b/drivers/usb/misc/sisusbvga/sisusb_init.h
index 864bc0e965..c46ce42d44 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_init.h
+++ b/drivers/usb/misc/sisusbvga/sisusb_init.h
@@ -46,7 +46,7 @@
  * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  *
  */
 
@@ -76,21 +76,21 @@
 #define CRT2Mode                0x0800
 #define HalfDCLK                0x1000
 #define NoSupportSimuTV         0x2000
-#define NoSupportLCDScale       0x4000 /* SiS bridge: No scaling possible (no matter what panel) */
+#define NoSupportLCDScale       0x4000  /* SiS bridge: No scaling possible (no matter what panel) */
 #define DoubleScanMode          0x8000
 
 /* Infoflag */
 #define SupportTV               0x0008
 #define SupportTV1024           0x0800
-#define SupportCHTV             0x0800
-#define Support64048060Hz       0x0800  /* Special for 640x480 LCD */
+#define SupportCHTV             0x0800
+#define Support64048060Hz       0x0800  /* Special for 640x480 LCD */
 #define SupportHiVision         0x0010
 #define SupportYPbPr750p        0x1000
 #define SupportLCD              0x0020
 #define SupportRAMDAC2          0x0040  /* All           (<= 100Mhz) */
-#define SupportRAMDAC2_135      0x0100  /* All except DH (<= 135Mhz) */
-#define SupportRAMDAC2_162      0x0200  /* B, C          (<= 162Mhz) */
-#define SupportRAMDAC2_202      0x0400  /* C             (<= 202Mhz) */
+#define SupportRAMDAC2_135      0x0100  /* All except DH (<= 135Mhz) */
+#define SupportRAMDAC2_162      0x0200  /* B, C          (<= 162Mhz) */
+#define SupportRAMDAC2_202      0x0400  /* C             (<= 202Mhz) */
 #define InterlaceMode           0x0080
 #define SyncPP                  0x0000
 #define SyncPN                  0x4000
@@ -129,7 +129,7 @@
 #define SIS_RI_856x480          19
 #define SIS_RI_1280x768         20
 #define SIS_RI_1400x1050        21
-#define SIS_RI_1152x864         22  /* Up to here SiS conforming */
+#define SIS_RI_1152x864         22      /* Up to here SiS conforming */
 #define SIS_RI_848x480          23
 #define SIS_RI_1360x768         24
 #define SIS_RI_1024x600         25
@@ -147,691 +147,691 @@
 #define SIS_CRT2_PORT_04        0x04 - 0x30
 
 /* Mode numbers */
-static const unsigned short ModeIndex_320x200[]   = {0x59, 0x41, 0x00, 0x4f};
-static const unsigned short ModeIndex_320x240[]   = {0x50, 0x56, 0x00, 0x53};
-static const unsigned short ModeIndex_400x300[]   = {0x51, 0x57, 0x00, 0x54};
-static const unsigned short ModeIndex_512x384[]   = {0x52, 0x58, 0x00, 0x5c};
-static const unsigned short ModeIndex_640x400[]   = {0x2f, 0x5d, 0x00, 0x5e};
-static const unsigned short ModeIndex_640x480[]   = {0x2e, 0x44, 0x00, 0x62};
-static const unsigned short ModeIndex_720x480[]   = {0x31, 0x33, 0x00, 0x35};
-static const unsigned short ModeIndex_720x576[]   = {0x32, 0x34, 0x00, 0x36};
-static const unsigned short ModeIndex_768x576[]   = {0x5f, 0x60, 0x00, 0x61};
-static const unsigned short ModeIndex_800x480[]   = {0x70, 0x7a, 0x00, 0x76};
-static const unsigned short ModeIndex_800x600[]   = {0x30, 0x47, 0x00, 0x63};
-static const unsigned short ModeIndex_848x480[]   = {0x39, 0x3b, 0x00, 0x3e};
-static const unsigned short ModeIndex_856x480[]   = {0x3f, 0x42, 0x00, 0x45};
-static const unsigned short ModeIndex_960x540[]   = {0x1d, 0x1e, 0x00, 0x1f};
-static const unsigned short ModeIndex_960x600[]   = {0x20, 0x21, 0x00, 0x22};
-static const unsigned short ModeIndex_1024x768[]  = {0x38, 0x4a, 0x00, 0x64};
-static const unsigned short ModeIndex_1024x576[]  = {0x71, 0x74, 0x00, 0x77};
-static const unsigned short ModeIndex_1152x864[]  = {0x29, 0x2a, 0x00, 0x2b};
-static const unsigned short ModeIndex_1280x720[]  = {0x79, 0x75, 0x00, 0x78};
-static const unsigned short ModeIndex_1280x768[]  = {0x23, 0x24, 0x00, 0x25};
-static const unsigned short ModeIndex_1280x1024[] = {0x3a, 0x4d, 0x00, 0x65};
+static const unsigned short ModeIndex_320x200[] = { 0x59, 0x41, 0x00, 0x4f };
+static const unsigned short ModeIndex_320x240[] = { 0x50, 0x56, 0x00, 0x53 };
+static const unsigned short ModeIndex_400x300[] = { 0x51, 0x57, 0x00, 0x54 };
+static const unsigned short ModeIndex_512x384[] = { 0x52, 0x58, 0x00, 0x5c };
+static const unsigned short ModeIndex_640x400[] = { 0x2f, 0x5d, 0x00, 0x5e };
+static const unsigned short ModeIndex_640x480[] = { 0x2e, 0x44, 0x00, 0x62 };
+static const unsigned short ModeIndex_720x480[] = { 0x31, 0x33, 0x00, 0x35 };
+static const unsigned short ModeIndex_720x576[] = { 0x32, 0x34, 0x00, 0x36 };
+static const unsigned short ModeIndex_768x576[] = { 0x5f, 0x60, 0x00, 0x61 };
+static const unsigned short ModeIndex_800x480[] = { 0x70, 0x7a, 0x00, 0x76 };
+static const unsigned short ModeIndex_800x600[] = { 0x30, 0x47, 0x00, 0x63 };
+static const unsigned short ModeIndex_848x480[] = { 0x39, 0x3b, 0x00, 0x3e };
+static const unsigned short ModeIndex_856x480[] = { 0x3f, 0x42, 0x00, 0x45 };
+static const unsigned short ModeIndex_960x540[] = { 0x1d, 0x1e, 0x00, 0x1f };
+static const unsigned short ModeIndex_960x600[] = { 0x20, 0x21, 0x00, 0x22 };
+static const unsigned short ModeIndex_1024x768[] = { 0x38, 0x4a, 0x00, 0x64 };
+static const unsigned short ModeIndex_1024x576[] = { 0x71, 0x74, 0x00, 0x77 };
+static const unsigned short ModeIndex_1152x864[] = { 0x29, 0x2a, 0x00, 0x2b };
+static const unsigned short ModeIndex_1280x720[] = { 0x79, 0x75, 0x00, 0x78 };
+static const unsigned short ModeIndex_1280x768[] = { 0x23, 0x24, 0x00, 0x25 };
+static const unsigned short ModeIndex_1280x1024[] = { 0x3a, 0x4d, 0x00, 0x65 };
 
-static const unsigned char SiS_MDA_DAC[] =
-{
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
-        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
-        0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
-        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
-        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
-        0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F
+static const unsigned char SiS_MDA_DAC[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+        0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+        0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+        0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+        0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F
 };
 
-static const unsigned char SiS_CGA_DAC[] =
-{
-        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
-        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
-        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
-        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F
+static const unsigned char SiS_CGA_DAC[] = {
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F,
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F
 };
 
-static const unsigned char SiS_EGA_DAC[] =
-{
-        0x00,0x10,0x04,0x14,0x01,0x11,0x05,0x15,
-        0x20,0x30,0x24,0x34,0x21,0x31,0x25,0x35,
-        0x08,0x18,0x0C,0x1C,0x09,0x19,0x0D,0x1D,
-        0x28,0x38,0x2C,0x3C,0x29,0x39,0x2D,0x3D,
-        0x02,0x12,0x06,0x16,0x03,0x13,0x07,0x17,
-        0x22,0x32,0x26,0x36,0x23,0x33,0x27,0x37,
-        0x0A,0x1A,0x0E,0x1E,0x0B,0x1B,0x0F,0x1F,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F
+static const unsigned char SiS_EGA_DAC[] = {
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x05, 0x15,
+        0x20, 0x30, 0x24, 0x34, 0x21, 0x31, 0x25, 0x35,
+        0x08, 0x18, 0x0C, 0x1C, 0x09, 0x19, 0x0D, 0x1D,
+        0x28, 0x38, 0x2C, 0x3C, 0x29, 0x39, 0x2D, 0x3D,
+        0x02, 0x12, 0x06, 0x16, 0x03, 0x13, 0x07, 0x17,
+        0x22, 0x32, 0x26, 0x36, 0x23, 0x33, 0x27, 0x37,
+        0x0A, 0x1A, 0x0E, 0x1E, 0x0B, 0x1B, 0x0F, 0x1F,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F
 };
 
-static const unsigned char SiS_VGA_DAC[] =
-{
-        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
-        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
-        0x00,0x05,0x08,0x0B,0x0E,0x11,0x14,0x18,
-        0x1C,0x20,0x24,0x28,0x2D,0x32,0x38,0x3F,
-        0x00,0x10,0x1F,0x2F,0x3F,0x1F,0x27,0x2F,
-        0x37,0x3F,0x2D,0x31,0x36,0x3A,0x3F,0x00,
-        0x07,0x0E,0x15,0x1C,0x0E,0x11,0x15,0x18,
-        0x1C,0x14,0x16,0x18,0x1A,0x1C,0x00,0x04,
-        0x08,0x0C,0x10,0x08,0x0A,0x0C,0x0E,0x10,
-        0x0B,0x0C,0x0D,0x0F,0x10
+static const unsigned char SiS_VGA_DAC[] = {
+        0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
+        0x2A, 0x3A, 0x2E, 0x3E, 0x2B, 0x3B, 0x2F, 0x3F,
+        0x00, 0x05, 0x08, 0x0B, 0x0E, 0x11, 0x14, 0x18,
+        0x1C, 0x20, 0x24, 0x28, 0x2D, 0x32, 0x38, 0x3F,
+        0x00, 0x10, 0x1F, 0x2F, 0x3F, 0x1F, 0x27, 0x2F,
+        0x37, 0x3F, 0x2D, 0x31, 0x36, 0x3A, 0x3F, 0x00,
+        0x07, 0x0E, 0x15, 0x1C, 0x0E, 0x11, 0x15, 0x18,
+        0x1C, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x00, 0x04,
+        0x08, 0x0C, 0x10, 0x08, 0x0A, 0x0C, 0x0E, 0x10,
+        0x0B, 0x0C, 0x0D, 0x0F, 0x10
 };
 
-static const struct SiS_St SiSUSB_SModeIDTable[] =
-{
-        {0x03,0x0010,0x18,0x02,0x02,0x00,0x01,0x03,0x40},
-        {0xff,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
+static const struct SiS_St SiSUSB_SModeIDTable[] = {
+        {0x03, 0x0010, 0x18, 0x02, 0x02, 0x00, 0x01, 0x03, 0x40},
+        {0xff, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
 };
 
-static const struct SiS_StResInfo_S SiSUSB_StResInfo[] =
-{
-        { 640,400},
-        { 640,350},
-        { 720,400},
-        { 720,350},
-        { 640,480}
+static const struct SiS_StResInfo_S SiSUSB_StResInfo[] = {
+        {640, 400},
+        {640, 350},
+        {720, 400},
+        {720, 350},
+        {640, 480}
 };
 
-static const struct SiS_ModeResInfo SiSUSB_ModeResInfo[] =
-{
-        {  320, 200, 8, 8},   /* 0x00 */
-        {  320, 240, 8, 8},   /* 0x01 */
-        {  320, 400, 8, 8},   /* 0x02 */
-        {  400, 300, 8, 8},   /* 0x03 */
-        {  512, 384, 8, 8},   /* 0x04 */
-        {  640, 400, 8,16},   /* 0x05 */
-        {  640, 480, 8,16},   /* 0x06 */
-        {  800, 600, 8,16},   /* 0x07 */
-        { 1024, 768, 8,16},   /* 0x08 */
-        { 1280,1024, 8,16},   /* 0x09 */
-        { 1600,1200, 8,16},   /* 0x0a */
-        { 1920,1440, 8,16},   /* 0x0b */
-        { 2048,1536, 8,16},   /* 0x0c */
-        {  720, 480, 8,16},   /* 0x0d */
-        {  720, 576, 8,16},   /* 0x0e */
-        { 1280, 960, 8,16},   /* 0x0f */
-        {  800, 480, 8,16},   /* 0x10 */
-        { 1024, 576, 8,16},   /* 0x11 */
-        { 1280, 720, 8,16},   /* 0x12 */
-        {  856, 480, 8,16},   /* 0x13 */
-        { 1280, 768, 8,16},   /* 0x14 */
-        { 1400,1050, 8,16},   /* 0x15 */
-        { 1152, 864, 8,16},   /* 0x16 */
-        {  848, 480, 8,16},   /* 0x17 */
-        { 1360, 768, 8,16},   /* 0x18 */
-        { 1024, 600, 8,16},   /* 0x19 */
-        { 1152, 768, 8,16},   /* 0x1a */
-        {  768, 576, 8,16},   /* 0x1b */
-        { 1360,1024, 8,16},   /* 0x1c */
-        { 1680,1050, 8,16},   /* 0x1d */
-        { 1280, 800, 8,16},   /* 0x1e */
-        { 1920,1080, 8,16},   /* 0x1f */
-        {  960, 540, 8,16},   /* 0x20 */
-        {  960, 600, 8,16}    /* 0x21 */
+static const struct SiS_ModeResInfo SiSUSB_ModeResInfo[] = {
+        {320, 200, 8, 8},       /* 0x00 */
+        {320, 240, 8, 8},       /* 0x01 */
+        {320, 400, 8, 8},       /* 0x02 */
+        {400, 300, 8, 8},       /* 0x03 */
+        {512, 384, 8, 8},       /* 0x04 */
+        {640, 400, 8, 16},      /* 0x05 */
+        {640, 480, 8, 16},      /* 0x06 */
+        {800, 600, 8, 16},      /* 0x07 */
+        {1024, 768, 8, 16},     /* 0x08 */
+        {1280, 1024, 8, 16},    /* 0x09 */
+        {1600, 1200, 8, 16},    /* 0x0a */
+        {1920, 1440, 8, 16},    /* 0x0b */
+        {2048, 1536, 8, 16},    /* 0x0c */
+        {720, 480, 8, 16},      /* 0x0d */
+        {720, 576, 8, 16},      /* 0x0e */
+        {1280, 960, 8, 16},     /* 0x0f */
+        {800, 480, 8, 16},      /* 0x10 */
+        {1024, 576, 8, 16},     /* 0x11 */
+        {1280, 720, 8, 16},     /* 0x12 */
+        {856, 480, 8, 16},      /* 0x13 */
+        {1280, 768, 8, 16},     /* 0x14 */
+        {1400, 1050, 8, 16},    /* 0x15 */
+        {1152, 864, 8, 16},     /* 0x16 */
+        {848, 480, 8, 16},      /* 0x17 */
+        {1360, 768, 8, 16},     /* 0x18 */
+        {1024, 600, 8, 16},     /* 0x19 */
+        {1152, 768, 8, 16},     /* 0x1a */
+        {768, 576, 8, 16},      /* 0x1b */
+        {1360, 1024, 8, 16},    /* 0x1c */
+        {1680, 1050, 8, 16},    /* 0x1d */
+        {1280, 800, 8, 16},     /* 0x1e */
+        {1920, 1080, 8, 16},    /* 0x1f */
+        {960, 540, 8, 16},      /* 0x20 */
+        {960, 600, 8, 16}       /* 0x21 */
 };
 
-static const struct SiS_StandTable SiSUSB_StandTable[] =
-{
+static const struct SiS_StandTable SiSUSB_StandTable[] = {
         /* MD_3_400 - mode 0x03 - 400 */
         {
-                0x50,0x18,0x10,0x1000,
-                { 0x00,0x03,0x00,0x02 },
-                0x67,
-                { 0x5f,0x4f,0x50,0x82,0x55,0x81,0xbf,0x1f,
-                  0x00,0x4f,0x0d,0x0e,0x00,0x00,0x00,0x00,
-                  0x9c,0x8e,0x8f,0x28,0x1f,0x96,0xb9,0xa3,
-                  0xff },
-                { 0x00,0x01,0x02,0x03,0x04,0x05,0x14,0x07,
-                  0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
-                  0x0c,0x00,0x0f,0x08 },
-                { 0x00,0x00,0x00,0x00,0x00,0x10,0x0e,0x00, 0xff }
-        },
+         0x50, 0x18, 0x10, 0x1000,
+         {0x00, 0x03, 0x00, 0x02},
+         0x67,
+         {0x5f, 0x4f, 0x50, 0x82, 0x55, 0x81, 0xbf, 0x1f,
+          0x00, 0x4f, 0x0d, 0x0e, 0x00, 0x00, 0x00, 0x00,
+          0x9c, 0x8e, 0x8f, 0x28, 0x1f, 0x96, 0xb9, 0xa3,
+          0xff},
+         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
+          0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+          0x0c, 0x00, 0x0f, 0x08},
+         {0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0e, 0x00, 0xff}
+         },
         /* Generic for VGA and higher */
         {
-                0x00,0x00,0x00,0x0000,
-                { 0x01,0x0f,0x00,0x0e },
-                0x23,
-                { 0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e,
-                  0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
-                  0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3,
-                  0xff },
-                { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
-                  0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
-                  0x01,0x00,0x00,0x00 },
-                { 0x00,0x00,0x00,0x00,0x00,0x40,0x05,0x0f, 0xff }
-        }
+         0x00, 0x00, 0x00, 0x0000,
+         {0x01, 0x0f, 0x00, 0x0e},
+         0x23,
+         {0x5f, 0x4f, 0x50, 0x82, 0x54, 0x80, 0x0b, 0x3e,
+          0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0xea, 0x8c, 0xdf, 0x28, 0x40, 0xe7, 0x04, 0xa3,
+          0xff},
+         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+          0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+          0x01, 0x00, 0x00, 0x00},
+         {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0f, 0xff}
+         }
 };
 
-static const struct SiS_Ext SiSUSB_EModeIDTable[] =
-{
-        {0x2e,0x0a1b,0x0101,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x8 */
-        {0x2f,0x0a1b,0x0100,SIS_RI_640x400,  0x00,0x00,0x05,0x05,0x10, 0}, /* 640x400x8 */
-        {0x30,0x2a1b,0x0103,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x8 */
-        {0x31,0x4a1b,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x8 */
-        {0x32,0x4a1b,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x8 */
-        {0x33,0x4a1d,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x16 */
-        {0x34,0x6a1d,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x16 */
-        {0x35,0x4a1f,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x32 */
-        {0x36,0x6a1f,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x32 */
-        {0x38,0x0a1b,0x0105,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x8 */
-        {0x3a,0x0e3b,0x0107,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x8 */
-        {0x41,0x9a1d,0x010e,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x16 */
-        {0x44,0x0a1d,0x0111,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x16 */
-        {0x47,0x2a1d,0x0114,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x16 */
-        {0x4a,0x0a3d,0x0117,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x16 */
-        {0x4d,0x0e7d,0x011a,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x16 */
-        {0x50,0x9a1b,0x0132,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x8  */
-        {0x51,0xba1b,0x0133,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x8  */
-        {0x52,0xba1b,0x0134,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x8  */
-        {0x56,0x9a1d,0x0135,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x16 */
-        {0x57,0xba1d,0x0136,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x16 */
-        {0x58,0xba1d,0x0137,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x16 */
-        {0x59,0x9a1b,0x0138,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x8  */
-        {0x5c,0xba1f,0x0000,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x32 */
-        {0x5d,0x0a1d,0x0139,SIS_RI_640x400,  0x00,0x00,0x05,0x07,0x10, 0}, /* 640x400x16 */
-        {0x5e,0x0a1f,0x0000,SIS_RI_640x400,  0x00,0x00,0x05,0x07,0x10, 0}, /* 640x400x32 */
-        {0x62,0x0a3f,0x013a,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x32 */
-        {0x63,0x2a3f,0x013b,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x32 */
-        {0x64,0x0a7f,0x013c,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x32 */
-        {0x65,0x0eff,0x013d,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x32 */
-        {0x70,0x6a1b,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x8 */
-        {0x71,0x4a1b,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x8 */
-        {0x74,0x4a1d,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x16 */
-        {0x75,0x0a3d,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x16 */
-        {0x76,0x6a1f,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x32 */
-        {0x77,0x4a1f,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x32 */
-        {0x78,0x0a3f,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x32 */
-        {0x79,0x0a3b,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x8 */
-        {0x7a,0x6a1d,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x16 */
-        {0x23,0x0e3b,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x8 */
-        {0x24,0x0e7d,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x16 */
-        {0x25,0x0eff,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x32 */
-        {0x39,0x6a1b,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1}, /* 848x480 */
-        {0x3b,0x6a3d,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1},
-        {0x3e,0x6a7f,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1},
-        {0x3f,0x6a1b,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1}, /* 856x480 */
-        {0x42,0x6a3d,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1},
-        {0x45,0x6a7f,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1},
-        {0x4f,0x9a1f,0x0000,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x32 */
-        {0x53,0x9a1f,0x0000,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x32 */
-        {0x54,0xba1f,0x0000,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x32 */
-        {0x5f,0x6a1b,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1}, /* 768x576 */
-        {0x60,0x6a1d,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1},
-        {0x61,0x6a3f,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1},
-        {0x1d,0x6a1b,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1}, /* 960x540 */
-        {0x1e,0x6a3d,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1},
-        {0x1f,0x6a7f,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1},
-        {0x20,0x6a1b,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1}, /* 960x600 */
-        {0x21,0x6a3d,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1},
-        {0x22,0x6a7f,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1},
-        {0x29,0x4e1b,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1}, /* 1152x864 */
-        {0x2a,0x4e3d,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1},
-        {0x2b,0x4e7f,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1},
-        {0xff,0x0000,0x0000,0,               0x00,0x00,0x00,0x00,0x00,-1}
+static const struct SiS_Ext SiSUSB_EModeIDTable[] = {
+        {0x2e, 0x0a1b, 0x0101, SIS_RI_640x480, 0x00, 0x00, 0x05, 0x05, 0x08, 2},        /* 640x480x8 */
+        {0x2f, 0x0a1b, 0x0100, SIS_RI_640x400, 0x00, 0x00, 0x05, 0x05, 0x10, 0},        /* 640x400x8 */
+        {0x30, 0x2a1b, 0x0103, SIS_RI_800x600, 0x00, 0x00, 0x07, 0x06, 0x00, 3},        /* 800x600x8 */
+        {0x31, 0x4a1b, 0x0000, SIS_RI_720x480, 0x00, 0x00, 0x06, 0x06, 0x11, -1},       /* 720x480x8 */
+        {0x32, 0x4a1b, 0x0000, SIS_RI_720x576, 0x00, 0x00, 0x06, 0x06, 0x12, -1},       /* 720x576x8 */
+        {0x33, 0x4a1d, 0x0000, SIS_RI_720x480, 0x00, 0x00, 0x06, 0x06, 0x11, -1},       /* 720x480x16 */
+        {0x34, 0x6a1d, 0x0000, SIS_RI_720x576, 0x00, 0x00, 0x06, 0x06, 0x12, -1},       /* 720x576x16 */
+        {0x35, 0x4a1f, 0x0000, SIS_RI_720x480, 0x00, 0x00, 0x06, 0x06, 0x11, -1},       /* 720x480x32 */
+        {0x36, 0x6a1f, 0x0000, SIS_RI_720x576, 0x00, 0x00, 0x06, 0x06, 0x12, -1},       /* 720x576x32 */
+        {0x38, 0x0a1b, 0x0105, SIS_RI_1024x768, 0x00, 0x00, 0x08, 0x07, 0x13, 4},       /* 1024x768x8 */
+        {0x3a, 0x0e3b, 0x0107, SIS_RI_1280x1024, 0x00, 0x00, 0x00, 0x00, 0x2f, 8},      /* 1280x1024x8 */
+        {0x41, 0x9a1d, 0x010e, SIS_RI_320x200, 0x00, 0x00, 0x04, 0x04, 0x1a, 0},        /* 320x200x16 */
+        {0x44, 0x0a1d, 0x0111, SIS_RI_640x480, 0x00, 0x00, 0x05, 0x05, 0x08, 2},        /* 640x480x16 */
+        {0x47, 0x2a1d, 0x0114, SIS_RI_800x600, 0x00, 0x00, 0x07, 0x06, 0x00, 3},        /* 800x600x16 */
+        {0x4a, 0x0a3d, 0x0117, SIS_RI_1024x768, 0x00, 0x00, 0x08, 0x07, 0x13, 4},       /* 1024x768x16 */
+        {0x4d, 0x0e7d, 0x011a, SIS_RI_1280x1024, 0x00, 0x00, 0x00, 0x00, 0x2f, 8},      /* 1280x1024x16 */
+        {0x50, 0x9a1b, 0x0132, SIS_RI_320x240, 0x00, 0x00, 0x04, 0x04, 0x1b, 2},        /* 320x240x8  */
+        {0x51, 0xba1b, 0x0133, SIS_RI_400x300, 0x00, 0x00, 0x07, 0x07, 0x1c, 3},        /* 400x300x8  */
+        {0x52, 0xba1b, 0x0134, SIS_RI_512x384, 0x00, 0x00, 0x00, 0x00, 0x1d, 4},        /* 512x384x8  */
+        {0x56, 0x9a1d, 0x0135, SIS_RI_320x240, 0x00, 0x00, 0x04, 0x04, 0x1b, 2},        /* 320x240x16 */
+        {0x57, 0xba1d, 0x0136, SIS_RI_400x300, 0x00, 0x00, 0x07, 0x07, 0x1c, 3},        /* 400x300x16 */
+        {0x58, 0xba1d, 0x0137, SIS_RI_512x384, 0x00, 0x00, 0x00, 0x00, 0x1d, 4},        /* 512x384x16 */
+        {0x59, 0x9a1b, 0x0138, SIS_RI_320x200, 0x00, 0x00, 0x04, 0x04, 0x1a, 0},        /* 320x200x8  */
+        {0x5c, 0xba1f, 0x0000, SIS_RI_512x384, 0x00, 0x00, 0x00, 0x00, 0x1d, 4},        /* 512x384x32 */
+        {0x5d, 0x0a1d, 0x0139, SIS_RI_640x400, 0x00, 0x00, 0x05, 0x07, 0x10, 0},        /* 640x400x16 */
+        {0x5e, 0x0a1f, 0x0000, SIS_RI_640x400, 0x00, 0x00, 0x05, 0x07, 0x10, 0},        /* 640x400x32 */
+        {0x62, 0x0a3f, 0x013a, SIS_RI_640x480, 0x00, 0x00, 0x05, 0x05, 0x08, 2},        /* 640x480x32 */
+        {0x63, 0x2a3f, 0x013b, SIS_RI_800x600, 0x00, 0x00, 0x07, 0x06, 0x00, 3},        /* 800x600x32 */
+        {0x64, 0x0a7f, 0x013c, SIS_RI_1024x768, 0x00, 0x00, 0x08, 0x07, 0x13, 4},       /* 1024x768x32 */
+        {0x65, 0x0eff, 0x013d, SIS_RI_1280x1024, 0x00, 0x00, 0x00, 0x00, 0x2f, 8},      /* 1280x1024x32 */
+        {0x70, 0x6a1b, 0x0000, SIS_RI_800x480, 0x00, 0x00, 0x07, 0x07, 0x1e, -1},       /* 800x480x8 */
+        {0x71, 0x4a1b, 0x0000, SIS_RI_1024x576, 0x00, 0x00, 0x00, 0x00, 0x21, -1},      /* 1024x576x8 */
+        {0x74, 0x4a1d, 0x0000, SIS_RI_1024x576, 0x00, 0x00, 0x00, 0x00, 0x21, -1},      /* 1024x576x16 */
+        {0x75, 0x0a3d, 0x0000, SIS_RI_1280x720, 0x00, 0x00, 0x00, 0x00, 0x24, 5},       /* 1280x720x16 */
+        {0x76, 0x6a1f, 0x0000, SIS_RI_800x480, 0x00, 0x00, 0x07, 0x07, 0x1e, -1},       /* 800x480x32 */
+        {0x77, 0x4a1f, 0x0000, SIS_RI_1024x576, 0x00, 0x00, 0x00, 0x00, 0x21, -1},      /* 1024x576x32 */
+        {0x78, 0x0a3f, 0x0000, SIS_RI_1280x720, 0x00, 0x00, 0x00, 0x00, 0x24, 5},       /* 1280x720x32 */
+        {0x79, 0x0a3b, 0x0000, SIS_RI_1280x720, 0x00, 0x00, 0x00, 0x00, 0x24, 5},       /* 1280x720x8 */
+        {0x7a, 0x6a1d, 0x0000, SIS_RI_800x480, 0x00, 0x00, 0x07, 0x07, 0x1e, -1},       /* 800x480x16 */
+        {0x23, 0x0e3b, 0x0000, SIS_RI_1280x768, 0x00, 0x00, 0x00, 0x00, 0x27, 6},       /* 1280x768x8 */
+        {0x24, 0x0e7d, 0x0000, SIS_RI_1280x768, 0x00, 0x00, 0x00, 0x00, 0x27, 6},       /* 1280x768x16 */
+        {0x25, 0x0eff, 0x0000, SIS_RI_1280x768, 0x00, 0x00, 0x00, 0x00, 0x27, 6},       /* 1280x768x32 */
+        {0x39, 0x6a1b, 0x0000, SIS_RI_848x480, 0x00, 0x00, 0x00, 0x00, 0x28, -1},       /* 848x480 */
+        {0x3b, 0x6a3d, 0x0000, SIS_RI_848x480, 0x00, 0x00, 0x00, 0x00, 0x28,
+         -1},
+        {0x3e, 0x6a7f, 0x0000, SIS_RI_848x480, 0x00, 0x00, 0x00, 0x00, 0x28,
+         -1},
+        {0x3f, 0x6a1b, 0x0000, SIS_RI_856x480, 0x00, 0x00, 0x00, 0x00, 0x2a, -1},       /* 856x480 */
+        {0x42, 0x6a3d, 0x0000, SIS_RI_856x480, 0x00, 0x00, 0x00, 0x00, 0x2a,
+         -1},
+        {0x45, 0x6a7f, 0x0000, SIS_RI_856x480, 0x00, 0x00, 0x00, 0x00, 0x2a,
+         -1},
+        {0x4f, 0x9a1f, 0x0000, SIS_RI_320x200, 0x00, 0x00, 0x04, 0x04, 0x1a, 0},        /* 320x200x32 */
+        {0x53, 0x9a1f, 0x0000, SIS_RI_320x240, 0x00, 0x00, 0x04, 0x04, 0x1b, 2},        /* 320x240x32 */
+        {0x54, 0xba1f, 0x0000, SIS_RI_400x300, 0x00, 0x00, 0x07, 0x07, 0x1c, 3},        /* 400x300x32 */
+        {0x5f, 0x6a1b, 0x0000, SIS_RI_768x576, 0x00, 0x00, 0x06, 0x06, 0x2c, -1},       /* 768x576 */
+        {0x60, 0x6a1d, 0x0000, SIS_RI_768x576, 0x00, 0x00, 0x06, 0x06, 0x2c,
+         -1},
+        {0x61, 0x6a3f, 0x0000, SIS_RI_768x576, 0x00, 0x00, 0x06, 0x06, 0x2c,
+         -1},
+        {0x1d, 0x6a1b, 0x0000, SIS_RI_960x540, 0x00, 0x00, 0x00, 0x00, 0x2d, -1},       /* 960x540 */
+        {0x1e, 0x6a3d, 0x0000, SIS_RI_960x540, 0x00, 0x00, 0x00, 0x00, 0x2d,
+         -1},
+        {0x1f, 0x6a7f, 0x0000, SIS_RI_960x540, 0x00, 0x00, 0x00, 0x00, 0x2d,
+         -1},
+        {0x20, 0x6a1b, 0x0000, SIS_RI_960x600, 0x00, 0x00, 0x00, 0x00, 0x2e, -1},       /* 960x600 */
+        {0x21, 0x6a3d, 0x0000, SIS_RI_960x600, 0x00, 0x00, 0x00, 0x00, 0x2e,
+         -1},
+        {0x22, 0x6a7f, 0x0000, SIS_RI_960x600, 0x00, 0x00, 0x00, 0x00, 0x2e,
+         -1},
+        {0x29, 0x4e1b, 0x0000, SIS_RI_1152x864, 0x00, 0x00, 0x00, 0x00, 0x33, -1},      /* 1152x864 */
+        {0x2a, 0x4e3d, 0x0000, SIS_RI_1152x864, 0x00, 0x00, 0x00, 0x00, 0x33,
+         -1},
+        {0x2b, 0x4e7f, 0x0000, SIS_RI_1152x864, 0x00, 0x00, 0x00, 0x00, 0x33,
+         -1},
+        {0xff, 0x0000, 0x0000, 0, 0x00, 0x00, 0x00, 0x00, 0x00, -1}
 };
 
-static const struct SiS_Ext2 SiSUSB_RefIndex[] =
-{
-        {0x085f,0x0d,0x03,0x05,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x0 */
-        {0x0067,0x0e,0x04,0x05,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x1 */
-        {0x0067,0x0f,0x08,0x48,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x2 */
-        {0x0067,0x10,0x07,0x8b,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x3 */
-        {0x0047,0x11,0x0a,0x00,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x4 */
-        {0x0047,0x12,0x0d,0x00,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x5 */
-        {0x0047,0x13,0x13,0x00,0x05,0x30, 800, 600, 0x20, 0x00, 0x00}, /* 0x6 */
-        {0x0107,0x14,0x1c,0x00,0x05,0x30, 800, 600, 0x20, 0x00, 0x00}, /* 0x7 */
-        {0xc85f,0x05,0x00,0x04,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0x8 */
-        {0xc067,0x06,0x02,0x04,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0x9 */
-        {0xc067,0x07,0x02,0x47,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xa */
-        {0xc067,0x08,0x03,0x8a,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xb */
-        {0xc047,0x09,0x05,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xc */
-        {0xc047,0x0a,0x09,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xd */
-        {0xc047,0x0b,0x0e,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xe */
-        {0xc047,0x0c,0x15,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xf */
-        {0x487f,0x04,0x00,0x00,0x00,0x2f, 640, 400, 0x30, 0x55, 0x6e}, /* 0x10 */
-        {0xc06f,0x3c,0x01,0x06,0x13,0x31, 720, 480, 0x30, 0x00, 0x00}, /* 0x11 */
-        {0x006f,0x3d,0x6f,0x06,0x14,0x32, 720, 576, 0x30, 0x00, 0x00}, /* 0x12 (6f was 03) */
-        {0x0087,0x15,0x06,0x00,0x06,0x38,1024, 768, 0x30, 0x00, 0x00}, /* 0x13 */
-        {0xc877,0x16,0x0b,0x06,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x14 */
-        {0xc067,0x17,0x0f,0x49,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x15 */
-        {0x0067,0x18,0x11,0x00,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x16 */
-        {0x0047,0x19,0x16,0x8c,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x17 */
-        {0x0107,0x1a,0x1b,0x00,0x06,0x38,1024, 768, 0x10, 0x00, 0x00}, /* 0x18 */
-        {0x0107,0x1b,0x1f,0x00,0x06,0x38,1024, 768, 0x10, 0x00, 0x00}, /* 0x19 */
-        {0x407f,0x00,0x00,0x00,0x00,0x41, 320, 200, 0x30, 0x56, 0x4e}, /* 0x1a */
-        {0xc07f,0x01,0x00,0x04,0x04,0x50, 320, 240, 0x30, 0x00, 0x00}, /* 0x1b */
-        {0x007f,0x02,0x04,0x05,0x05,0x51, 400, 300, 0x30, 0x00, 0x00}, /* 0x1c */
-        {0xc077,0x03,0x0b,0x06,0x06,0x52, 512, 384, 0x30, 0x00, 0x00}, /* 0x1d */
-        {0x0077,0x32,0x40,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x1e */
-        {0x0047,0x33,0x07,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x1f */
-        {0x0047,0x34,0x0a,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x20 */
-        {0x0077,0x35,0x0b,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x21 */
-        {0x0047,0x36,0x11,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x22 */
-        {0x0047,0x37,0x16,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x23 */
-        {0x1137,0x38,0x19,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x24 */
-        {0x1107,0x39,0x1e,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x25 */
-        {0x1307,0x3a,0x20,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x26 */
-        {0x0077,0x42,0x5b,0x08,0x11,0x23,1280, 768, 0x30, 0x00, 0x00}, /* 0x27 */
-        {0x0087,0x45,0x57,0x00,0x16,0x39, 848, 480, 0x30, 0x00, 0x00}, /* 0x28 38Hzi  */
-        {0xc067,0x46,0x55,0x0b,0x16,0x39, 848, 480, 0x30, 0x00, 0x00}, /* 0x29 848x480-60Hz   */
-        {0x0087,0x47,0x57,0x00,0x17,0x3f, 856, 480, 0x30, 0x00, 0x00}, /* 0x2a 856x480-38Hzi  */
-        {0xc067,0x48,0x57,0x00,0x17,0x3f, 856, 480, 0x30, 0x00, 0x00}, /* 0x2b 856x480-60Hz   */
-        {0x006f,0x4d,0x71,0x06,0x15,0x5f, 768, 576, 0x30, 0x00, 0x00}, /* 0x2c 768x576-56Hz   */
-        {0x0067,0x52,0x6a,0x00,0x1c,0x1d, 960, 540, 0x30, 0x00, 0x00}, /* 0x2d 960x540 60Hz */
-        {0x0077,0x53,0x6b,0x0b,0x1d,0x20, 960, 600, 0x30, 0x00, 0x00}, /* 0x2e 960x600 60Hz */
-        {0x0087,0x1c,0x11,0x00,0x07,0x3a,1280,1024, 0x30, 0x00, 0x00}, /* 0x2f */
-        {0x0137,0x1d,0x19,0x07,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x30 */
-        {0x0107,0x1e,0x1e,0x00,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x31 */
-        {0x0207,0x1f,0x20,0x00,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x32 */
-        {0x0127,0x54,0x6d,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x33 1152x864-60Hz  */
-        {0x0127,0x44,0x19,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x34 1152x864-75Hz  */
-        {0x0127,0x4a,0x1e,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x35 1152x864-85Hz  */
-        {0xffff,0x00,0x00,0x00,0x00,0x00,   0,   0,    0, 0x00, 0x00}
+static const struct SiS_Ext2 SiSUSB_RefIndex[] = {
+        {0x085f, 0x0d, 0x03, 0x05, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x0 */
+        {0x0067, 0x0e, 0x04, 0x05, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x1 */
+        {0x0067, 0x0f, 0x08, 0x48, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x2 */
+        {0x0067, 0x10, 0x07, 0x8b, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x3 */
+        {0x0047, 0x11, 0x0a, 0x00, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x4 */
+        {0x0047, 0x12, 0x0d, 0x00, 0x05, 0x30, 800, 600, 0x40, 0x00, 0x00},     /* 0x5 */
+        {0x0047, 0x13, 0x13, 0x00, 0x05, 0x30, 800, 600, 0x20, 0x00, 0x00},     /* 0x6 */
+        {0x0107, 0x14, 0x1c, 0x00, 0x05, 0x30, 800, 600, 0x20, 0x00, 0x00},     /* 0x7 */
+        {0xc85f, 0x05, 0x00, 0x04, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0x8 */
+        {0xc067, 0x06, 0x02, 0x04, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0x9 */
+        {0xc067, 0x07, 0x02, 0x47, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xa */
+        {0xc067, 0x08, 0x03, 0x8a, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xb */
+        {0xc047, 0x09, 0x05, 0x00, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xc */
+        {0xc047, 0x0a, 0x09, 0x00, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xd */
+        {0xc047, 0x0b, 0x0e, 0x00, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xe */
+        {0xc047, 0x0c, 0x15, 0x00, 0x04, 0x2e, 640, 480, 0x40, 0x00, 0x00},     /* 0xf */
+        {0x487f, 0x04, 0x00, 0x00, 0x00, 0x2f, 640, 400, 0x30, 0x55, 0x6e},     /* 0x10 */
+        {0xc06f, 0x3c, 0x01, 0x06, 0x13, 0x31, 720, 480, 0x30, 0x00, 0x00},     /* 0x11 */
+        {0x006f, 0x3d, 0x6f, 0x06, 0x14, 0x32, 720, 576, 0x30, 0x00, 0x00},     /* 0x12 (6f was 03) */
+        {0x0087, 0x15, 0x06, 0x00, 0x06, 0x38, 1024, 768, 0x30, 0x00, 0x00},    /* 0x13 */
+        {0xc877, 0x16, 0x0b, 0x06, 0x06, 0x38, 1024, 768, 0x20, 0x00, 0x00},    /* 0x14 */
+        {0xc067, 0x17, 0x0f, 0x49, 0x06, 0x38, 1024, 768, 0x20, 0x00, 0x00},    /* 0x15 */
+        {0x0067, 0x18, 0x11, 0x00, 0x06, 0x38, 1024, 768, 0x20, 0x00, 0x00},    /* 0x16 */
+        {0x0047, 0x19, 0x16, 0x8c, 0x06, 0x38, 1024, 768, 0x20, 0x00, 0x00},    /* 0x17 */
+        {0x0107, 0x1a, 0x1b, 0x00, 0x06, 0x38, 1024, 768, 0x10, 0x00, 0x00},    /* 0x18 */
+        {0x0107, 0x1b, 0x1f, 0x00, 0x06, 0x38, 1024, 768, 0x10, 0x00, 0x00},    /* 0x19 */
+        {0x407f, 0x00, 0x00, 0x00, 0x00, 0x41, 320, 200, 0x30, 0x56, 0x4e},     /* 0x1a */
+        {0xc07f, 0x01, 0x00, 0x04, 0x04, 0x50, 320, 240, 0x30, 0x00, 0x00},     /* 0x1b */
+        {0x007f, 0x02, 0x04, 0x05, 0x05, 0x51, 400, 300, 0x30, 0x00, 0x00},     /* 0x1c */
+        {0xc077, 0x03, 0x0b, 0x06, 0x06, 0x52, 512, 384, 0x30, 0x00, 0x00},     /* 0x1d */
+        {0x0077, 0x32, 0x40, 0x08, 0x18, 0x70, 800, 480, 0x30, 0x00, 0x00},     /* 0x1e */
+        {0x0047, 0x33, 0x07, 0x08, 0x18, 0x70, 800, 480, 0x30, 0x00, 0x00},     /* 0x1f */
+        {0x0047, 0x34, 0x0a, 0x08, 0x18, 0x70, 800, 480, 0x30, 0x00, 0x00},     /* 0x20 */
+        {0x0077, 0x35, 0x0b, 0x09, 0x19, 0x71, 1024, 576, 0x30, 0x00, 0x00},    /* 0x21 */
+        {0x0047, 0x36, 0x11, 0x09, 0x19, 0x71, 1024, 576, 0x30, 0x00, 0x00},    /* 0x22 */
+        {0x0047, 0x37, 0x16, 0x09, 0x19, 0x71, 1024, 576, 0x30, 0x00, 0x00},    /* 0x23 */
+        {0x1137, 0x38, 0x19, 0x0a, 0x0c, 0x75, 1280, 720, 0x30, 0x00, 0x00},    /* 0x24 */
+        {0x1107, 0x39, 0x1e, 0x0a, 0x0c, 0x75, 1280, 720, 0x30, 0x00, 0x00},    /* 0x25 */
+        {0x1307, 0x3a, 0x20, 0x0a, 0x0c, 0x75, 1280, 720, 0x30, 0x00, 0x00},    /* 0x26 */
+        {0x0077, 0x42, 0x5b, 0x08, 0x11, 0x23, 1280, 768, 0x30, 0x00, 0x00},    /* 0x27 */
+        {0x0087, 0x45, 0x57, 0x00, 0x16, 0x39, 848, 480, 0x30, 0x00, 0x00},     /* 0x28 38Hzi  */
+        {0xc067, 0x46, 0x55, 0x0b, 0x16, 0x39, 848, 480, 0x30, 0x00, 0x00},     /* 0x29 848x480-60Hz   */
+        {0x0087, 0x47, 0x57, 0x00, 0x17, 0x3f, 856, 480, 0x30, 0x00, 0x00},     /* 0x2a 856x480-38Hzi  */
+        {0xc067, 0x48, 0x57, 0x00, 0x17, 0x3f, 856, 480, 0x30, 0x00, 0x00},     /* 0x2b 856x480-60Hz   */
+        {0x006f, 0x4d, 0x71, 0x06, 0x15, 0x5f, 768, 576, 0x30, 0x00, 0x00},     /* 0x2c 768x576-56Hz   */
+        {0x0067, 0x52, 0x6a, 0x00, 0x1c, 0x1d, 960, 540, 0x30, 0x00, 0x00},     /* 0x2d 960x540 60Hz */
+        {0x0077, 0x53, 0x6b, 0x0b, 0x1d, 0x20, 960, 600, 0x30, 0x00, 0x00},     /* 0x2e 960x600 60Hz */
+        {0x0087, 0x1c, 0x11, 0x00, 0x07, 0x3a, 1280, 1024, 0x30, 0x00, 0x00},   /* 0x2f */
+        {0x0137, 0x1d, 0x19, 0x07, 0x07, 0x3a, 1280, 1024, 0x00, 0x00, 0x00},   /* 0x30 */
+        {0x0107, 0x1e, 0x1e, 0x00, 0x07, 0x3a, 1280, 1024, 0x00, 0x00, 0x00},   /* 0x31 */
+        {0x0207, 0x1f, 0x20, 0x00, 0x07, 0x3a, 1280, 1024, 0x00, 0x00, 0x00},   /* 0x32 */
+        {0x0127, 0x54, 0x6d, 0x00, 0x1a, 0x29, 1152, 864, 0x30, 0x00, 0x00},    /* 0x33 1152x864-60Hz  */
+        {0x0127, 0x44, 0x19, 0x00, 0x1a, 0x29, 1152, 864, 0x30, 0x00, 0x00},    /* 0x34 1152x864-75Hz  */
+        {0x0127, 0x4a, 0x1e, 0x00, 0x1a, 0x29, 1152, 864, 0x30, 0x00, 0x00},    /* 0x35 1152x864-85Hz  */
+        {0xffff, 0x00, 0x00, 0x00, 0x00, 0x00, 0, 0, 0, 0x00, 0x00}
 };
 
-static const struct SiS_CRT1Table SiSUSB_CRT1Table[] =
-{
- {{0x2d,0x27,0x28,0x90,0x2c,0x80,0xbf,0x1f,
-   0x9c,0x8e,0x8f,0x96,0xb9,0x30,0x00,0x00,
-   0x00}}, /* 0x0 */
- {{0x2d,0x27,0x28,0x90,0x2c,0x80,0x0b,0x3e,
-   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x00,
-   0x00}}, /* 0x1 */
- {{0x3d,0x31,0x31,0x81,0x37,0x1f,0x72,0xf0,
-   0x58,0x8c,0x57,0x57,0x73,0x20,0x00,0x05,
-   0x01}}, /* 0x2 */
- {{0x4f,0x3f,0x3f,0x93,0x45,0x0d,0x24,0xf5,
-   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x01,
-   0x01}}, /* 0x3 */
- {{0x5f,0x4f,0x50,0x82,0x55,0x81,0xbf,0x1f,
-   0x9c,0x8e,0x8f,0x96,0xb9,0x30,0x00,0x05,
-   0x00}}, /* 0x4 */
- {{0x5f,0x4f,0x4f,0x83,0x55,0x81,0x0b,0x3e,
-   0xe9,0x8b,0xdf,0xe8,0x0c,0x00,0x00,0x05,
-   0x00}}, /* 0x5 */
- {{0x63,0x4f,0x4f,0x87,0x56,0x9b,0x06,0x3e,
-   0xe8,0x8a,0xdf,0xe7,0x07,0x00,0x00,0x01,
-   0x00}}, /* 0x6 */
- {{0x64,0x4f,0x4f,0x88,0x55,0x9d,0xf2,0x1f,
-   0xe0,0x83,0xdf,0xdf,0xf3,0x10,0x00,0x01,
-   0x00}}, /* 0x7 */
- {{0x63,0x4f,0x4f,0x87,0x5a,0x81,0xfb,0x1f,
-   0xe0,0x83,0xdf,0xdf,0xfc,0x10,0x00,0x05,
-   0x00}}, /* 0x8 */
- {{0x65,0x4f,0x4f,0x89,0x58,0x80,0xfb,0x1f,
-   0xe0,0x83,0xdf,0xdf,0xfc,0x10,0x00,0x05,
-   0x61}}, /* 0x9 */
- {{0x65,0x4f,0x4f,0x89,0x58,0x80,0x01,0x3e,
-   0xe0,0x83,0xdf,0xdf,0x02,0x00,0x00,0x05,
-   0x61}}, /* 0xa */
- {{0x67,0x4f,0x4f,0x8b,0x58,0x81,0x0d,0x3e,
-   0xe0,0x83,0xdf,0xdf,0x0e,0x00,0x00,0x05,
-   0x61}}, /* 0xb */
- {{0x65,0x4f,0x4f,0x89,0x57,0x9f,0xfb,0x1f,
-   0xe6,0x8a,0xdf,0xdf,0xfc,0x10,0x00,0x01,
-   0x00}}, /* 0xc */
- {{0x7b,0x63,0x63,0x9f,0x6a,0x93,0x6f,0xf0,
-   0x58,0x8a,0x57,0x57,0x70,0x20,0x00,0x05,
-   0x01}}, /* 0xd */
- {{0x7f,0x63,0x63,0x83,0x6c,0x1c,0x72,0xf0,
-   0x58,0x8c,0x57,0x57,0x73,0x20,0x00,0x06,
-   0x01}}, /* 0xe */
- {{0x7d,0x63,0x63,0x81,0x6e,0x1d,0x98,0xf0,
-   0x7c,0x82,0x57,0x57,0x99,0x00,0x00,0x06,
-   0x01}}, /* 0xf */
- {{0x7f,0x63,0x63,0x83,0x69,0x13,0x6f,0xf0,
-   0x58,0x8b,0x57,0x57,0x70,0x20,0x00,0x06,
-   0x01}}, /* 0x10 */
- {{0x7e,0x63,0x63,0x82,0x6b,0x13,0x75,0xf0,
-   0x58,0x8b,0x57,0x57,0x76,0x20,0x00,0x06,
-   0x01}}, /* 0x11 */
- {{0x81,0x63,0x63,0x85,0x6d,0x18,0x7a,0xf0,
-   0x58,0x8b,0x57,0x57,0x7b,0x20,0x00,0x06,
-   0x61}}, /* 0x12 */
- {{0x83,0x63,0x63,0x87,0x6e,0x19,0x81,0xf0,
-   0x58,0x8b,0x57,0x57,0x82,0x20,0x00,0x06,
-   0x61}}, /* 0x13 */
- {{0x85,0x63,0x63,0x89,0x6f,0x1a,0x91,0xf0,
-   0x58,0x8b,0x57,0x57,0x92,0x20,0x00,0x06,
-   0x61}}, /* 0x14 */
- {{0x99,0x7f,0x7f,0x9d,0x84,0x1a,0x96,0x1f,
-   0x7f,0x83,0x7f,0x7f,0x97,0x10,0x00,0x02,
-   0x00}}, /* 0x15 */
- {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf5,
-   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
-   0x01}}, /* 0x16 */
- {{0xa1,0x7f,0x7f,0x85,0x86,0x97,0x24,0xf5,
-   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
-   0x01}}, /* 0x17 */
- {{0x9f,0x7f,0x7f,0x83,0x85,0x91,0x1e,0xf5,
-   0x00,0x83,0xff,0xff,0x1f,0x10,0x00,0x02,
-   0x01}}, /* 0x18 */
- {{0xa7,0x7f,0x7f,0x8b,0x89,0x95,0x26,0xf5,
-   0x00,0x83,0xff,0xff,0x27,0x10,0x00,0x02,
-   0x01}}, /* 0x19 */
- {{0xa9,0x7f,0x7f,0x8d,0x8c,0x9a,0x2c,0xf5,
-   0x00,0x83,0xff,0xff,0x2d,0x14,0x00,0x02,
-   0x62}}, /* 0x1a */
- {{0xab,0x7f,0x7f,0x8f,0x8d,0x9b,0x35,0xf5,
-   0x00,0x83,0xff,0xff,0x36,0x14,0x00,0x02,
-   0x62}}, /* 0x1b */
- {{0xcf,0x9f,0x9f,0x93,0xb2,0x01,0x14,0xba,
-   0x00,0x83,0xff,0xff,0x15,0x00,0x00,0x03,
-   0x00}}, /* 0x1c */
- {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x28,0x5a,
-   0x00,0x83,0xff,0xff,0x29,0x09,0x00,0x07,
-   0x01}}, /* 0x1d */
- {{0xce,0x9f,0x9f,0x92,0xa5,0x17,0x28,0x5a,
-   0x00,0x83,0xff,0xff,0x29,0x09,0x00,0x07,
-   0x01}}, /* 0x1e */
- {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0x2e,0x5a,
-   0x00,0x83,0xff,0xff,0x2f,0x09,0x00,0x07,
-   0x01}}, /* 0x1f */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x20 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x21 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x22 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x23 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x24 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x25 */
- {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
-   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
-   0x00}}, /* 0x26 */
- {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
-   0x00}}, /* 0x27 */
- {{0x43,0xef,0xef,0x87,0x06,0x00,0xd4,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xd5,0x1f,0x41,0x05,
-   0x63}}, /* 0x28 */
- {{0x45,0xef,0xef,0x89,0x07,0x01,0xd9,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xda,0x1f,0x41,0x05,
-   0x63}}, /* 0x29 */
- {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
-   0x00}}, /* 0x2a */
- {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
-   0x00}}, /* 0x2b */
- {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
-   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
-   0x00}}, /* 0x2c */
- {{0x59,0xff,0xff,0x9d,0x17,0x13,0x33,0xba,
-   0x00,0x83,0xff,0xff,0x34,0x0f,0x41,0x05,
-   0x44}}, /* 0x2d */
- {{0x5b,0xff,0xff,0x9f,0x18,0x14,0x38,0xba,
-   0x00,0x83,0xff,0xff,0x39,0x0f,0x41,0x05,
-   0x44}}, /* 0x2e */
- {{0x5b,0xff,0xff,0x9f,0x18,0x14,0x3d,0xba,
-   0x00,0x83,0xff,0xff,0x3e,0x0f,0x41,0x05,
-   0x44}}, /* 0x2f */
- {{0x5d,0xff,0xff,0x81,0x19,0x95,0x41,0xba,
-   0x00,0x84,0xff,0xff,0x42,0x0f,0x41,0x05,
-   0x44}}, /* 0x30 */
- {{0x55,0xff,0xff,0x99,0x0d,0x0c,0x3e,0xba,
-   0x00,0x84,0xff,0xff,0x3f,0x0f,0x41,0x05,
-   0x00}}, /* 0x31 */
- {{0x7f,0x63,0x63,0x83,0x6c,0x1c,0x72,0xba,
-   0x27,0x8b,0xdf,0xdf,0x73,0x00,0x00,0x06,
-   0x01}}, /* 0x32 */
- {{0x7f,0x63,0x63,0x83,0x69,0x13,0x6f,0xba,
-   0x26,0x89,0xdf,0xdf,0x6f,0x00,0x00,0x06,
-   0x01}}, /* 0x33 */
- {{0x7f,0x63,0x63,0x82,0x6b,0x13,0x75,0xba,
-   0x29,0x8c,0xdf,0xdf,0x75,0x00,0x00,0x06,
-   0x01}}, /* 0x34 */
- {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf1,
-   0xaf,0x85,0x3f,0x3f,0x25,0x30,0x00,0x02,
-   0x01}}, /* 0x35 */
- {{0x9f,0x7f,0x7f,0x83,0x85,0x91,0x1e,0xf1,
-   0xad,0x81,0x3f,0x3f,0x1f,0x30,0x00,0x02,
-   0x01}}, /* 0x36 */
- {{0xa7,0x7f,0x7f,0x88,0x89,0x95,0x26,0xf1,
-   0xb1,0x85,0x3f,0x3f,0x27,0x30,0x00,0x02,
-   0x01}}, /* 0x37 */
- {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x28,0xc4,
-   0x7a,0x8e,0xcf,0xcf,0x29,0x21,0x00,0x07,
-   0x01}}, /* 0x38 */
- {{0xce,0x9f,0x9f,0x92,0xa5,0x17,0x28,0xd4,
-   0x7a,0x8e,0xcf,0xcf,0x29,0x21,0x00,0x07,
-   0x01}}, /* 0x39 */
- {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0x2e,0xd4,
-   0x7d,0x81,0xcf,0xcf,0x2f,0x21,0x00,0x07,
-   0x01}}, /* 0x3a */
- {{0xdc,0x9f,0x9f,0x80,0xaf,0x9d,0xe6,0xff,
-   0xc0,0x83,0xbf,0xbf,0xe7,0x10,0x00,0x07,
-   0x01}}, /* 0x3b */
- {{0x6b,0x59,0x59,0x8f,0x5e,0x8c,0x0b,0x3e,
-   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x05,
-   0x00}}, /* 0x3c */
- {{0x6d,0x59,0x59,0x91,0x60,0x89,0x53,0xf0,
-   0x41,0x84,0x3f,0x3f,0x54,0x00,0x00,0x05,
-   0x41}}, /* 0x3d */
- {{0x86,0x6a,0x6a,0x8a,0x74,0x06,0x8c,0x15,
-   0x4f,0x83,0xef,0xef,0x8d,0x30,0x00,0x02,
-   0x00}}, /* 0x3e */
- {{0x81,0x6a,0x6a,0x85,0x70,0x00,0x0f,0x3e,
-   0xeb,0x8e,0xdf,0xdf,0x10,0x00,0x00,0x02,
-   0x00}}, /* 0x3f */
- {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x1e,0xf1,
-   0xae,0x85,0x57,0x57,0x1f,0x30,0x00,0x02,
-   0x01}},  /* 0x40 */
- {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf5,
-   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
-   0x01}},  /* 0x41 */
- {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x20,0xf5,
-   0x03,0x88,0xff,0xff,0x21,0x10,0x00,0x07,
-   0x01}},  /* 0x42 */
- {{0xe6,0xae,0xae,0x8a,0xbd,0x90,0x3d,0x10,
-   0x1a,0x8d,0x19,0x19,0x3e,0x2f,0x00,0x03,
-   0x00}},  /* 0x43 */
- {{0xc3,0x8f,0x8f,0x87,0x9b,0x0b,0x82,0xef,
-   0x60,0x83,0x5f,0x5f,0x83,0x10,0x00,0x07,
-   0x01}},  /* 0x44 */
- {{0x86,0x69,0x69,0x8A,0x74,0x06,0x8C,0x15,
-   0x4F,0x83,0xEF,0xEF,0x8D,0x30,0x00,0x02,
-   0x00}},  /* 0x45 */
- {{0x83,0x69,0x69,0x87,0x6f,0x1d,0x03,0x3E,
-   0xE5,0x8d,0xDF,0xe4,0x04,0x00,0x00,0x06,
-   0x00}},  /* 0x46 */
- {{0x86,0x6A,0x6A,0x8A,0x74,0x06,0x8C,0x15,
-   0x4F,0x83,0xEF,0xEF,0x8D,0x30,0x00,0x02,
-   0x00}},  /* 0x47 */
- {{0x81,0x6A,0x6A,0x85,0x70,0x00,0x0F,0x3E,
-   0xEB,0x8E,0xDF,0xDF,0x10,0x00,0x00,0x02,
-   0x00}},  /* 0x48 */
- {{0xdd,0xa9,0xa9,0x81,0xb4,0x97,0x26,0xfd,
-   0x01,0x8d,0xff,0x00,0x27,0x10,0x00,0x03,
-   0x01}},  /* 0x49 */
- {{0xd9,0x8f,0x8f,0x9d,0xba,0x0a,0x8a,0xff,
-   0x60,0x8b,0x5f,0x5f,0x8b,0x10,0x00,0x03,
-   0x01}},  /* 0x4a */
- {{0xea,0xae,0xae,0x8e,0xba,0x82,0x40,0x10,
-   0x1b,0x87,0x19,0x1a,0x41,0x0f,0x00,0x03,
-   0x00}},  /* 0x4b */
- {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0xf1,0xff,
-   0xc0,0x83,0xbf,0xbf,0xf2,0x10,0x00,0x07,
-   0x01}},  /* 0x4c */
- {{0x75,0x5f,0x5f,0x99,0x66,0x90,0x53,0xf0,
-   0x41,0x84,0x3f,0x3f,0x54,0x00,0x00,0x05,
-   0x41}},
- {{0x2d,0x27,0x28,0x90,0x2c,0x80,0x0b,0x3e,
-   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x00,
-   0x00}},  /* 0x4e */
- {{0xcd,0x9f,0x9f,0x91,0xab,0x1c,0x3a,0xff,
-   0x20,0x83,0x1f,0x1f,0x3b,0x10,0x00,0x07,
-   0x21}},  /* 0x4f */
- {{0x15,0xd1,0xd1,0x99,0xe2,0x19,0x3d,0x10,
-   0x1a,0x8d,0x19,0x19,0x3e,0x2f,0x01,0x0c,
-   0x20}},  /* 0x50 */
- {{0x0e,0xef,0xef,0x92,0xfe,0x03,0x30,0xf0,
-   0x1e,0x83,0x1b,0x1c,0x31,0x00,0x01,0x00,
-   0x61}},  /* 0x51 */
- {{0x85,0x77,0x77,0x89,0x7d,0x01,0x31,0xf0,
-   0x1e,0x84,0x1b,0x1c,0x32,0x00,0x00,0x02,
-   0x41}},  /* 0x52 */
- {{0x87,0x77,0x77,0x8b,0x81,0x0b,0x68,0xf0,
-   0x5a,0x80,0x57,0x57,0x69,0x00,0x00,0x02,
-   0x01}},  /* 0x53 */
- {{0xcd,0x8f,0x8f,0x91,0x9b,0x1b,0x7a,0xff,
-   0x64,0x8c,0x5f,0x62,0x7b,0x10,0x00,0x07,
-   0x41}}   /* 0x54 */
+static const struct SiS_CRT1Table SiSUSB_CRT1Table[] = {
+        {{0x2d, 0x27, 0x28, 0x90, 0x2c, 0x80, 0xbf, 0x1f,
+          0x9c, 0x8e, 0x8f, 0x96, 0xb9, 0x30, 0x00, 0x00,
+          0x00}},               /* 0x0 */
+        {{0x2d, 0x27, 0x28, 0x90, 0x2c, 0x80, 0x0b, 0x3e,
+          0xe9, 0x8b, 0xdf, 0xe7, 0x04, 0x00, 0x00, 0x00,
+          0x00}},               /* 0x1 */
+        {{0x3d, 0x31, 0x31, 0x81, 0x37, 0x1f, 0x72, 0xf0,
+          0x58, 0x8c, 0x57, 0x57, 0x73, 0x20, 0x00, 0x05,
+          0x01}},               /* 0x2 */
+        {{0x4f, 0x3f, 0x3f, 0x93, 0x45, 0x0d, 0x24, 0xf5,
+          0x02, 0x88, 0xff, 0xff, 0x25, 0x10, 0x00, 0x01,
+          0x01}},               /* 0x3 */
+        {{0x5f, 0x4f, 0x50, 0x82, 0x55, 0x81, 0xbf, 0x1f,
+          0x9c, 0x8e, 0x8f, 0x96, 0xb9, 0x30, 0x00, 0x05,
+          0x00}},               /* 0x4 */
+        {{0x5f, 0x4f, 0x4f, 0x83, 0x55, 0x81, 0x0b, 0x3e,
+          0xe9, 0x8b, 0xdf, 0xe8, 0x0c, 0x00, 0x00, 0x05,
+          0x00}},               /* 0x5 */
+        {{0x63, 0x4f, 0x4f, 0x87, 0x56, 0x9b, 0x06, 0x3e,
+          0xe8, 0x8a, 0xdf, 0xe7, 0x07, 0x00, 0x00, 0x01,
+          0x00}},               /* 0x6 */
+        {{0x64, 0x4f, 0x4f, 0x88, 0x55, 0x9d, 0xf2, 0x1f,
+          0xe0, 0x83, 0xdf, 0xdf, 0xf3, 0x10, 0x00, 0x01,
+          0x00}},               /* 0x7 */
+        {{0x63, 0x4f, 0x4f, 0x87, 0x5a, 0x81, 0xfb, 0x1f,
+          0xe0, 0x83, 0xdf, 0xdf, 0xfc, 0x10, 0x00, 0x05,
+          0x00}},               /* 0x8 */
+        {{0x65, 0x4f, 0x4f, 0x89, 0x58, 0x80, 0xfb, 0x1f,
+          0xe0, 0x83, 0xdf, 0xdf, 0xfc, 0x10, 0x00, 0x05,
+          0x61}},               /* 0x9 */
+        {{0x65, 0x4f, 0x4f, 0x89, 0x58, 0x80, 0x01, 0x3e,
+          0xe0, 0x83, 0xdf, 0xdf, 0x02, 0x00, 0x00, 0x05,
+          0x61}},               /* 0xa */
+        {{0x67, 0x4f, 0x4f, 0x8b, 0x58, 0x81, 0x0d, 0x3e,
+          0xe0, 0x83, 0xdf, 0xdf, 0x0e, 0x00, 0x00, 0x05,
+          0x61}},               /* 0xb */
+        {{0x65, 0x4f, 0x4f, 0x89, 0x57, 0x9f, 0xfb, 0x1f,
+          0xe6, 0x8a, 0xdf, 0xdf, 0xfc, 0x10, 0x00, 0x01,
+          0x00}},               /* 0xc */
+        {{0x7b, 0x63, 0x63, 0x9f, 0x6a, 0x93, 0x6f, 0xf0,
+          0x58, 0x8a, 0x57, 0x57, 0x70, 0x20, 0x00, 0x05,
+          0x01}},               /* 0xd */
+        {{0x7f, 0x63, 0x63, 0x83, 0x6c, 0x1c, 0x72, 0xf0,
+          0x58, 0x8c, 0x57, 0x57, 0x73, 0x20, 0x00, 0x06,
+          0x01}},               /* 0xe */
+        {{0x7d, 0x63, 0x63, 0x81, 0x6e, 0x1d, 0x98, 0xf0,
+          0x7c, 0x82, 0x57, 0x57, 0x99, 0x00, 0x00, 0x06,
+          0x01}},               /* 0xf */
+        {{0x7f, 0x63, 0x63, 0x83, 0x69, 0x13, 0x6f, 0xf0,
+          0x58, 0x8b, 0x57, 0x57, 0x70, 0x20, 0x00, 0x06,
+          0x01}},               /* 0x10 */
+        {{0x7e, 0x63, 0x63, 0x82, 0x6b, 0x13, 0x75, 0xf0,
+          0x58, 0x8b, 0x57, 0x57, 0x76, 0x20, 0x00, 0x06,
+          0x01}},               /* 0x11 */
+        {{0x81, 0x63, 0x63, 0x85, 0x6d, 0x18, 0x7a, 0xf0,
+          0x58, 0x8b, 0x57, 0x57, 0x7b, 0x20, 0x00, 0x06,
+          0x61}},               /* 0x12 */
+        {{0x83, 0x63, 0x63, 0x87, 0x6e, 0x19, 0x81, 0xf0,
+          0x58, 0x8b, 0x57, 0x57, 0x82, 0x20, 0x00, 0x06,
+          0x61}},               /* 0x13 */
+        {{0x85, 0x63, 0x63, 0x89, 0x6f, 0x1a, 0x91, 0xf0,
+          0x58, 0x8b, 0x57, 0x57, 0x92, 0x20, 0x00, 0x06,
+          0x61}},               /* 0x14 */
+        {{0x99, 0x7f, 0x7f, 0x9d, 0x84, 0x1a, 0x96, 0x1f,
+          0x7f, 0x83, 0x7f, 0x7f, 0x97, 0x10, 0x00, 0x02,
+          0x00}},               /* 0x15 */
+        {{0xa3, 0x7f, 0x7f, 0x87, 0x86, 0x97, 0x24, 0xf5,
+          0x02, 0x88, 0xff, 0xff, 0x25, 0x10, 0x00, 0x02,
+          0x01}},               /* 0x16 */
+        {{0xa1, 0x7f, 0x7f, 0x85, 0x86, 0x97, 0x24, 0xf5,
+          0x02, 0x88, 0xff, 0xff, 0x25, 0x10, 0x00, 0x02,
+          0x01}},               /* 0x17 */
+        {{0x9f, 0x7f, 0x7f, 0x83, 0x85, 0x91, 0x1e, 0xf5,
+          0x00, 0x83, 0xff, 0xff, 0x1f, 0x10, 0x00, 0x02,
+          0x01}},               /* 0x18 */
+        {{0xa7, 0x7f, 0x7f, 0x8b, 0x89, 0x95, 0x26, 0xf5,
+          0x00, 0x83, 0xff, 0xff, 0x27, 0x10, 0x00, 0x02,
+          0x01}},               /* 0x19 */
+        {{0xa9, 0x7f, 0x7f, 0x8d, 0x8c, 0x9a, 0x2c, 0xf5,
+          0x00, 0x83, 0xff, 0xff, 0x2d, 0x14, 0x00, 0x02,
+          0x62}},               /* 0x1a */
+        {{0xab, 0x7f, 0x7f, 0x8f, 0x8d, 0x9b, 0x35, 0xf5,
+          0x00, 0x83, 0xff, 0xff, 0x36, 0x14, 0x00, 0x02,
+          0x62}},               /* 0x1b */
+        {{0xcf, 0x9f, 0x9f, 0x93, 0xb2, 0x01, 0x14, 0xba,
+          0x00, 0x83, 0xff, 0xff, 0x15, 0x00, 0x00, 0x03,
+          0x00}},               /* 0x1c */
+        {{0xce, 0x9f, 0x9f, 0x92, 0xa9, 0x17, 0x28, 0x5a,
+          0x00, 0x83, 0xff, 0xff, 0x29, 0x09, 0x00, 0x07,
+          0x01}},               /* 0x1d */
+        {{0xce, 0x9f, 0x9f, 0x92, 0xa5, 0x17, 0x28, 0x5a,
+          0x00, 0x83, 0xff, 0xff, 0x29, 0x09, 0x00, 0x07,
+          0x01}},               /* 0x1e */
+        {{0xd3, 0x9f, 0x9f, 0x97, 0xab, 0x1f, 0x2e, 0x5a,
+          0x00, 0x83, 0xff, 0xff, 0x2f, 0x09, 0x00, 0x07,
+          0x01}},               /* 0x1f */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x20 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x21 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x22 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x23 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x24 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x25 */
+        {{0x09, 0xc7, 0xc7, 0x8d, 0xd3, 0x0b, 0xe0, 0x10,
+          0xb0, 0x83, 0xaf, 0xaf, 0xe1, 0x2f, 0x01, 0x04,
+          0x00}},               /* 0x26 */
+        {{0x40, 0xef, 0xef, 0x84, 0x03, 0x1d, 0xda, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xdb, 0x1f, 0x41, 0x01,
+          0x00}},               /* 0x27 */
+        {{0x43, 0xef, 0xef, 0x87, 0x06, 0x00, 0xd4, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xd5, 0x1f, 0x41, 0x05,
+          0x63}},               /* 0x28 */
+        {{0x45, 0xef, 0xef, 0x89, 0x07, 0x01, 0xd9, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xda, 0x1f, 0x41, 0x05,
+          0x63}},               /* 0x29 */
+        {{0x40, 0xef, 0xef, 0x84, 0x03, 0x1d, 0xda, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xdb, 0x1f, 0x41, 0x01,
+          0x00}},               /* 0x2a */
+        {{0x40, 0xef, 0xef, 0x84, 0x03, 0x1d, 0xda, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xdb, 0x1f, 0x41, 0x01,
+          0x00}},               /* 0x2b */
+        {{0x40, 0xef, 0xef, 0x84, 0x03, 0x1d, 0xda, 0x1f,
+          0xa0, 0x83, 0x9f, 0x9f, 0xdb, 0x1f, 0x41, 0x01,
+          0x00}},               /* 0x2c */
+        {{0x59, 0xff, 0xff, 0x9d, 0x17, 0x13, 0x33, 0xba,
+          0x00, 0x83, 0xff, 0xff, 0x34, 0x0f, 0x41, 0x05,
+          0x44}},               /* 0x2d */
+        {{0x5b, 0xff, 0xff, 0x9f, 0x18, 0x14, 0x38, 0xba,
+          0x00, 0x83, 0xff, 0xff, 0x39, 0x0f, 0x41, 0x05,
+          0x44}},               /* 0x2e */
+        {{0x5b, 0xff, 0xff, 0x9f, 0x18, 0x14, 0x3d, 0xba,
+          0x00, 0x83, 0xff, 0xff, 0x3e, 0x0f, 0x41, 0x05,
+          0x44}},               /* 0x2f */
+        {{0x5d, 0xff, 0xff, 0x81, 0x19, 0x95, 0x41, 0xba,
+          0x00, 0x84, 0xff, 0xff, 0x42, 0x0f, 0x41, 0x05,
+          0x44}},               /* 0x30 */
+        {{0x55, 0xff, 0xff, 0x99, 0x0d, 0x0c, 0x3e, 0xba,
+          0x00, 0x84, 0xff, 0xff, 0x3f, 0x0f, 0x41, 0x05,
+          0x00}},               /* 0x31 */
+        {{0x7f, 0x63, 0x63, 0x83, 0x6c, 0x1c, 0x72, 0xba,
+          0x27, 0x8b, 0xdf, 0xdf, 0x73, 0x00, 0x00, 0x06,
+          0x01}},               /* 0x32 */
+        {{0x7f, 0x63, 0x63, 0x83, 0x69, 0x13, 0x6f, 0xba,
+          0x26, 0x89, 0xdf, 0xdf, 0x6f, 0x00, 0x00, 0x06,
+          0x01}},               /* 0x33 */
+        {{0x7f, 0x63, 0x63, 0x82, 0x6b, 0x13, 0x75, 0xba,
+          0x29, 0x8c, 0xdf, 0xdf, 0x75, 0x00, 0x00, 0x06,
+          0x01}},               /* 0x34 */
+        {{0xa3, 0x7f, 0x7f, 0x87, 0x86, 0x97, 0x24, 0xf1,
+          0xaf, 0x85, 0x3f, 0x3f, 0x25, 0x30, 0x00, 0x02,
+          0x01}},               /* 0x35 */
+        {{0x9f, 0x7f, 0x7f, 0x83, 0x85, 0x91, 0x1e, 0xf1,
+          0xad, 0x81, 0x3f, 0x3f, 0x1f, 0x30, 0x00, 0x02,
+          0x01}},               /* 0x36 */
+        {{0xa7, 0x7f, 0x7f, 0x88, 0x89, 0x95, 0x26, 0xf1,
+          0xb1, 0x85, 0x3f, 0x3f, 0x27, 0x30, 0x00, 0x02,
+          0x01}},               /* 0x37 */
+        {{0xce, 0x9f, 0x9f, 0x92, 0xa9, 0x17, 0x28, 0xc4,
+          0x7a, 0x8e, 0xcf, 0xcf, 0x29, 0x21, 0x00, 0x07,
+          0x01}},               /* 0x38 */
+        {{0xce, 0x9f, 0x9f, 0x92, 0xa5, 0x17, 0x28, 0xd4,
+          0x7a, 0x8e, 0xcf, 0xcf, 0x29, 0x21, 0x00, 0x07,
+          0x01}},               /* 0x39 */
+        {{0xd3, 0x9f, 0x9f, 0x97, 0xab, 0x1f, 0x2e, 0xd4,
+          0x7d, 0x81, 0xcf, 0xcf, 0x2f, 0x21, 0x00, 0x07,
+          0x01}},               /* 0x3a */
+        {{0xdc, 0x9f, 0x9f, 0x80, 0xaf, 0x9d, 0xe6, 0xff,
+          0xc0, 0x83, 0xbf, 0xbf, 0xe7, 0x10, 0x00, 0x07,
+          0x01}},               /* 0x3b */
+        {{0x6b, 0x59, 0x59, 0x8f, 0x5e, 0x8c, 0x0b, 0x3e,
+          0xe9, 0x8b, 0xdf, 0xe7, 0x04, 0x00, 0x00, 0x05,
+          0x00}},               /* 0x3c */
+        {{0x6d, 0x59, 0x59, 0x91, 0x60, 0x89, 0x53, 0xf0,
+          0x41, 0x84, 0x3f, 0x3f, 0x54, 0x00, 0x00, 0x05,
+          0x41}},               /* 0x3d */
+        {{0x86, 0x6a, 0x6a, 0x8a, 0x74, 0x06, 0x8c, 0x15,
+          0x4f, 0x83, 0xef, 0xef, 0x8d, 0x30, 0x00, 0x02,
+          0x00}},               /* 0x3e */
+        {{0x81, 0x6a, 0x6a, 0x85, 0x70, 0x00, 0x0f, 0x3e,
+          0xeb, 0x8e, 0xdf, 0xdf, 0x10, 0x00, 0x00, 0x02,
+          0x00}},               /* 0x3f */
+        {{0xa3, 0x7f, 0x7f, 0x87, 0x86, 0x97, 0x1e, 0xf1,
+          0xae, 0x85, 0x57, 0x57, 0x1f, 0x30, 0x00, 0x02,
+          0x01}},               /* 0x40 */
+        {{0xa3, 0x7f, 0x7f, 0x87, 0x86, 0x97, 0x24, 0xf5,
+          0x02, 0x88, 0xff, 0xff, 0x25, 0x10, 0x00, 0x02,
+          0x01}},               /* 0x41 */
+        {{0xce, 0x9f, 0x9f, 0x92, 0xa9, 0x17, 0x20, 0xf5,
+          0x03, 0x88, 0xff, 0xff, 0x21, 0x10, 0x00, 0x07,
+          0x01}},               /* 0x42 */
+        {{0xe6, 0xae, 0xae, 0x8a, 0xbd, 0x90, 0x3d, 0x10,
+          0x1a, 0x8d, 0x19, 0x19, 0x3e, 0x2f, 0x00, 0x03,
+          0x00}},               /* 0x43 */
+        {{0xc3, 0x8f, 0x8f, 0x87, 0x9b, 0x0b, 0x82, 0xef,
+          0x60, 0x83, 0x5f, 0x5f, 0x83, 0x10, 0x00, 0x07,
+          0x01}},               /* 0x44 */
+        {{0x86, 0x69, 0x69, 0x8A, 0x74, 0x06, 0x8C, 0x15,
+          0x4F, 0x83, 0xEF, 0xEF, 0x8D, 0x30, 0x00, 0x02,
+          0x00}},               /* 0x45 */
+        {{0x83, 0x69, 0x69, 0x87, 0x6f, 0x1d, 0x03, 0x3E,
+          0xE5, 0x8d, 0xDF, 0xe4, 0x04, 0x00, 0x00, 0x06,
+          0x00}},               /* 0x46 */
+        {{0x86, 0x6A, 0x6A, 0x8A, 0x74, 0x06, 0x8C, 0x15,
+          0x4F, 0x83, 0xEF, 0xEF, 0x8D, 0x30, 0x00, 0x02,
+          0x00}},               /* 0x47 */
+        {{0x81, 0x6A, 0x6A, 0x85, 0x70, 0x00, 0x0F, 0x3E,
+          0xEB, 0x8E, 0xDF, 0xDF, 0x10, 0x00, 0x00, 0x02,
+          0x00}},               /* 0x48 */
+        {{0xdd, 0xa9, 0xa9, 0x81, 0xb4, 0x97, 0x26, 0xfd,
+          0x01, 0x8d, 0xff, 0x00, 0x27, 0x10, 0x00, 0x03,
+          0x01}},               /* 0x49 */
+        {{0xd9, 0x8f, 0x8f, 0x9d, 0xba, 0x0a, 0x8a, 0xff,
+          0x60, 0x8b, 0x5f, 0x5f, 0x8b, 0x10, 0x00, 0x03,
+          0x01}},               /* 0x4a */
+        {{0xea, 0xae, 0xae, 0x8e, 0xba, 0x82, 0x40, 0x10,
+          0x1b, 0x87, 0x19, 0x1a, 0x41, 0x0f, 0x00, 0x03,
+          0x00}},               /* 0x4b */
+        {{0xd3, 0x9f, 0x9f, 0x97, 0xab, 0x1f, 0xf1, 0xff,
+          0xc0, 0x83, 0xbf, 0xbf, 0xf2, 0x10, 0x00, 0x07,
+          0x01}},               /* 0x4c */
+        {{0x75, 0x5f, 0x5f, 0x99, 0x66, 0x90, 0x53, 0xf0,
+          0x41, 0x84, 0x3f, 0x3f, 0x54, 0x00, 0x00, 0x05,
+          0x41}},
+        {{0x2d, 0x27, 0x28, 0x90, 0x2c, 0x80, 0x0b, 0x3e,
+          0xe9, 0x8b, 0xdf, 0xe7, 0x04, 0x00, 0x00, 0x00,
+          0x00}},               /* 0x4e */
+        {{0xcd, 0x9f, 0x9f, 0x91, 0xab, 0x1c, 0x3a, 0xff,
+          0x20, 0x83, 0x1f, 0x1f, 0x3b, 0x10, 0x00, 0x07,
+          0x21}},               /* 0x4f */
+        {{0x15, 0xd1, 0xd1, 0x99, 0xe2, 0x19, 0x3d, 0x10,
+          0x1a, 0x8d, 0x19, 0x19, 0x3e, 0x2f, 0x01, 0x0c,
+          0x20}},               /* 0x50 */
+        {{0x0e, 0xef, 0xef, 0x92, 0xfe, 0x03, 0x30, 0xf0,
+          0x1e, 0x83, 0x1b, 0x1c, 0x31, 0x00, 0x01, 0x00,
+          0x61}},               /* 0x51 */
+        {{0x85, 0x77, 0x77, 0x89, 0x7d, 0x01, 0x31, 0xf0,
+          0x1e, 0x84, 0x1b, 0x1c, 0x32, 0x00, 0x00, 0x02,
+          0x41}},               /* 0x52 */
+        {{0x87, 0x77, 0x77, 0x8b, 0x81, 0x0b, 0x68, 0xf0,
+          0x5a, 0x80, 0x57, 0x57, 0x69, 0x00, 0x00, 0x02,
+          0x01}},               /* 0x53 */
+        {{0xcd, 0x8f, 0x8f, 0x91, 0x9b, 0x1b, 0x7a, 0xff,
+          0x64, 0x8c, 0x5f, 0x62, 0x7b, 0x10, 0x00, 0x07,
+          0x41}}                /* 0x54 */
 };
 
-static const struct SiS_VCLKData SiSUSB_VCLKData[] =
-{
-        { 0x1b,0xe1, 25}, /* 0x00 */
-        { 0x4e,0xe4, 28}, /* 0x01 */
-        { 0x57,0xe4, 31}, /* 0x02 */
-        { 0xc3,0xc8, 36}, /* 0x03 */
-        { 0x42,0xe2, 40}, /* 0x04 */
-        { 0xfe,0xcd, 43}, /* 0x05 */
-        { 0x5d,0xc4, 44}, /* 0x06 */
-        { 0x52,0xe2, 49}, /* 0x07 */
-        { 0x53,0xe2, 50}, /* 0x08 */
-        { 0x74,0x67, 52}, /* 0x09 */
-        { 0x6d,0x66, 56}, /* 0x0a */
-        { 0x5a,0x64, 65}, /* 0x0b */
-        { 0x46,0x44, 67}, /* 0x0c */
-        { 0xb1,0x46, 68}, /* 0x0d */
-        { 0xd3,0x4a, 72}, /* 0x0e */
-        { 0x29,0x61, 75}, /* 0x0f */
-        { 0x6e,0x46, 76}, /* 0x10 */
-        { 0x2b,0x61, 78}, /* 0x11 */
-        { 0x31,0x42, 79}, /* 0x12 */
-        { 0xab,0x44, 83}, /* 0x13 */
-        { 0x46,0x25, 84}, /* 0x14 */
-        { 0x78,0x29, 86}, /* 0x15 */
-        { 0x62,0x44, 94}, /* 0x16 */
-        { 0x2b,0x41,104}, /* 0x17 */
-        { 0x3a,0x23,105}, /* 0x18 */
-        { 0x70,0x44,108}, /* 0x19 */
-        { 0x3c,0x23,109}, /* 0x1a */
-        { 0x5e,0x43,113}, /* 0x1b */
-        { 0xbc,0x44,116}, /* 0x1c */
-        { 0xe0,0x46,132}, /* 0x1d */
-        { 0x54,0x42,135}, /* 0x1e */
-        { 0xea,0x2a,139}, /* 0x1f */
-        { 0x41,0x22,157}, /* 0x20 */
-        { 0x70,0x24,162}, /* 0x21 */
-        { 0x30,0x21,175}, /* 0x22 */
-        { 0x4e,0x22,189}, /* 0x23 */
-        { 0xde,0x26,194}, /* 0x24 */
-        { 0x62,0x06,202}, /* 0x25 */
-        { 0x3f,0x03,229}, /* 0x26 */
-        { 0xb8,0x06,234}, /* 0x27 */
-        { 0x34,0x02,253}, /* 0x28 */
-        { 0x58,0x04,255}, /* 0x29 */
-        { 0x24,0x01,265}, /* 0x2a */
-        { 0x9b,0x02,267}, /* 0x2b */
-        { 0x70,0x05,270}, /* 0x2c */
-        { 0x25,0x01,272}, /* 0x2d */
-        { 0x9c,0x02,277}, /* 0x2e */
-        { 0x27,0x01,286}, /* 0x2f */
-        { 0x3c,0x02,291}, /* 0x30 */
-        { 0xef,0x0a,292}, /* 0x31 */
-        { 0xf6,0x0a,310}, /* 0x32 */
-        { 0x95,0x01,315}, /* 0x33 */
-        { 0xf0,0x09,324}, /* 0x34 */
-        { 0xfe,0x0a,331}, /* 0x35 */
-        { 0xf3,0x09,332}, /* 0x36 */
-        { 0xea,0x08,340}, /* 0x37 */
-        { 0xe8,0x07,376}, /* 0x38 */
-        { 0xde,0x06,389}, /* 0x39 */
-        { 0x52,0x2a, 54}, /* 0x3a 301 TV */
-        { 0x52,0x6a, 27}, /* 0x3b 301 TV */
-        { 0x62,0x24, 70}, /* 0x3c 301 TV */
-        { 0x62,0x64, 70}, /* 0x3d 301 TV */
-        { 0xa8,0x4c, 30}, /* 0x3e 301 TV */
-        { 0x20,0x26, 33}, /* 0x3f 301 TV */
-        { 0x31,0xc2, 39}, /* 0x40 */
-        { 0x60,0x36, 30}, /* 0x41 Chrontel */
-        { 0x40,0x4a, 28}, /* 0x42 Chrontel */
-        { 0x9f,0x46, 44}, /* 0x43 Chrontel */
-        { 0x97,0x2c, 26}, /* 0x44 */
-        { 0x44,0xe4, 25}, /* 0x45 Chrontel */
-        { 0x7e,0x32, 47}, /* 0x46 Chrontel */
-        { 0x8a,0x24, 31}, /* 0x47 Chrontel */
-        { 0x97,0x2c, 26}, /* 0x48 Chrontel */
-        { 0xce,0x3c, 39}, /* 0x49 */
-        { 0x52,0x4a, 36}, /* 0x4a Chrontel */
-        { 0x34,0x61, 95}, /* 0x4b */
-        { 0x78,0x27,108}, /* 0x4c - was 102 */
-        { 0x66,0x43,123}, /* 0x4d Modes 0x26-0x28 (1400x1050) */
-        { 0x41,0x4e, 21}, /* 0x4e */
-        { 0xa1,0x4a, 29}, /* 0x4f Chrontel */
-        { 0x19,0x42, 42}, /* 0x50 */
-        { 0x54,0x46, 58}, /* 0x51 Chrontel */
-        { 0x25,0x42, 61}, /* 0x52 */
-        { 0x44,0x44, 66}, /* 0x53 Chrontel */
-        { 0x3a,0x62, 70}, /* 0x54 Chrontel */
-        { 0x62,0xc6, 34}, /* 0x55 848x480-60 */
-        { 0x6a,0xc6, 37}, /* 0x56 848x480-75 - TEMP */
-        { 0xbf,0xc8, 35}, /* 0x57 856x480-38i,60 */
-        { 0x30,0x23, 88}, /* 0x58 1360x768-62 (is 60Hz!) */
-        { 0x52,0x07,149}, /* 0x59 1280x960-85 */
-        { 0x56,0x07,156}, /* 0x5a 1400x1050-75 */
-        { 0x70,0x29, 81}, /* 0x5b 1280x768 LCD */
-        { 0x45,0x25, 83}, /* 0x5c 1280x800  */
-        { 0x70,0x0a,147}, /* 0x5d 1680x1050 */
-        { 0x70,0x24,162}, /* 0x5e 1600x1200 */
-        { 0x5a,0x64, 65}, /* 0x5f 1280x720 - temp */
-        { 0x63,0x46, 68}, /* 0x60 1280x768_2 */
-        { 0x31,0x42, 79}, /* 0x61 1280x768_3 - temp */
-        {    0,   0,  0}, /* 0x62 - custom (will be filled out at run-time) */
-        { 0x5a,0x64, 65}, /* 0x63 1280x720 (LCD LVDS) */
-        { 0x70,0x28, 90}, /* 0x64 1152x864@60 */
-        { 0x41,0xc4, 32}, /* 0x65 848x480@60 */
-        { 0x5c,0xc6, 32}, /* 0x66 856x480@60 */
-        { 0x76,0xe7, 27}, /* 0x67 720x480@60 */
-        { 0x5f,0xc6, 33}, /* 0x68 720/768x576@60 */
-        { 0x52,0x27, 75}, /* 0x69 1920x1080i 60Hz interlaced */
-        { 0x7c,0x6b, 38}, /* 0x6a 960x540@60 */
-        { 0xe3,0x56, 41}, /* 0x6b 960x600@60 */
-        { 0x45,0x25, 83}, /* 0x6c 1280x800 */
-        { 0x70,0x28, 90}, /* 0x6d 1152x864@60 */
-        { 0x15,0xe1, 20}, /* 0x6e 640x400@60 (fake, not actually used) */
-        { 0x5f,0xc6, 33}, /* 0x6f 720x576@60 */
-        { 0x37,0x5a, 10}, /* 0x70 320x200@60 (fake, not actually used) */
-        { 0x2b,0xc2, 35}  /* 0x71 768@576@60 */
+static const struct SiS_VCLKData SiSUSB_VCLKData[] = {
+        {0x1b, 0xe1, 25},       /* 0x00 */
+        {0x4e, 0xe4, 28},       /* 0x01 */
+        {0x57, 0xe4, 31},       /* 0x02 */
+        {0xc3, 0xc8, 36},       /* 0x03 */
+        {0x42, 0xe2, 40},       /* 0x04 */
+        {0xfe, 0xcd, 43},       /* 0x05 */
+        {0x5d, 0xc4, 44},       /* 0x06 */
+        {0x52, 0xe2, 49},       /* 0x07 */
+        {0x53, 0xe2, 50},       /* 0x08 */
+        {0x74, 0x67, 52},       /* 0x09 */
+        {0x6d, 0x66, 56},       /* 0x0a */
+        {0x5a, 0x64, 65},       /* 0x0b */
+        {0x46, 0x44, 67},       /* 0x0c */
+        {0xb1, 0x46, 68},       /* 0x0d */
+        {0xd3, 0x4a, 72},       /* 0x0e */
+        {0x29, 0x61, 75},       /* 0x0f */
+        {0x6e, 0x46, 76},       /* 0x10 */
+        {0x2b, 0x61, 78},       /* 0x11 */
+        {0x31, 0x42, 79},       /* 0x12 */
+        {0xab, 0x44, 83},       /* 0x13 */
+        {0x46, 0x25, 84},       /* 0x14 */
+        {0x78, 0x29, 86},       /* 0x15 */
+        {0x62, 0x44, 94},       /* 0x16 */
+        {0x2b, 0x41, 104},      /* 0x17 */
+        {0x3a, 0x23, 105},      /* 0x18 */
+        {0x70, 0x44, 108},      /* 0x19 */
+        {0x3c, 0x23, 109},      /* 0x1a */
+        {0x5e, 0x43, 113},      /* 0x1b */
+        {0xbc, 0x44, 116},      /* 0x1c */
+        {0xe0, 0x46, 132},      /* 0x1d */
+        {0x54, 0x42, 135},      /* 0x1e */
+        {0xea, 0x2a, 139},      /* 0x1f */
+        {0x41, 0x22, 157},      /* 0x20 */
+        {0x70, 0x24, 162},      /* 0x21 */
+        {0x30, 0x21, 175},      /* 0x22 */
+        {0x4e, 0x22, 189},      /* 0x23 */
+        {0xde, 0x26, 194},      /* 0x24 */
+        {0x62, 0x06, 202},      /* 0x25 */
+        {0x3f, 0x03, 229},      /* 0x26 */
+        {0xb8, 0x06, 234},      /* 0x27 */
+        {0x34, 0x02, 253},      /* 0x28 */
+        {0x58, 0x04, 255},      /* 0x29 */
+        {0x24, 0x01, 265},      /* 0x2a */
+        {0x9b, 0x02, 267},      /* 0x2b */
+        {0x70, 0x05, 270},      /* 0x2c */
+        {0x25, 0x01, 272},      /* 0x2d */
+        {0x9c, 0x02, 277},      /* 0x2e */
+        {0x27, 0x01, 286},      /* 0x2f */
+        {0x3c, 0x02, 291},      /* 0x30 */
+        {0xef, 0x0a, 292},      /* 0x31 */
+        {0xf6, 0x0a, 310},      /* 0x32 */
+        {0x95, 0x01, 315},      /* 0x33 */
+        {0xf0, 0x09, 324},      /* 0x34 */
+        {0xfe, 0x0a, 331},      /* 0x35 */
+        {0xf3, 0x09, 332},      /* 0x36 */
+        {0xea, 0x08, 340},      /* 0x37 */
+        {0xe8, 0x07, 376},      /* 0x38 */
+        {0xde, 0x06, 389},      /* 0x39 */
+        {0x52, 0x2a, 54},       /* 0x3a 301 TV */
+        {0x52, 0x6a, 27},       /* 0x3b 301 TV */
+        {0x62, 0x24, 70},       /* 0x3c 301 TV */
+        {0x62, 0x64, 70},       /* 0x3d 301 TV */
+        {0xa8, 0x4c, 30},       /* 0x3e 301 TV */
+        {0x20, 0x26, 33},       /* 0x3f 301 TV */
+        {0x31, 0xc2, 39},       /* 0x40 */
+        {0x60, 0x36, 30},       /* 0x41 Chrontel */
+        {0x40, 0x4a, 28},       /* 0x42 Chrontel */
+        {0x9f, 0x46, 44},       /* 0x43 Chrontel */
+        {0x97, 0x2c, 26},       /* 0x44 */
+        {0x44, 0xe4, 25},       /* 0x45 Chrontel */
+        {0x7e, 0x32, 47},       /* 0x46 Chrontel */
+        {0x8a, 0x24, 31},       /* 0x47 Chrontel */
+        {0x97, 0x2c, 26},       /* 0x48 Chrontel */
+        {0xce, 0x3c, 39},       /* 0x49 */
+        {0x52, 0x4a, 36},       /* 0x4a Chrontel */
+        {0x34, 0x61, 95},       /* 0x4b */
+        {0x78, 0x27, 108},      /* 0x4c - was 102 */
+        {0x66, 0x43, 123},      /* 0x4d Modes 0x26-0x28 (1400x1050) */
+        {0x41, 0x4e, 21},       /* 0x4e */
+        {0xa1, 0x4a, 29},       /* 0x4f Chrontel */
+        {0x19, 0x42, 42},       /* 0x50 */
+        {0x54, 0x46, 58},       /* 0x51 Chrontel */
+        {0x25, 0x42, 61},       /* 0x52 */
+        {0x44, 0x44, 66},       /* 0x53 Chrontel */
+        {0x3a, 0x62, 70},       /* 0x54 Chrontel */
+        {0x62, 0xc6, 34},       /* 0x55 848x480-60 */
+        {0x6a, 0xc6, 37},       /* 0x56 848x480-75 - TEMP */
+        {0xbf, 0xc8, 35},       /* 0x57 856x480-38i,60 */
+        {0x30, 0x23, 88},       /* 0x58 1360x768-62 (is 60Hz!) */
+        {0x52, 0x07, 149},      /* 0x59 1280x960-85 */
+        {0x56, 0x07, 156},      /* 0x5a 1400x1050-75 */
+        {0x70, 0x29, 81},       /* 0x5b 1280x768 LCD */
+        {0x45, 0x25, 83},       /* 0x5c 1280x800  */
+        {0x70, 0x0a, 147},      /* 0x5d 1680x1050 */
+        {0x70, 0x24, 162},      /* 0x5e 1600x1200 */
+        {0x5a, 0x64, 65},       /* 0x5f 1280x720 - temp */
+        {0x63, 0x46, 68},       /* 0x60 1280x768_2 */
+        {0x31, 0x42, 79},       /* 0x61 1280x768_3 - temp */
+        {0, 0, 0},              /* 0x62 - custom (will be filled out at run-time) */
+        {0x5a, 0x64, 65},       /* 0x63 1280x720 (LCD LVDS) */
+        {0x70, 0x28, 90},       /* 0x64 1152x864@60 */
+        {0x41, 0xc4, 32},       /* 0x65 848x480@60 */
+        {0x5c, 0xc6, 32},       /* 0x66 856x480@60 */
+        {0x76, 0xe7, 27},       /* 0x67 720x480@60 */
+        {0x5f, 0xc6, 33},       /* 0x68 720/768x576@60 */
+        {0x52, 0x27, 75},       /* 0x69 1920x1080i 60Hz interlaced */
+        {0x7c, 0x6b, 38},       /* 0x6a 960x540@60 */
+        {0xe3, 0x56, 41},       /* 0x6b 960x600@60 */
+        {0x45, 0x25, 83},       /* 0x6c 1280x800 */
+        {0x70, 0x28, 90},       /* 0x6d 1152x864@60 */
+        {0x15, 0xe1, 20},       /* 0x6e 640x400@60 (fake, not actually used) */
+        {0x5f, 0xc6, 33},       /* 0x6f 720x576@60 */
+        {0x37, 0x5a, 10},       /* 0x70 320x200@60 (fake, not actually used) */
+        {0x2b, 0xc2, 35}        /* 0x71 768@576@60 */
 };
 
-int             SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo);
-int             SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo);
+int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo);
+int SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo);
 
-extern int      sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data);
-extern int      sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data);
-extern int      sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port,
-                                        u8 index, u8 data);
-extern int      sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port,
-                                        u8 index, u8 *data);
-extern int      sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port,
-                                        u8 idx, u8 myand, u8 myor);
-extern int      sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port,
-                                        u8 index, u8 myor);
-extern int      sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port,
-                                        u8 idx, u8 myand);
+extern int sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data);
+extern int sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 * data);
+extern int sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port,
+                            u8 index, u8 data);
+extern int sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port,
+                            u8 index, u8 * data);
+extern int sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port,
+                                 u8 idx, u8 myand, u8 myor);
+extern int sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port,
+                              u8 index, u8 myor);
+extern int sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port,
+                               u8 idx, u8 myand);
 
 void sisusb_delete(struct kref *kref);
 int sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data);
-int sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data);
+int sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 * data);
 int sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
-                       u32 dest, int length, size_t *bytes_written);
+                       u32 dest, int length, size_t * bytes_written);
 int sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init);
 int sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
-                         u8 *arg, int cmapsz, int ch512, int dorecalc,
+                         u8 * arg, int cmapsz, int ch512, int dorecalc,
                          struct vc_data *c, int fh, int uplock);
 void sisusb_set_cursor(struct sisusb_usb_data *sisusb, unsigned int location);
 int sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last);
@@ -839,4 +839,3 @@ void sisusb_console_exit(struct sisusb_usb_data *sisusb);
 void sisusb_init_concode(void);
 
 #endif
-
diff --git a/drivers/usb/misc/sisusbvga/sisusb_struct.h b/drivers/usb/misc/sisusbvga/sisusb_struct.h
index f325ecb29a..1c4240e802 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_struct.h
+++ b/drivers/usb/misc/sisusbvga/sisusb_struct.h
@@ -44,7 +44,7 @@
  * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  *
  */
 
@@ -52,85 +52,78 @@
 #define _SISUSB_STRUCT_H_
 
 struct SiS_St {
-        unsigned char   St_ModeID;
-        unsigned short  St_ModeFlag;
-        unsigned char   St_StTableIndex;
-        unsigned char   St_CRT2CRTC;
-        unsigned char   St_ResInfo;
-        unsigned char   VB_StTVFlickerIndex;
-        unsigned char   VB_StTVEdgeIndex;
-        unsigned char   VB_StTVYFilterIndex;
-        unsigned char   St_PDC;
+        unsigned char St_ModeID;
+        unsigned short St_ModeFlag;
+        unsigned char St_StTableIndex;
+        unsigned char St_CRT2CRTC;
+        unsigned char St_ResInfo;
+        unsigned char VB_StTVFlickerIndex;
+        unsigned char VB_StTVEdgeIndex;
+        unsigned char VB_StTVYFilterIndex;
+        unsigned char St_PDC;
 };
 
-struct SiS_StandTable
-{
-        unsigned char   CRT_COLS;
-        unsigned char   ROWS;
-        unsigned char   CHAR_HEIGHT;
-        unsigned short  CRT_LEN;
-        unsigned char   SR[4];
-        unsigned char   MISC;
-        unsigned char   CRTC[0x19];
-        unsigned char   ATTR[0x14];
-        unsigned char   GRC[9];
+struct SiS_StandTable {
+        unsigned char CRT_COLS;
+        unsigned char ROWS;
+        unsigned char CHAR_HEIGHT;
+        unsigned short CRT_LEN;
+        unsigned char SR[4];
+        unsigned char MISC;
+        unsigned char CRTC[0x19];
+        unsigned char ATTR[0x14];
+        unsigned char GRC[9];
 };
 
 struct SiS_StResInfo_S {
-        unsigned short  HTotal;
-        unsigned short  VTotal;
+        unsigned short HTotal;
+        unsigned short VTotal;
 };
 
-struct SiS_Ext
-{
-        unsigned char   Ext_ModeID;
-        unsigned short  Ext_ModeFlag;
-        unsigned short  Ext_VESAID;
-        unsigned char   Ext_RESINFO;
-        unsigned char   VB_ExtTVFlickerIndex;
-        unsigned char   VB_ExtTVEdgeIndex;
-        unsigned char   VB_ExtTVYFilterIndex;
-        unsigned char   VB_ExtTVYFilterIndexROM661;
-        unsigned char   REFindex;
-        char            ROMMODEIDX661;
+struct SiS_Ext {
+        unsigned char Ext_ModeID;
+        unsigned short Ext_ModeFlag;
+        unsigned short Ext_VESAID;
+        unsigned char Ext_RESINFO;
+        unsigned char VB_ExtTVFlickerIndex;
+        unsigned char VB_ExtTVEdgeIndex;
+        unsigned char VB_ExtTVYFilterIndex;
+        unsigned char VB_ExtTVYFilterIndexROM661;
+        unsigned char REFindex;
+        char ROMMODEIDX661;
 };
 
-struct SiS_Ext2
-{
-        unsigned short  Ext_InfoFlag;
-        unsigned char   Ext_CRT1CRTC;
-        unsigned char   Ext_CRTVCLK;
-        unsigned char   Ext_CRT2CRTC;
-        unsigned char   Ext_CRT2CRTC_NS;
-        unsigned char   ModeID;
-        unsigned short  XRes;
-        unsigned short  YRes;
-        unsigned char   Ext_PDC;
-        unsigned char   Ext_FakeCRT2CRTC;
-        unsigned char   Ext_FakeCRT2Clk;
+struct SiS_Ext2 {
+        unsigned short Ext_InfoFlag;
+        unsigned char Ext_CRT1CRTC;
+        unsigned char Ext_CRTVCLK;
+        unsigned char Ext_CRT2CRTC;
+        unsigned char Ext_CRT2CRTC_NS;
+        unsigned char ModeID;
+        unsigned short XRes;
+        unsigned short YRes;
+        unsigned char Ext_PDC;
+        unsigned char Ext_FakeCRT2CRTC;
+        unsigned char Ext_FakeCRT2Clk;
 };
 
-struct SiS_CRT1Table
-{
-        unsigned char   CR[17];
+struct SiS_CRT1Table {
+        unsigned char CR[17];
 };
 
-struct SiS_VCLKData
-{
-        unsigned char   SR2B,SR2C;
-        unsigned short  CLOCK;
+struct SiS_VCLKData {
+        unsigned char SR2B, SR2C;
+        unsigned short CLOCK;
 };
 
-struct SiS_ModeResInfo
-{
-        unsigned short  HTotal;
-        unsigned short  VTotal;
-        unsigned char   XChar;
-        unsigned char   YChar;
+struct SiS_ModeResInfo {
+        unsigned short HTotal;
+        unsigned short VTotal;
+        unsigned char XChar;
+        unsigned char YChar;
 };
 
-struct SiS_Private
-{
+struct SiS_Private {
         void *sisusb;
 
         unsigned long IOAddress;
@@ -151,19 +144,18 @@ struct SiS_Private
         unsigned long SiS_P3da;
         unsigned long SiS_Part1Port;
 
-        unsigned char   SiS_MyCR63;
-        unsigned short  SiS_CRT1Mode;
-        unsigned short  SiS_ModeType;
-        unsigned short  SiS_SetFlag;
-
-        const struct SiS_StandTable     *SiS_StandTable;
-        const struct SiS_St             *SiS_SModeIDTable;
-        const struct SiS_Ext            *SiS_EModeIDTable;
-        const struct SiS_Ext2           *SiS_RefIndex;
-        const struct SiS_CRT1Table      *SiS_CRT1Table;
-        const struct SiS_VCLKData       *SiS_VCLKData;
-        const struct SiS_ModeResInfo    *SiS_ModeResInfo;
+        unsigned char SiS_MyCR63;
+        unsigned short SiS_CRT1Mode;
+        unsigned short SiS_ModeType;
+        unsigned short SiS_SetFlag;
+
+        const struct SiS_StandTable *SiS_StandTable;
+        const struct SiS_St *SiS_SModeIDTable;
+        const struct SiS_Ext *SiS_EModeIDTable;
+        const struct SiS_Ext2 *SiS_RefIndex;
+        const struct SiS_CRT1Table *SiS_CRT1Table;
+        const struct SiS_VCLKData *SiS_VCLKData;
+        const struct SiS_ModeResInfo *SiS_ModeResInfo;
 };
 
 #endif
-
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index c03dfd7a9d..f06e4e2b49 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -172,6 +172,10 @@ static inline struct mon_bin_hdr *MON_OFF2HDR(const struct mon_reader_bin *rp,
 
 #define MON_RING_EMPTY(rp)      ((rp)->b_cnt == 0)
 
+static unsigned char xfer_to_pipe[4] = {
+        PIPE_CONTROL, PIPE_ISOCHRONOUS, PIPE_BULK, PIPE_INTERRUPT
+};
+
 static struct class *mon_bin_class;
 static dev_t mon_bin_dev0;
 static struct cdev mon_bin_cdev;
@@ -354,13 +358,9 @@ static inline char mon_bin_get_setup(unsigned char *setupb,
     const struct urb *urb, char ev_type)
 {
 
-        if (!usb_pipecontrol(urb->pipe) || ev_type != 'S')
+        if (!usb_endpoint_xfer_control(&urb->ep->desc) || ev_type != 'S')
                 return '-';
 
-        if (urb->dev->bus->uses_dma &&
-            (urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) {
-                return mon_dmapeek(setupb, urb->setup_dma, SETUP_LEN);
-        }
         if (urb->setup_packet == NULL)
                 return 'Z';
 
@@ -386,13 +386,15 @@ static char mon_bin_get_data(const struct mon_reader_bin *rp,
 }
 
 static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
-    char ev_type)
+    char ev_type, int status)
 {
+        const struct usb_endpoint_descriptor *epd = &urb->ep->desc;
         unsigned long flags;
         struct timeval ts;
         unsigned int urb_length;
         unsigned int offset;
         unsigned int length;
+        unsigned char dir;
         struct mon_bin_hdr *ep;
         char data_tag = 0;
 
@@ -410,16 +412,19 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
         if (length >= rp->b_size/5)
                 length = rp->b_size/5;
 
-        if (usb_pipein(urb->pipe)) {
+        if (usb_urb_dir_in(urb)) {
                 if (ev_type == 'S') {
                         length = 0;
                         data_tag = '<';
                 }
+                /* Cannot rely on endpoint number in case of control ep.0 */
+                dir = USB_DIR_IN;
         } else {
                 if (ev_type == 'C') {
                         length = 0;
                         data_tag = '>';
                 }
+                dir = 0;
         }
 
         if (rp->mmap_active)
@@ -440,15 +445,14 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
          */
         memset(ep, 0, PKT_SIZE);
         ep->type = ev_type;
-        ep->xfer_type = usb_pipetype(urb->pipe);
-        /* We use the fact that usb_pipein() returns 0x80 */
-        ep->epnum = usb_pipeendpoint(urb->pipe) | usb_pipein(urb->pipe);
-        ep->devnum = usb_pipedevice(urb->pipe);
+        ep->xfer_type = xfer_to_pipe[usb_endpoint_type(epd)];
+        ep->epnum = dir | usb_endpoint_num(epd);
+        ep->devnum = urb->dev->devnum;
         ep->busnum = urb->dev->bus->busnum;
         ep->id = (unsigned long) urb;
         ep->ts_sec = ts.tv_sec;
         ep->ts_usec = ts.tv_usec;
-        ep->status = urb->status;
+        ep->status = status;
         ep->len_urb = urb_length;
         ep->len_cap = length;
 
@@ -471,13 +475,13 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
 static void mon_bin_submit(void *data, struct urb *urb)
 {
         struct mon_reader_bin *rp = data;
-        mon_bin_event(rp, urb, 'S');
+        mon_bin_event(rp, urb, 'S', -EINPROGRESS);
 }
 
-static void mon_bin_complete(void *data, struct urb *urb)
+static void mon_bin_complete(void *data, struct urb *urb, int status)
 {
         struct mon_reader_bin *rp = data;
-        mon_bin_event(rp, urb, 'C');
+        mon_bin_event(rp, urb, 'C', status);
 }
 
 static void mon_bin_error(void *data, struct urb *urb, int error)
@@ -500,10 +504,10 @@ static void mon_bin_error(void *data, struct urb *urb, int error)
 
         memset(ep, 0, PKT_SIZE);
         ep->type = 'E';
-        ep->xfer_type = usb_pipetype(urb->pipe);
-        /* We use the fact that usb_pipein() returns 0x80 */
-        ep->epnum = usb_pipeendpoint(urb->pipe) | usb_pipein(urb->pipe);
-        ep->devnum = usb_pipedevice(urb->pipe);
+        ep->xfer_type = xfer_to_pipe[usb_endpoint_type(&urb->ep->desc)];
+        ep->epnum = usb_urb_dir_in(urb) ? USB_DIR_IN : 0;
+        ep->epnum |= usb_endpoint_num(&urb->ep->desc);
+        ep->devnum = urb->dev->devnum;
         ep->busnum = urb->dev->bus->busnum;
         ep->id = (unsigned long) urb;
         ep->status = error;
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index ce61d8b0fd..b371ffd39d 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -129,7 +129,8 @@ static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
 
 /*
  */
-static void mon_bus_complete(struct mon_bus *mbus, struct urb *urb)
+static void mon_bus_complete(struct mon_bus *mbus, struct urb *urb,
+                int status)
 {
         unsigned long flags;
         struct list_head *pos;
@@ -139,28 +140,18 @@ static void mon_bus_complete(struct mon_bus *mbus, struct urb *urb)
         mbus->cnt_events++;
         list_for_each (pos, &mbus->r_list) {
                 r = list_entry(pos, struct mon_reader, r_link);
-                r->rnf_complete(r->r_data, urb);
+                r->rnf_complete(r->r_data, urb, status);
         }
         spin_unlock_irqrestore(&mbus->lock, flags);
 }
 
-static void mon_complete(struct usb_bus *ubus, struct urb *urb)
+static void mon_complete(struct usb_bus *ubus, struct urb *urb, int status)
 {
         struct mon_bus *mbus;
 
-        mbus = ubus->mon_bus;
-        if (mbus == NULL) {
-                /*
-                 * This should not happen.
-                 * At this point we do not even know the bus number...
-                 */
-                printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
-                    urb->pipe);
-                return;
-        }
-
-        mon_bus_complete(mbus, urb);
-        mon_bus_complete(&mon_bus0, urb);
+        if ((mbus = ubus->mon_bus) != NULL)
+                mon_bus_complete(mbus, urb, status);
+        mon_bus_complete(&mon_bus0, urb, status);
 }
 
 /* int (*unlink_urb) (struct urb *urb, int status); */
@@ -170,7 +161,7 @@ static void mon_complete(struct usb_bus *ubus, struct urb *urb)
  */
 static void mon_stop(struct mon_bus *mbus)
 {
-        struct usb_bus *ubus = mbus->u_bus;
+        struct usb_bus *ubus;
         struct list_head *p;
 
         if (mbus == &mon_bus0) {
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 8f27a9e1c3..ebb04ac485 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -50,10 +50,13 @@ struct mon_iso_desc {
 struct mon_event_text {
         struct list_head e_link;
         int type;               /* submit, complete, etc. */
-        unsigned int pipe;      /* Pipe */
         unsigned long id;       /* From pointer, most of the time */
         unsigned int tstamp;
         int busnum;
+        char devnum;
+        char epnum;
+        char is_in;
+        char xfertype;
         int length;             /* Depends on type: xfer length or act length */
         int status;
         int interval;
@@ -121,13 +124,9 @@ static inline char mon_text_get_setup(struct mon_event_text *ep,
     struct urb *urb, char ev_type, struct mon_bus *mbus)
 {
 
-        if (!usb_pipecontrol(urb->pipe) || ev_type != 'S')
+        if (ep->xfertype != USB_ENDPOINT_XFER_CONTROL || ev_type != 'S')
                 return '-';
 
-        if (urb->dev->bus->uses_dma &&
-            (urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) {
-                return mon_dmapeek(ep->setup, urb->setup_dma, SETUP_MAX);
-        }
         if (urb->setup_packet == NULL)
                 return 'Z';     /* '0' would be not as pretty. */
 
@@ -138,14 +137,12 @@ static inline char mon_text_get_setup(struct mon_event_text *ep,
 static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
     int len, char ev_type, struct mon_bus *mbus)
 {
-        int pipe = urb->pipe;
-
         if (len <= 0)
                 return 'L';
         if (len >= DATA_MAX)
                 len = DATA_MAX;
 
-        if (usb_pipein(pipe)) {
+        if (ep->is_in) {
                 if (ev_type != 'C')
                         return '<';
         } else {
@@ -186,7 +183,7 @@ static inline unsigned int mon_get_timestamp(void)
 }
 
 static void mon_text_event(struct mon_reader_text *rp, struct urb *urb,
-    char ev_type)
+    char ev_type, int status)
 {
         struct mon_event_text *ep;
         unsigned int stamp;
@@ -203,24 +200,28 @@ static void mon_text_event(struct mon_reader_text *rp, struct urb *urb,
         }
 
         ep->type = ev_type;
-        ep->pipe = urb->pipe;
         ep->id = (unsigned long) urb;
         ep->busnum = urb->dev->bus->busnum;
+        ep->devnum = urb->dev->devnum;
+        ep->epnum = usb_endpoint_num(&urb->ep->desc);
+        ep->xfertype = usb_endpoint_type(&urb->ep->desc);
+        ep->is_in = usb_urb_dir_in(urb);
         ep->tstamp = stamp;
         ep->length = (ev_type == 'S') ?
             urb->transfer_buffer_length : urb->actual_length;
         /* Collecting status makes debugging sense for submits, too */
-        ep->status = urb->status;
+        ep->status = status;
 
-        if (usb_pipeint(urb->pipe)) {
+        if (ep->xfertype == USB_ENDPOINT_XFER_INT) {
                 ep->interval = urb->interval;
-        } else if (usb_pipeisoc(urb->pipe)) {
+        } else if (ep->xfertype == USB_ENDPOINT_XFER_ISOC) {
                 ep->interval = urb->interval;
                 ep->start_frame = urb->start_frame;
                 ep->error_count = urb->error_count;
         }
         ep->numdesc = urb->number_of_packets;
-        if (usb_pipeisoc(urb->pipe) && urb->number_of_packets > 0) {
+        if (ep->xfertype == USB_ENDPOINT_XFER_ISOC &&
+                        urb->number_of_packets > 0) {
                 if ((ndesc = urb->number_of_packets) > ISODESC_MAX)
                         ndesc = ISODESC_MAX;
                 fp = urb->iso_frame_desc;
@@ -247,13 +248,13 @@ static void mon_text_event(struct mon_reader_text *rp, struct urb *urb,
 static void mon_text_submit(void *data, struct urb *urb)
 {
         struct mon_reader_text *rp = data;
-        mon_text_event(rp, urb, 'S');
+        mon_text_event(rp, urb, 'S', -EINPROGRESS);
 }
 
-static void mon_text_complete(void *data, struct urb *urb)
+static void mon_text_complete(void *data, struct urb *urb, int status)
 {
         struct mon_reader_text *rp = data;
-        mon_text_event(rp, urb, 'C');
+        mon_text_event(rp, urb, 'C', status);
 }
 
 static void mon_text_error(void *data, struct urb *urb, int error)
@@ -268,9 +269,12 @@ static void mon_text_error(void *data, struct urb *urb, int error)
         }
 
         ep->type = 'E';
-        ep->pipe = urb->pipe;
         ep->id = (unsigned long) urb;
         ep->busnum = 0;
+        ep->devnum = urb->dev->devnum;
+        ep->epnum = usb_endpoint_num(&urb->ep->desc);
+        ep->xfertype = usb_endpoint_type(&urb->ep->desc);
+        ep->is_in = usb_urb_dir_in(urb);
         ep->tstamp = 0;
         ep->length = 0;
         ep->status = error;
@@ -413,10 +417,10 @@ static ssize_t mon_text_read_u(struct file *file, char __user *buf,
         mon_text_read_head_u(rp, &ptr, ep);
         if (ep->type == 'E') {
                 mon_text_read_statset(rp, &ptr, ep);
-        } else if (usb_pipeisoc(ep->pipe)) {
+        } else if (ep->xfertype == USB_ENDPOINT_XFER_ISOC) {
                 mon_text_read_isostat(rp, &ptr, ep);
                 mon_text_read_isodesc(rp, &ptr, ep);
-        } else if (usb_pipeint(ep->pipe)) {
+        } else if (ep->xfertype == USB_ENDPOINT_XFER_INT) {
                 mon_text_read_intstat(rp, &ptr, ep);
         } else {
                 mon_text_read_statset(rp, &ptr, ep);
@@ -468,18 +472,17 @@ static void mon_text_read_head_t(struct mon_reader_text *rp,
 {
         char udir, utype;
 
-        udir = usb_pipein(ep->pipe) ? 'i' : 'o';
-        switch (usb_pipetype(ep->pipe)) {
-        case PIPE_ISOCHRONOUS:  utype = 'Z'; break;
-        case PIPE_INTERRUPT:    utype = 'I'; break;
-        case PIPE_CONTROL:      utype = 'C'; break;
+        udir = (ep->is_in ? 'i' : 'o');
+        switch (ep->xfertype) {
+        case USB_ENDPOINT_XFER_ISOC:    utype = 'Z'; break;
+        case USB_ENDPOINT_XFER_INT:     utype = 'I'; break;
+        case USB_ENDPOINT_XFER_CONTROL: utype = 'C'; break;
         default: /* PIPE_BULK */  utype = 'B';
         }
         p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt,
             "%lx %u %c %c%c:%03u:%02u",
             ep->id, ep->tstamp, ep->type,
-            utype, udir,
-            usb_pipedevice(ep->pipe), usb_pipeendpoint(ep->pipe));
+            utype, udir, ep->devnum, ep->epnum);
 }
 
 static void mon_text_read_head_u(struct mon_reader_text *rp,
@@ -487,18 +490,17 @@ static void mon_text_read_head_u(struct mon_reader_text *rp,
 {
         char udir, utype;
 
-        udir = usb_pipein(ep->pipe) ? 'i' : 'o';
-        switch (usb_pipetype(ep->pipe)) {
-        case PIPE_ISOCHRONOUS:  utype = 'Z'; break;
-        case PIPE_INTERRUPT:    utype = 'I'; break;
-        case PIPE_CONTROL:      utype = 'C'; break;
+        udir = (ep->is_in ? 'i' : 'o');
+        switch (ep->xfertype) {
+        case USB_ENDPOINT_XFER_ISOC:    utype = 'Z'; break;
+        case USB_ENDPOINT_XFER_INT:     utype = 'I'; break;
+        case USB_ENDPOINT_XFER_CONTROL: utype = 'C'; break;
         default: /* PIPE_BULK */  utype = 'B';
         }
         p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt,
             "%lx %u %c %c%c:%d:%03u:%u",
             ep->id, ep->tstamp, ep->type,
-            utype, udir,
-            ep->busnum, usb_pipedevice(ep->pipe), usb_pipeendpoint(ep->pipe));
+            utype, udir, ep->busnum, ep->devnum, ep->epnum);
 }
 
 static void mon_text_read_statset(struct mon_reader_text *rp,
diff --git a/drivers/usb/mon/usb_mon.h b/drivers/usb/mon/usb_mon.h
index f68ad6d99a..f5d84ff8c1 100644
--- a/drivers/usb/mon/usb_mon.h
+++ b/drivers/usb/mon/usb_mon.h
@@ -46,7 +46,7 @@ struct mon_reader {
 
         void (*rnf_submit)(void *data, struct urb *urb);
         void (*rnf_error)(void *data, struct urb *urb, int error);
-        void (*rnf_complete)(void *data, struct urb *urb);
+        void (*rnf_complete)(void *data, struct urb *urb, int status);
 };
 
 void mon_reader_add(struct mon_bus *mbus, struct mon_reader *r);
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 43d6db696f..99fefed779 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -92,6 +92,16 @@ config USB_SERIAL_BELKIN
           To compile this driver as a module, choose M here: the
           module will be called belkin_sa.
 
+config USB_SERIAL_CH341
+        tristate "USB Winchiphead CH341 Single Port Serial Driver"
+        depends on USB_SERIAL
+        help
+          Say Y here if you want to use a Winchiphead CH341 single port
+          USB to serial adapter.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ch341.
+
 config USB_SERIAL_WHITEHEAT
         tristate "USB ConnectTech WhiteHEAT Serial Driver"
         depends on USB_SERIAL
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 07a976eca6..d6fb384e52 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_USB_SERIAL_AIRCABLE)		+= aircable.o
 obj-$(CONFIG_USB_SERIAL_AIRPRIME)               += airprime.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_CYBERJACK)              += cyberjack.o
 obj-$(CONFIG_USB_SERIAL_CYPRESS_M8)             += cypress_m8.o
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index c9fd486c1c..2a8e537cb0 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -172,11 +172,6 @@ static void ark3116_set_termios(struct usb_serial_port *port,
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
-        if (!port->tty || !port->tty->termios) {
-                dbg("%s - no tty structures", __FUNCTION__);
-                return;
-        }
-
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->termios_initialized) {
                 *(port->tty->termios) = tty_std_termios;
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index a47a24f882..0b14aea8eb 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -36,6 +36,16 @@ static int usb_serial_device_match (struct device *dev, struct device_driver *dr
         return 0;
 }
 
+static ssize_t show_port_number(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+
+        return sprintf(buf, "%d\n", port->number - port->serial->minor);
+}
+
+static DEVICE_ATTR(port_number, S_IRUGO, show_port_number, NULL);
+
 static int usb_serial_device_probe (struct device *dev)
 {
         struct usb_serial_driver *driver;
@@ -62,6 +72,10 @@ static int usb_serial_device_probe (struct device *dev)
                         goto exit;
         }
 
+        retval = device_create_file(dev, &dev_attr_port_number);
+        if (retval)
+                goto exit;
+
         minor = port->number;
         tty_register_device (usb_serial_tty_driver, minor, dev);
         dev_info(&port->serial->dev->dev, 
@@ -84,6 +98,8 @@ static int usb_serial_device_remove (struct device *dev)
                 return -ENODEV;
         }
 
+        device_remove_file(&port->dev, &dev_attr_port_number);
+
         driver = port->serial->type;
         if (driver->port_remove) {
                 if (!try_module_get(driver->driver.owner)) {
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
new file mode 100644
index 0000000000..6b252ceb39
--- /dev/null
+++ b/drivers/usb/serial/ch341.c
@@ -0,0 +1,354 @@
+/*
+ * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
+ *
+ * ch341.c implements a serial port driver for the Winchiphead CH341.
+ *
+ * The CH341 device can be used to implement an RS232 asynchronous
+ * serial port, an IEEE-1284 parallel printer port or a memory-like
+ * interface. In all cases the CH341 supports an I2C interface as well.
+ * This driver only supports the asynchronous serial interface.
+ *
+ * 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/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+#include <linux/serial.h>
+
+#define DEFAULT_BAUD_RATE 2400
+#define DEFAULT_TIMEOUT   1000
+
+static int debug;
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x4348, 0x5523) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+struct ch341_private {
+        unsigned baud_rate;
+        u8 dtr;
+        u8 rts;
+};
+
+static int ch341_control_out(struct usb_device *dev, u8 request,
+                             u16 value, u16 index)
+{
+        int r;
+        dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT|0x40,
+                (int)request, (int)value, (int)index);
+
+        r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
+                            USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
+                            value, index, NULL, 0, DEFAULT_TIMEOUT);
+
+        return r;
+}
+
+static int ch341_control_in(struct usb_device *dev,
+                            u8 request, u16 value, u16 index,
+                            char *buf, unsigned bufsize)
+{
+        int r;
+        dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN|0x40,
+                (int)request, (int)value, (int)index, buf, (int)bufsize);
+
+        r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
+                            USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                            value, index, buf, bufsize, DEFAULT_TIMEOUT);
+        return r;
+}
+
+static int ch341_set_baudrate(struct usb_device *dev,
+                              struct ch341_private *priv)
+{
+        short a, b;
+        int r;
+
+        dbg("ch341_set_baudrate(%d)", priv->baud_rate);
+        switch (priv->baud_rate) {
+        case 2400:
+                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;
+        }
+
+        r = ch341_control_out(dev, 0x9a, 0x1312, a);
+        if (!r)
+                r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
+
+        return r;
+}
+
+static int ch341_set_handshake(struct usb_device *dev,
+                               struct ch341_private *priv)
+{
+        dbg("ch341_set_handshake(%d,%d)", priv->dtr, priv->rts);
+        return ch341_control_out(dev, 0xa4,
+                ~((priv->dtr?1<<5:0)|(priv->rts?1<<6:0)), 0);
+}
+
+static int ch341_get_status(struct usb_device *dev)
+{
+        char *buffer;
+        int r;
+        const unsigned size = 8;
+
+        dbg("ch341_get_status()");
+
+        buffer = kmalloc(size, GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
+
+        r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
+        if ( r < 0)
+                goto out;
+
+        /* Not having the datasheet for the CH341, we ignore the bytes returned
+         * from the device. Return error if the device did not respond in time.
+         */
+        r = 0;
+
+out:    kfree(buffer);
+        return r;
+}
+
+/* -------------------------------------------------------------------------- */
+
+static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
+{
+        char *buffer;
+        int r;
+        const unsigned size = 8;
+
+        dbg("ch341_configure()");
+
+        buffer = kmalloc(size, GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
+
+        /* expect two bytes 0x27 0x00 */
+        r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
+        if (r < 0)
+                goto out;
+
+        r = ch341_control_out(dev, 0xa1, 0, 0);
+        if (r < 0)
+                goto out;
+
+        r = ch341_set_baudrate(dev, priv);
+        if (r < 0)
+                goto out;
+
+        /* expect two bytes 0x56 0x00 */
+        r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
+        if (r < 0)
+                goto out;
+
+        r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
+        if (r < 0)
+                goto out;
+
+        /* expect 0xff 0xee */
+        r = ch341_get_status(dev);
+        if (r < 0)
+                goto out;
+
+        r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
+        if (r < 0)
+                goto out;
+
+        r = ch341_set_baudrate(dev, priv);
+        if (r < 0)
+                goto out;
+
+        r = ch341_set_handshake(dev, priv);
+        if (r < 0)
+                goto out;
+
+        /* expect 0x9f 0xee */
+        r = ch341_get_status(dev);
+
+out:    kfree(buffer);
+        return r;
+}
+
+/* allocate private data */
+static int ch341_attach(struct usb_serial *serial)
+{
+        struct ch341_private *priv;
+        int r;
+
+        dbg("ch341_attach()");
+
+        /* private data */
+        priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->baud_rate = DEFAULT_BAUD_RATE;
+        priv->dtr = 1;
+        priv->rts = 1;
+
+        r = ch341_configure(serial->dev, priv);
+        if (r < 0)
+                goto error;
+
+        usb_set_serial_port_data(serial->port[0], priv);
+        return 0;
+
+error:  kfree(priv);
+        return r;
+}
+
+/* open this device, set default parameters */
+static int ch341_open(struct usb_serial_port *port, struct file *filp)
+{
+        struct usb_serial *serial = port->serial;
+        struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
+        int r;
+
+        dbg("ch341_open()");
+
+        priv->baud_rate = DEFAULT_BAUD_RATE;
+        priv->dtr = 1;
+        priv->rts = 1;
+
+        r = ch341_configure(serial->dev, priv);
+        if (r)
+                goto out;
+
+        r = ch341_set_handshake(serial->dev, priv);
+        if (r)
+                goto out;
+
+        r = ch341_set_baudrate(serial->dev, priv);
+        if (r)
+                goto out;
+
+        r = usb_serial_generic_open(port, filp);
+
+out:    return r;
+}
+
+/* Old_termios contains the original termios settings and
+ * tty->termios contains the new setting to be used.
+ */
+static void ch341_set_termios(struct usb_serial_port *port,
+                              struct ktermios *old_termios)
+{
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        struct tty_struct *tty = port->tty;
+        unsigned baud_rate;
+
+        dbg("ch341_set_termios()");
+
+        if (!tty || !tty->termios)
+                return;
+
+        baud_rate = tty_get_baud_rate(tty);
+
+        switch (baud_rate) {
+        case 2400:
+        case 4800:
+        case 9600:
+        case 19200:
+        case 38400:
+        case 115200:
+                priv->baud_rate = baud_rate;
+                break;
+        default:
+                dbg("Rate %d not supported, using %d",
+                        baud_rate, DEFAULT_BAUD_RATE);
+                priv->baud_rate = DEFAULT_BAUD_RATE;
+        }
+
+        ch341_set_baudrate(port->serial->dev, priv);
+
+        /* Unimplemented:
+         * (cflag & CSIZE) : data bits [5, 8]
+         * (cflag & PARENB) : parity {NONE, EVEN, ODD}
+         * (cflag & CSTOPB) : stop bits [1, 2]
+         */
+}
+
+static struct usb_driver ch341_driver = {
+        .name           = "ch341",
+        .probe          = usb_serial_probe,
+        .disconnect     = usb_serial_disconnect,
+        .id_table       = id_table,
+        .no_dynamic_id  = 1,
+};
+
+static struct usb_serial_driver ch341_device = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "ch341-uart",
+        },
+        .id_table         = id_table,
+        .usb_driver       = &ch341_driver,
+        .num_interrupt_in = NUM_DONT_CARE,
+        .num_bulk_in      = 1,
+        .num_bulk_out     = 1,
+        .num_ports        = 1,
+        .open             = ch341_open,
+        .set_termios      = ch341_set_termios,
+        .attach           = ch341_attach,
+};
+
+static int __init ch341_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&ch341_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&ch341_driver);
+        if (retval)
+                usb_serial_deregister(&ch341_device);
+        return retval;
+}
+
+static void __exit ch341_exit(void)
+{
+        usb_deregister(&ch341_driver);
+        usb_serial_deregister(&ch341_device);
+}
+
+module_init(ch341_init);
+module_exit(ch341_exit);
+MODULE_LICENSE("GPL");
+
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
+
+/* EOF ch341.c */
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 33f6ee50b8..eb7df1835c 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -53,6 +53,7 @@ static void cp2101_shutdown(struct usb_serial*);
 static int debug;
 
 static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
         { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
         { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
         { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
@@ -521,7 +522,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
-        if ((!port->tty) || (!port->tty->termios)) {
+        if (!port->tty || !port->tty->termios) {
                 dbg("%s - no tty structures", __FUNCTION__);
                 return;
         }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2d045857b1..e4c248c98e 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1169,7 +1169,9 @@ static void remove_sysfs_attrs(struct usb_serial_port *port)
         /* XXX see create_sysfs_attrs */
         if (priv->chip_type != SIO) {
                 device_remove_file(&port->dev, &dev_attr_event_char);
-                if (priv->chip_type == FT232BM || priv->chip_type == FT2232C) {
+                if (priv->chip_type == FT232BM ||
+                    priv->chip_type == FT2232C ||
+                    priv->chip_type == FT232RL) {
                         device_remove_file(&port->dev, &dev_attr_latency_timer);
                 }
         }
@@ -2102,6 +2104,7 @@ static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
         case FT8U232AM:
         case FT232BM:
         case FT2232C:
+        case FT232RL:
                 /* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
                    format as the data returned from the in point */
                 if ((ret = usb_control_msg(port->serial->dev,
diff --git a/drivers/usb/serial/funsoft.c b/drivers/usb/serial/funsoft.c
index 4092f6dc9e..b5194dc7d3 100644
--- a/drivers/usb/serial/funsoft.c
+++ b/drivers/usb/serial/funsoft.c
@@ -24,26 +24,6 @@ static struct usb_device_id id_table [] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static int funsoft_ioctl(struct usb_serial_port *port, struct file *file,
-                         unsigned int cmd, unsigned long arg)
-{
-        struct ktermios t;
-
-        dbg("%s - port %d, cmd 0x%04x", __FUNCTION__, port->number, cmd);
-
-        if (cmd == TCSETSF) {
-                if (user_termios_to_kernel_termios(&t, (struct termios __user *)arg))
-                        return -EFAULT;
-
-                dbg("%s - iflag:%x oflag:%x cflag:%x lflag:%x", __FUNCTION__,
-                    t.c_iflag, t.c_oflag, t.c_cflag, t.c_lflag);
-
-                if (!(t.c_lflag & ICANON))
-                        return -EINVAL;
-        }
-        return -ENOIOCTLCMD;
-}
-
 static struct usb_driver funsoft_driver = {
         .name =         "funsoft",
         .probe =        usb_serial_probe,
@@ -63,7 +43,6 @@ static struct usb_serial_driver funsoft_device = {
         .num_bulk_in =          NUM_DONT_CARE,
         .num_bulk_out =         NUM_DONT_CARE,
         .num_ports =            1,
-        .ioctl =                funsoft_ioctl,
 };
 
 static int __init funsoft_init(void)
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 6a3a704b58..e836ad07fd 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -256,6 +256,7 @@ static struct usb_device_id ipaq_id_table [] = {
         { USB_DEVICE(0x04DD, 0x9121) }, /* SHARP WS004SH USB Modem */
         { USB_DEVICE(0x04DD, 0x9123) }, /* SHARP WS007SH USB Modem */
         { USB_DEVICE(0x04DD, 0x9151) }, /* SHARP S01SH USB Modem */
+        { USB_DEVICE(0x04DD, 0x91AC) }, /* SHARP WS011SH USB Modem */
         { USB_DEVICE(0x04E8, 0x5F00) }, /* Samsung NEXiO USB Sync */
         { USB_DEVICE(0x04E8, 0x5F01) }, /* Samsung NEXiO USB Sync */
         { USB_DEVICE(0x04E8, 0x5F02) }, /* Samsung NEXiO USB Sync */
@@ -646,11 +647,13 @@ static int ipaq_open(struct usb_serial_port *port, struct file *filp)
         kfree(port->bulk_out_buffer);
         port->bulk_in_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
         if (port->bulk_in_buffer == NULL) {
+                port->bulk_out_buffer = NULL; /* prevent double free */
                 goto enomem;
         }
         port->bulk_out_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
         if (port->bulk_out_buffer == NULL) {
                 kfree(port->bulk_in_buffer);
+                port->bulk_in_buffer = NULL;
                 goto enomem;
         }
         port->read_urb->transfer_buffer = port->bulk_in_buffer;
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 5a4127e62c..90e3216abd 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -728,24 +728,32 @@ static void klsi_105_set_termios (struct usb_serial_port *port,
 #endif
                 }
                 
-                switch(cflag & CBAUD) {
-                case B0: /* handled below */
+                switch(tty_get_baud_rate(port->tty)) {
+                case 0: /* handled below */
                         break;
-                case B1200: priv->cfg.baudrate = kl5kusb105a_sio_b1200;
+                case 1200:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b1200;
                         break;
-                case B2400: priv->cfg.baudrate = kl5kusb105a_sio_b2400;
+                case 2400:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b2400;
                         break;
-                case B4800: priv->cfg.baudrate = kl5kusb105a_sio_b4800;
+                case 4800:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b4800;
                         break;
-                case B9600: priv->cfg.baudrate = kl5kusb105a_sio_b9600;
+                case 9600:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b9600;
                         break;
-                case B19200: priv->cfg.baudrate = kl5kusb105a_sio_b19200;
+                case 19200:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b19200;
                         break;
-                case B38400: priv->cfg.baudrate = kl5kusb105a_sio_b38400;
+                case 38400:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b38400;
                         break;
-                case B57600: priv->cfg.baudrate = kl5kusb105a_sio_b57600;
+                case 57600:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b57600;
                         break;
-                case B115200: priv->cfg.baudrate = kl5kusb105a_sio_b115200;
+                case 115200:
+                        priv->cfg.baudrate = kl5kusb105a_sio_b115200;
                         break;
                 default:
                         err("KLSI USB->Serial converter:"
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index 02a86dbc0e..6f224195bd 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -82,6 +82,7 @@ static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
                            unsigned int set, unsigned int clear);
 static void kobil_read_int_callback( struct urb *urb );
 static void kobil_write_callback( struct urb *purb );
+static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old);
 
 
 static struct usb_device_id id_table [] = {
@@ -119,6 +120,7 @@ static struct usb_serial_driver kobil_device = {
         .attach =               kobil_startup,
         .shutdown =             kobil_shutdown,
         .ioctl =                kobil_ioctl,
+        .set_termios =          kobil_set_termios,
         .tiocmget =             kobil_tiocmget,
         .tiocmset =             kobil_tiocmset,
         .open =                 kobil_open,
@@ -137,7 +139,6 @@ struct kobil_private {
         int cur_pos; // index of the next char to send in buf
         __u16 device_type;
         int line_state;
-        struct ktermios internal_termios;
 };
 
 
@@ -216,7 +217,7 @@ static void kobil_shutdown (struct usb_serial *serial)
 
 static int kobil_open (struct usb_serial_port *port, struct file *filp)
 {
-        int i, result = 0;
+        int result = 0;
         struct kobil_private *priv;
         unsigned char *transfer_buffer;
         int transfer_buffer_length = 8;
@@ -242,16 +243,6 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
         port->tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
         port->tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
         
-        // set up internal termios structure 
-        priv->internal_termios.c_iflag = port->tty->termios->c_iflag;
-        priv->internal_termios.c_oflag = port->tty->termios->c_oflag;
-        priv->internal_termios.c_cflag = port->tty->termios->c_cflag;
-        priv->internal_termios.c_lflag = port->tty->termios->c_lflag;
-
-        for (i=0; i<NCCS; i++) {
-                priv->internal_termios.c_cc[i] = port->tty->termios->c_cc[i];
-        }
-        
         // allocate memory for transfer buffer
         transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (! transfer_buffer) {
@@ -607,102 +598,79 @@ static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
         return (result < 0) ? result : 0;
 }
 
-
-static int  kobil_ioctl(struct usb_serial_port *port, struct file *file,
-                        unsigned int cmd, unsigned long arg)
+static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old)
 {
         struct kobil_private * priv;
         int result;
         unsigned short urb_val = 0;
-        unsigned char *transfer_buffer;
-        int transfer_buffer_length = 8;
-        char *settings;
-        void __user *user_arg = (void __user *)arg;
+        int c_cflag = port->tty->termios->c_cflag;
+        speed_t speed;
+        void * settings;
 
         priv = usb_get_serial_port_data(port);
-        if ((priv->device_type == KOBIL_USBTWIN_PRODUCT_ID) || (priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)) {
+        if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
                 // This device doesn't support ioctl calls
-                return 0;
-        }
-
-        switch (cmd) {
-        case TCGETS:   // 0x5401
-                if (!access_ok(VERIFY_WRITE, user_arg, sizeof(struct ktermios))) {
-                        dbg("%s - port %d Error in access_ok", __FUNCTION__, port->number);
-                        return -EFAULT;
-                }
-                if (kernel_termios_to_user_termios((struct ktermios __user *)arg,
-                                                   &priv->internal_termios))
-                        return -EFAULT;
-                return 0;
-
-        case TCSETS:   // 0x5402
-                if (!(port->tty->termios)) {
-                        dbg("%s - port %d Error: port->tty->termios is NULL", __FUNCTION__, port->number);
-                        return -ENOTTY;
-                }
-                if (!access_ok(VERIFY_READ, user_arg, sizeof(struct ktermios))) {
-                        dbg("%s - port %d Error in access_ok", __FUNCTION__, port->number);
-                        return -EFAULT;
-                }
-                if (user_termios_to_kernel_termios(&priv->internal_termios,
-                                                   (struct ktermios __user *)arg))
-                        return -EFAULT;
-                
-                settings = kzalloc(50, GFP_KERNEL);
-                if (! settings) {
-                        return -ENOBUFS;
-                }
+                return;
 
-                switch (priv->internal_termios.c_cflag & CBAUD) {
-                case B1200:
+        switch (speed = tty_get_baud_rate(port->tty)) {
+                case 1200:
                         urb_val = SUSBCR_SBR_1200;
-                        strcat(settings, "1200 ");
                         break;
-                case B9600:
+                case 9600:
                 default:
                         urb_val = SUSBCR_SBR_9600;
-                        strcat(settings, "9600 ");
                         break;
-                }
+        }
+        urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits : SUSBCR_SPASB_1StopBit;
+
+        settings = kzalloc(50, GFP_KERNEL);
+        if (! settings)
+                return;
 
-                urb_val |= (priv->internal_termios.c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits : SUSBCR_SPASB_1StopBit;
-                strcat(settings, (priv->internal_termios.c_cflag & CSTOPB) ? "2 StopBits " : "1 StopBit ");
+        sprintf(settings, "%d ", speed);
 
-                if (priv->internal_termios.c_cflag & PARENB) {
-                        if  (priv->internal_termios.c_cflag & PARODD) {
-                                urb_val |= SUSBCR_SPASB_OddParity;
-                                strcat(settings, "Odd Parity");
-                        } else {
-                                urb_val |= SUSBCR_SPASB_EvenParity;
-                                strcat(settings, "Even Parity");
-                        }
+        if (c_cflag & PARENB) {
+                if  (c_cflag & PARODD) {
+                        urb_val |= SUSBCR_SPASB_OddParity;
+                        strcat(settings, "Odd Parity");
                 } else {
-                        urb_val |= SUSBCR_SPASB_NoParity;
-                        strcat(settings, "No Parity");
+                        urb_val |= SUSBCR_SPASB_EvenParity;
+                        strcat(settings, "Even Parity");
                 }
-                dbg("%s - port %d setting port to: %s", __FUNCTION__, port->number, settings );
+        } else {
+                urb_val |= SUSBCR_SPASB_NoParity;
+                strcat(settings, "No Parity");
+        }
 
-                result = usb_control_msg( port->serial->dev, 
-                                          usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                          SUSBCRequest_SetBaudRateParityAndStopBits,
-                                          USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                          urb_val,
-                                          0,
-                                          settings,
-                                          0,
-                                          KOBIL_TIMEOUT
-                        );
+        result = usb_control_msg( port->serial->dev,
+                                  usb_rcvctrlpipe(port->serial->dev, 0 ),
+                                  SUSBCRequest_SetBaudRateParityAndStopBits,
+                                  USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                                  urb_val,
+                                  0,
+                                  settings,
+                                  0,
+                                  KOBIL_TIMEOUT
+                );
+        kfree(settings);
+}
 
-                dbg("%s - port %d Send set_baudrate URB returns: %i", __FUNCTION__, port->number, result);
-                kfree(settings);
+static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
+{
+        struct kobil_private * priv = usb_get_serial_port_data(port);
+        unsigned char *transfer_buffer;
+        int transfer_buffer_length = 8;
+        int result;
+
+        if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
+                // This device doesn't support ioctl calls
                 return 0;
 
+        switch (cmd) {
         case TCFLSH:   // 0x540B
                 transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
-                if (! transfer_buffer) {
+                if (! transfer_buffer)
                         return -ENOBUFS;
-                }
 
                 result = usb_control_msg( port->serial->dev, 
                                           usb_rcvctrlpipe(port->serial->dev, 0 ), 
@@ -716,15 +684,13 @@ static int  kobil_ioctl(struct usb_serial_port *port, struct file *file,
                         );
                 
                 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __FUNCTION__, port->number, result);
-
                 kfree(transfer_buffer);
-                return ((result < 0) ? -EFAULT : 0);
-
+                return (result < 0) ? -EFAULT : 0;
+        default:
+                return -ENOIOCTLCMD;
         }
-        return -ENOIOCTLCMD;
 }
 
-
 static int __init kobil_init (void)
 {
         int retval;
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index e08c9bb403..0dc99f75bb 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -206,20 +206,20 @@ static int mct_u232_calculate_baud_rate(struct usb_serial *serial, speed_t value
                 }
         } else {
                 switch (value) {
-                        case 300: break;
-                        case 600: break;
-                        case 1200: break;
-                        case 2400: break;
-                        case 4800: break;
-                        case 9600: break;
-                        case 19200: break;
-                        case 38400: break;
-                        case 57600: break;
-                        case 115200: break;
-                        default:
-                                err("MCT USB-RS232: unsupported baudrate request 0x%x,"
-                                    " using default of B9600", value);
-                                value = 9600;
+                case 300: break;
+                case 600: break;
+                case 1200: break;
+                case 2400: break;
+                case 4800: break;
+                case 9600: break;
+                case 19200: break;
+                case 38400: break;
+                case 57600: break;
+                case 115200: break;
+                default:
+                        err("MCT USB-RS232: unsupported baudrate request 0x%x,"
+                            " using default of B9600", value);
+                        value = 9600;
                 }
                 return 115200/value;
         }
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index 64f3f66a7a..d19861166b 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -1144,7 +1144,7 @@ static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
         if (size == 0)
                 return NULL;
 
-        pb = (struct pl2303_buf *)kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
+        pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
         if (pb == NULL)
                 return NULL;
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index f9f85f56f0..1da57fd9ea 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -73,6 +73,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
+        { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
         { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index f9a71d0c10..c39bace5cb 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -59,6 +59,7 @@
 #define SIEMENS_PRODUCT_ID_SX1  0x0001
 #define SIEMENS_PRODUCT_ID_X65  0x0003
 #define SIEMENS_PRODUCT_ID_X75  0x0004
+#define SIEMENS_PRODUCT_ID_EF81 0x0005
 
 #define SYNTECH_VENDOR_ID       0x0745
 #define SYNTECH_PRODUCT_ID      0x0001
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 51669b7622..4e6dcc199b 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -90,18 +90,12 @@ MODULE_AUTHOR (DRIVER_AUTHOR);
 MODULE_DESCRIPTION (DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-#if defined(CONFIG_USBD_SAFE_SERIAL_VENDOR) && !defined(CONFIG_USBD_SAFE_SERIAL_PRODUCT)
-#error "SAFE_SERIAL_VENDOR defined without SAFE_SERIAL_PRODUCT"
-#endif
-
-#if ! defined(CONFIG_USBD_SAFE_SERIAL_VENDOR)
 static __u16 vendor;            // no default
 static __u16 product;           // no default
 module_param(vendor, ushort, 0);
 MODULE_PARM_DESC(vendor, "User specified USB idVendor (required)");
 module_param(product, ushort, 0);
 MODULE_PARM_DESC(product, "User specified USB idProduct (required)");
-#endif
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled or not");
@@ -145,11 +139,6 @@ static struct usb_device_id id_table[] = {
         {MY_USB_DEVICE (0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Collie 
         {MY_USB_DEVICE (0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Collie 
         {MY_USB_DEVICE (0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Sharp tmp
-#if defined(CONFIG_USB_SAFE_SERIAL_VENDOR)
-        {MY_USB_DEVICE
-         (CONFIG_USB_SAFE_SERIAL_VENDOR, CONFIG_USB_SAFE_SERIAL_PRODUCT, CDC_DEVICE_CLASS,
-          LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},
-#endif
         // extra null entry for module 
         // vendor/produc parameters
         {MY_USB_DEVICE (0, 0, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 9bf01a5efc..4b1bd7def4 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -578,6 +578,17 @@ static void kill_traffic(struct usb_serial_port *port)
 {
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->write_urb);
+        /*
+         * This is tricky.
+         * Some drivers submit the read_urb in the
+         * handler for the write_urb or vice versa
+         * this order determines the order in which
+         * usb_kill_urb() must be used to reliably
+         * kill the URBs. As it is unknown here,
+         * both orders must be used in turn.
+         * The call below is not redundant.
+         */
+        usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
         usb_kill_urb(port->interrupt_out_urb);
 }
@@ -651,16 +662,14 @@ exit:
 
 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
 {
-        struct list_head *p;
         const struct usb_device_id *id;
-        struct usb_serial_driver *t;
+        struct usb_serial_driver *drv;
 
         /* Check if the usb id matches a known device */
-        list_for_each(p, &usb_serial_driver_list) {
-                t = list_entry(p, struct usb_serial_driver, driver_list);
-                id = get_iface_id(t, iface);
+        list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
+                id = get_iface_id(drv, iface);
                 if (id)
-                        return t;
+                        return drv;
         }
 
         return NULL;
@@ -800,9 +809,6 @@ int usb_serial_probe(struct usb_interface *interface,
         /* END HORRIBLE HACK FOR PL2303 */
 #endif
 
-        /* found all that we need */
-        dev_info(&interface->dev, "%s converter detected\n", type->description);
-
 #ifdef CONFIG_USB_SERIAL_GENERIC
         if (type == &usb_serial_generic_device) {
                 num_ports = num_bulk_out;
@@ -836,6 +842,24 @@ int usb_serial_probe(struct usb_interface *interface,
         serial->num_interrupt_in = num_interrupt_in;
         serial->num_interrupt_out = num_interrupt_out;
 
+        /* check that the device meets the driver's requirements */
+        if ((type->num_interrupt_in != NUM_DONT_CARE &&
+                                type->num_interrupt_in != num_interrupt_in)
+                        || (type->num_interrupt_out != NUM_DONT_CARE &&
+                                type->num_interrupt_out != num_interrupt_out)
+                        || (type->num_bulk_in != NUM_DONT_CARE &&
+                                type->num_bulk_in != num_bulk_in)
+                        || (type->num_bulk_out != NUM_DONT_CARE &&
+                                type->num_bulk_out != num_bulk_out)) {
+                dbg("wrong number of endpoints");
+                kfree(serial);
+                return -EIO;
+        }
+
+        /* found all that we need */
+        dev_info(&interface->dev, "%s converter detected\n",
+                        type->description);
+
         /* create our ports, we need as many as the max endpoints */
         /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
         max_endpoints = max(num_bulk_in, num_bulk_out);
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 30e08c0bcd..7ee087fed9 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -46,7 +46,6 @@ static int  visor_probe		(struct usb_serial *serial, const struct usb_device_id
 static int  visor_calc_num_ports(struct usb_serial *serial);
 static void visor_shutdown      (struct usb_serial *serial);
 static int  visor_ioctl         (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
-static void visor_set_termios   (struct usb_serial_port *port, struct ktermios *old_termios);
 static void visor_write_bulk_callback   (struct urb *urb);
 static void visor_read_bulk_callback    (struct urb *urb);
 static void visor_read_int_callback     (struct urb *urb);
@@ -203,7 +202,6 @@ static struct usb_serial_driver handspring_device = {
         .calc_num_ports =       visor_calc_num_ports,
         .shutdown =             visor_shutdown,
         .ioctl =                visor_ioctl,
-        .set_termios =          visor_set_termios,
         .write =                visor_write,
         .write_room =           visor_write_room,
         .chars_in_buffer =      visor_chars_in_buffer,
@@ -234,7 +232,6 @@ static struct usb_serial_driver clie_5_device = {
         .calc_num_ports =       visor_calc_num_ports,
         .shutdown =             visor_shutdown,
         .ioctl =                visor_ioctl,
-        .set_termios =          visor_set_termios,
         .write =                visor_write,
         .write_room =           visor_write_room,
         .chars_in_buffer =      visor_chars_in_buffer,
@@ -262,7 +259,6 @@ static struct usb_serial_driver clie_3_5_device = {
         .unthrottle =           visor_unthrottle,
         .attach =               clie_3_5_startup,
         .ioctl =                visor_ioctl,
-        .set_termios =          visor_set_termios,
         .write =                visor_write,
         .write_room =           visor_write_room,
         .chars_in_buffer =      visor_chars_in_buffer,
@@ -936,66 +932,6 @@ static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsign
         return -ENOIOCTLCMD;
 }
 
-
-/* This function is all nice and good, but we don't change anything based on it :) */
-static void visor_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
-{
-        unsigned int cflag;
-
-        dbg("%s - port %d", __FUNCTION__, port->number);
-
-        if ((!port->tty) || (!port->tty->termios)) {
-                dbg("%s - no tty structures", __FUNCTION__);
-                return;
-        }
-
-        cflag = port->tty->termios->c_cflag;
-
-        /* get the byte size */
-        switch (cflag & CSIZE) {
-                case CS5:       dbg("%s - data bits = 5", __FUNCTION__);   break;
-                case CS6:       dbg("%s - data bits = 6", __FUNCTION__);   break;
-                case CS7:       dbg("%s - data bits = 7", __FUNCTION__);   break;
-                default:
-                case CS8:       dbg("%s - data bits = 8", __FUNCTION__);   break;
-        }
-        
-        /* determine the parity */
-        if (cflag & PARENB)
-                if (cflag & PARODD)
-                        dbg("%s - parity = odd", __FUNCTION__);
-                else
-                        dbg("%s - parity = even", __FUNCTION__);
-        else
-                dbg("%s - parity = none", __FUNCTION__);
-
-        /* figure out the stop bits requested */
-        if (cflag & CSTOPB)
-                dbg("%s - stop bits = 2", __FUNCTION__);
-        else
-                dbg("%s - stop bits = 1", __FUNCTION__);
-
-        
-        /* figure out the flow control settings */
-        if (cflag & CRTSCTS)
-                dbg("%s - RTS/CTS is enabled", __FUNCTION__);
-        else
-                dbg("%s - RTS/CTS is disabled", __FUNCTION__);
-        
-        /* determine software flow control */
-        if (I_IXOFF(port->tty))
-                dbg("%s - XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                    __FUNCTION__, START_CHAR(port->tty), STOP_CHAR(port->tty));
-        else
-                dbg("%s - XON/XOFF is disabled", __FUNCTION__);
-
-        /* get the baud rate wanted */
-        dbg("%s - baud rate = %d", __FUNCTION__, tty_get_baud_rate(port->tty));
-
-        return;
-}
-
-
 static int __init visor_init (void)
 {
         int i, retval;
diff --git a/drivers/usb/storage/initializers.c b/drivers/usb/storage/initializers.c
index 3a41740cad..ee5b42aa53 100644
--- a/drivers/usb/storage/initializers.c
+++ b/drivers/usb/storage/initializers.c
@@ -90,3 +90,17 @@ int usb_stor_ucr61s2b_init(struct us_data *us)
 
         return (res ? -1 : 0);
 }
+
+/* This places the HUAWEI E220 devices in multi-port mode */
+int usb_stor_huawei_e220_init(struct us_data *us)
+{
+        int result;
+
+        us->iobuf[0] = 0x1;
+        result = usb_stor_control_msg(us, us->send_ctrl_pipe,
+                                      USB_REQ_SET_FEATURE,
+                                      USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                                      0x01, 0x0, us->iobuf, 0x1, 1000);
+        US_DEBUGP("usb_control_msg performing result is %d\n", result);
+        return (result ? 0 : -1);
+}
diff --git a/drivers/usb/storage/initializers.h b/drivers/usb/storage/initializers.h
index e2967a4d48..ad3ffd4236 100644
--- a/drivers/usb/storage/initializers.h
+++ b/drivers/usb/storage/initializers.h
@@ -47,3 +47,6 @@ int usb_stor_euscsi_init(struct us_data *us);
 /* This function is required to activate all four slots on the UCR-61S2B
  * flash reader */
 int usb_stor_ucr61s2b_init(struct us_data *us);
+
+/* This places the HUAWEI E220 devices in multi-port mode */
+int usb_stor_huawei_e220_init(struct us_data *us);
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index 5e27297c01..17ca4d7357 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -190,9 +190,6 @@ static int usbat_check_status(struct us_data *us)
         unsigned char *reply = us->iobuf;
         int rc;
 
-        if (!us)
-                return USB_STOR_TRANSPORT_ERROR;
-
         rc = usbat_get_status(us, reply);
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index c6b78ba815..9b656ec427 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -198,7 +198,7 @@ UNUSUAL_DEV(  0x0421, 0x044e, 0x0100, 0x0100,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Bardur Arantsson <bardur@scientician.net> */
-UNUSUAL_DEV(  0x0421, 0x047c, 0x0370, 0x0370,
+UNUSUAL_DEV(  0x0421, 0x047c, 0x0370, 0x0610,
                 "Nokia",
                 "6131",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
@@ -341,6 +341,13 @@ UNUSUAL_DEV(  0x04b0, 0x040d, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
+/* Reported by Graber and Mike Pagano <mpagano-kernel@mpagano.com> */
+UNUSUAL_DEV(  0x04b0, 0x040f, 0x0200, 0x0200,
+       "NIKON",
+       "NIKON DSC D200",
+       US_SC_DEVICE, US_PR_DEVICE, NULL,
+       US_FL_FIX_CAPACITY),
+
 /* Reported by Emil Larsson <emil@swip.net> */
 UNUSUAL_DEV(  0x04b0, 0x0411, 0x0100, 0x0101,
                 "NIKON",
@@ -355,6 +362,20 @@ UNUSUAL_DEV(  0x04b0, 0x0413, 0x0110, 0x0110,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
+/* Reported by Paul Check <paul@openstreet.com> */
+UNUSUAL_DEV(  0x04b0, 0x0415, 0x0100, 0x0100,
+                "NIKON",
+                "NIKON DSC D2Xs",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
+/* Reported by Shan Destromp (shansan@gmail.com) */
+UNUSUAL_DEV(  0x04b0, 0x0417, 0x0100, 0x0100,
+                "NIKON",
+                "NIKON DSC D40X",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
 /* BENQ DC5330
  * Reported by Manuel Fombuena <mfombuena@ya.com> and
  * Frank Copeland <fjc@thingy.apana.org.au> */
@@ -1463,6 +1484,17 @@ UNUSUAL_DEV(  0x1210, 0x0003, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
+/* Reported by fangxiaozhi <fangxiaozhi60675@huawei.com>
+ * and by linlei <linlei83@huawei.com>
+ * Patch reworked by Johann Wilhelm <johann.wilhelm@student.tugraz.at>
+ * This brings the HUAWEI E220 devices into multi-port mode
+ */
+UNUSUAL_DEV( 0x12d1, 0x1003, 0x0000, 0x0000,
+                "HUAWEI MOBILE",
+                "Mass Storage",
+                US_SC_DEVICE, US_PR_DEVICE, usb_stor_huawei_e220_init,
+                0),
+
 /* Reported by Vilius Bilinkevicius <vilisas AT xxx DOT lt) */
 UNUSUAL_DEV(  0x132b, 0x000b, 0x0001, 0x0001,
                 "Minolta",
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 5918166706..3451e8d03a 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -960,6 +960,10 @@ static int storage_probe(struct usb_interface *intf,
                 return -ENOMEM;
         }
 
+        /*
+         * Allow 16-byte CDBs and thus > 2TB
+         */
+        host->max_cmd_len = 16;
         us = host_to_us(host);
         memset(us, 0, sizeof(struct us_data));
         mutex_init(&(us->dev_mutex));
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index 8de11deb5d..c815a40e16 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -125,6 +125,7 @@ static int skel_open(struct inode *inode, struct file *file)
 
         /* save our object in the file's private structure */
         file->private_data = dev;
+        mutex_unlock(&dev->io_mutex);
 
 exit:
         return retval;
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index 0899fccbd5..fbea2bd129 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -125,8 +125,8 @@ static int hp680bl_remove(struct platform_device *pdev)
 {
         struct backlight_device *bd = platform_get_drvdata(pdev);
 
-        hp680bl_data.brightness = 0;
-        hp680bl_data.power = 0;
+        bd->props.brightness = 0;
+        bd->props.power = 0;
         hp680bl_send_intensity(bd);
 
         backlight_device_unregister(bd);
diff --git a/drivers/video/output.c b/drivers/video/output.c
index 1473f2c892..f2df5519c9 100644
--- a/drivers/video/output.c
+++ b/drivers/video/output.c
@@ -31,7 +31,8 @@ MODULE_DESCRIPTION("Display Output Switcher Lowlevel Control Abstraction");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Luming Yu <luming.yu@intel.com>");
 
-static ssize_t video_output_show_state(struct class_device *dev,char *buf)
+static ssize_t video_output_show_state(struct device *dev,
+                                       struct device_attribute *attr, char *buf)
 {
         ssize_t ret_size = 0;
         struct output_device *od = to_output_device(dev);
@@ -40,8 +41,9 @@ static ssize_t video_output_show_state(struct class_device *dev,char *buf)
         return ret_size;
 }
 
-static ssize_t video_output_store_state(struct class_device *dev,
-        const char *buf,size_t count)
+static ssize_t video_output_store_state(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf,size_t count)
 {
         char *endp;
         struct output_device *od = to_output_device(dev);
@@ -60,21 +62,22 @@ static ssize_t video_output_store_state(struct class_device *dev,
         return count;
 }
 
-static void video_output_class_release(struct class_device *dev)
+static void video_output_release(struct device *dev)
 {
         struct output_device *od = to_output_device(dev);
         kfree(od);
 }
 
-static struct class_device_attribute video_output_attributes[] = {
+static struct device_attribute video_output_attributes[] = {
         __ATTR(state, 0644, video_output_show_state, video_output_store_state),
         __ATTR_NULL,
 };
 
+
 static struct class video_output_class = {
         .name = "video_output",
-        .release = video_output_class_release,
-        .class_dev_attrs = video_output_attributes,
+        .dev_release = video_output_release,
+        .dev_attrs = video_output_attributes,
 };
 
 struct output_device *video_output_register(const char *name,
@@ -91,11 +94,11 @@ struct output_device *video_output_register(const char *name,
                 goto error_return;
         }
         new_dev->props = op;
-        new_dev->class_dev.class = &video_output_class;
-        new_dev->class_dev.dev = dev;
-        strlcpy(new_dev->class_dev.class_id,name,KOBJ_NAME_LEN);
-        class_set_devdata(&new_dev->class_dev,devdata);
-        ret_code = class_device_register(&new_dev->class_dev);
+        new_dev->dev.class = &video_output_class;
+        new_dev->dev.parent = dev;
+        strlcpy(new_dev->dev.bus_id,name, BUS_ID_SIZE);
+        dev_set_drvdata(&new_dev->dev, devdata);
+        ret_code = device_register(&new_dev->dev);
         if (ret_code) {
                 kfree(new_dev);
                 goto error_return;
@@ -111,7 +114,7 @@ void video_output_unregister(struct output_device *dev)
 {
         if (!dev)
                 return;
-        class_device_unregister(&dev->class_dev);
+        device_unregister(&dev->dev);
 }
 EXPORT_SYMBOL(video_output_unregister);
 
diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c
index 7d6c29800d..06805c9b23 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -667,6 +667,8 @@ static int pvr2_init_cable(void)
           related */
         if (cable_type == CT_COMPOSITE)
                 fb_writel(3 << 8, VOUTC);
+        else if (cable_type == CT_RGB)
+                fb_writel(1 << 9, VOUTC);
         else
                 fb_writel(0, VOUTC);
 
@@ -890,7 +892,7 @@ static int __init pvr2fb_dc_init(void)
         pvr2_fix.mmio_start     = 0xa05f8000;   /* registers start here */
         pvr2_fix.mmio_len       = 0x2000;
 
-        if (request_irq(HW_EVENT_VSYNC, pvr2fb_interrupt, 0,
+        if (request_irq(HW_EVENT_VSYNC, pvr2fb_interrupt, IRQF_SHARED,
                         "pvr2 VBL handler", fb_info)) {
                 return -EBUSY;
         }
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index a593f900ef..070217322c 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -197,7 +197,7 @@ static struct w1_family w1_default_family = {
         .fops = &w1_default_fops,
 };
 
-static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size);
+static int w1_uevent(struct device *dev, struct kobj_uevent_env *env);
 
 static struct bus_type w1_bus_type = {
         .name = "w1",
@@ -396,13 +396,12 @@ static void w1_destroy_master_attributes(struct w1_master *master)
 }
 
 #ifdef CONFIG_HOTPLUG
-static int w1_uevent(struct device *dev, char **envp, int num_envp,
-                        char *buffer, int buffer_size)
+static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct w1_master *md = NULL;
         struct w1_slave *sl = NULL;
         char *event_owner, *name;
-        int err, cur_index=0, cur_len=0;
+        int err;
 
         if (dev->driver == &w1_master_driver) {
                 md = container_of(dev, struct w1_master, dev);
@@ -423,23 +422,19 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp,
         if (dev->driver != &w1_slave_driver || !sl)
                 return 0;
 
-        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size,
-                        &cur_len, "W1_FID=%02X", sl->reg_num.family);
+        err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family);
         if (err)
                 return err;
 
-        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size,
-                        &cur_len, "W1_SLAVE_ID=%024LX",
-                        (unsigned long long)sl->reg_num.id);
-        envp[cur_index] = NULL;
+        err = add_uevent_var(env, "W1_SLAVE_ID=%024LX",
+                             (unsigned long long)sl->reg_num.id);
         if (err)
                 return err;
 
         return 0;
 };
 #else
-static int w1_uevent(struct device *dev, char **envp, int num_envp,
-                        char *buffer, int buffer_size)
+static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         return 0;
 }