51 files changed, 924 insertions, 1233 deletions
diff --git a/Documentation/infiniband/ipoib.txt b/Documentation/infiniband/ipoib.txt
index 864ff3283780..6d40f00b358c 100644
--- a/Documentation/infiniband/ipoib.txt
+++ b/Documentation/infiniband/ipoib.txt
@@ -24,6 +24,49 @@ Partitions and P_Keys
  The P_Key for any interface is given by the "pkey" file, and the
  main interface for a subinterface is in "parent."
+Datagram vs Connected modes
+  The IPoIB driver supports two modes of operation: datagram and
+  connected.  The mode is set and read through an interface's
+  /sys/class/net/<intf name>/mode file.
+  In datagram mode, the IB UD (Unreliable Datagram) transport is used
+  and so the interface MTU has is equal to the IB L2 MTU minus the
+  IPoIB encapsulation header (4 bytes).  For example, in a typical IB
+  fabric with a 2K MTU, the IPoIB MTU will be 2048 - 4 = 2044 bytes.
+  In connected mode, the IB RC (Reliable Connected) transport is used.
+  Connected mode is to takes advantage of the connected nature of the
+  IB transport and allows an MTU up to the maximal IP packet size of
+  64K, which reduces the number of IP packets needed for handling
+  large UDP datagrams, TCP segments, etc and increases the performance
+  for large messages.
+  In connected mode, the interface's UD QP is still used for multicast
+  and communication with peers that don't support connected mode. In
+  this case, RX emulation of ICMP PMTU packets is used to cause the
+  networking stack to use the smaller UD MTU for these neighbours.
+Stateless offloads
+  If the IB HW supports IPoIB stateless offloads, IPoIB advertises
+  TCP/IP checksum and/or Large Send (LSO) offloading capability to the
+  network stack.
+  Large Receive (LRO) offloading is also implemented and may be turned
+  on/off using ethtool calls.  Currently LRO is supported only for
+  checksum offload capable devices.
+  Stateless offloads are supported only in datagram mode.  
+Interrupt moderation
+  If the underlying IB device supports CQ event moderation, one can
+  use ethtool to set interrupt mitigation parameters and thus reduce
+  the overhead incurred by handling interrupts.  The main code path of
+  IPoIB doesn't use events for TX completion signaling so only RX
+  moderation is supported.
 Debugging Information
  By compiling the IPoIB driver with CONFIG_INFINIBAND_IPOIB_DEBUG set
@@ -55,3 +98,5 @@ References
    http://ietf.org/rfc/rfc4391.txt 
  IP over InfiniBand (IPoIB) Architecture (RFC 4392)
    http://ietf.org/rfc/rfc4392.txt 
+  IP over InfiniBand: Connected Mode (RFC 4755)
+    http://ietf.org/rfc/rfc4755.txt
diff --git a/arch/x86/include/asm/fixmap.h b/arch/x86/include/asm/fixmap.h
index 81937a5dc77c..2d81af3974a0 100644
--- a/arch/x86/include/asm/fixmap.h
+++ b/arch/x86/include/asm/fixmap.h
@@ -151,11 +151,11 @@ extern pte_t *pkmap_page_table;
 void __native_set_fixmap(enum fixed_addresses idx, pte_t pte);
 void native_set_fixmap(enum fixed_addresses idx,
-                       unsigned long phys, pgprot_t flags);
+                       phys_addr_t phys, pgprot_t flags);
 #ifndef CONFIG_PARAVIRT
 static inline void __set_fixmap(enum fixed_addresses idx,
-                                unsigned long phys, pgprot_t flags)
+                                phys_addr_t phys, pgprot_t flags)
 {
        native_set_fixmap(idx, phys, flags);
 }
diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h
index 7727aa8b7dda..378e3691c08c 100644
--- a/arch/x86/include/asm/paravirt.h
+++ b/arch/x86/include/asm/paravirt.h
@@ -347,7 +347,7 @@ struct pv_mmu_ops {
        /* Sometimes the physical address is a pfn, and sometimes its
           an mfn.  We can tell which is which from the index. */
        void (*set_fixmap)(unsigned /* enum fixed_addresses */ idx,
-                           unsigned long phys, pgprot_t flags);
+                           phys_addr_t phys, pgprot_t flags);
 };
 struct raw_spinlock;
@@ -1432,7 +1432,7 @@ static inline void arch_leave_lazy_mmu_mode(void)
 void arch_flush_lazy_mmu_mode(void);
 static inline void __set_fixmap(unsigned /* enum fixed_addresses */ idx,
-                                unsigned long phys, pgprot_t flags)
+                                phys_addr_t phys, pgprot_t flags)
 {
        pv_mmu_ops.set_fixmap(idx, phys, flags);
 }
diff --git a/arch/x86/mm/pgtable.c b/arch/x86/mm/pgtable.c
index 5b7c7c8464fe..7aa03a5389f5 100644
--- a/arch/x86/mm/pgtable.c
+++ b/arch/x86/mm/pgtable.c
@@ -345,7 +345,8 @@ void __native_set_fixmap(enum fixed_addresses idx, pte_t pte)
        fixmaps_set++;
 }
-void native_set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t flags)
+void native_set_fixmap(enum fixed_addresses idx, phys_addr_t phys,
+                       pgprot_t flags)
 {
        __native_set_fixmap(idx, pfn_pte(phys >> PAGE_SHIFT, flags));
 }
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index db3802fb7b84..2a81838a9ab7 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -1750,7 +1750,7 @@ __init pgd_t *xen_setup_kernel_pagetable(pgd_t *pgd,
 }
 #endif  /* CONFIG_X86_64 */
-static void xen_set_fixmap(unsigned idx, unsigned long phys, pgprot_t prot)
+static void xen_set_fixmap(unsigned idx, phys_addr_t phys, pgprot_t prot)
 {
        pte_t pte;
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 6cccdc3f5220..4aecf5dc6a93 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -563,7 +563,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
        case ACE_FSM_STATE_IDENTIFY_PREPARE:
                /* Send identify command */
                ace->fsm_task = ACE_TASK_IDENTIFY;
-                ace->data_ptr = &ace->cf_id;
+                ace->data_ptr = ace->cf_id;
                ace->data_count = ACE_BUF_PER_SECTOR;
                ace_out(ace, ACE_SECCNTCMD, ACE_SECCNTCMD_IDENTIFY);
@@ -608,8 +608,8 @@ static void ace_fsm_dostate(struct ace_device *ace)
                break;
        case ACE_FSM_STATE_IDENTIFY_COMPLETE:
-                ace_fix_driveid(&ace->cf_id[0]);
+                ace_fix_driveid(ace->cf_id);
-                ace_dump_mem(&ace->cf_id, 512); /* Debug: Dump out disk ID */
+                ace_dump_mem(ace->cf_id, 512);  /* Debug: Dump out disk ID */
                if (ace->data_result) {
                        /* Error occured, disable the disk */
@@ -622,9 +622,9 @@ static void ace_fsm_dostate(struct ace_device *ace)
                        /* Record disk parameters */
                        set_capacity(ace->gd,
-                                ata_id_u32(&ace->cf_id, ATA_ID_LBA_CAPACITY));
+                                ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY));
                        dev_info(ace->dev, "capacity: %i sectors\n",
-                                ata_id_u32(&ace->cf_id, ATA_ID_LBA_CAPACITY));
+                                ata_id_u32(ace->cf_id, ATA_ID_LBA_CAPACITY));
                }
                /* We're done, drop to IDLE state and notify waiters */
@@ -923,7 +923,7 @@ static int ace_release(struct gendisk *disk, fmode_t mode)
 static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 {
        struct ace_device *ace = bdev->bd_disk->private_data;
-        u16 *cf_id = &ace->cf_id[0];
+        u16 *cf_id = ace->cf_id;
        dev_dbg(ace->dev, "ace_getgeo()\n");
diff --git a/drivers/ide/at91_ide.c b/drivers/ide/at91_ide.c
index 8eda552326e9..403d0e4265db 100644
--- a/drivers/ide/at91_ide.c
+++ b/drivers/ide/at91_ide.c
@@ -20,7 +20,6 @@
 *
 */
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/clk.h>
@@ -175,90 +174,6 @@ static void at91_ide_output_data(ide_drive_t *drive, struct ide_cmd *cmd,
        leave_16bit(chipselect, mode);
 }
-static u8 ide_mm_inb(unsigned long port)
-{
-        return readb((void __iomem *) port);
-}
-static void ide_mm_outb(u8 value, unsigned long port)
-{
-        writeb(value, (void __iomem *) port);
-}
-static void at91_ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                ide_mm_outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                ide_mm_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                ide_mm_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                ide_mm_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                ide_mm_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                ide_mm_outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
-                ide_mm_outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
-                ide_mm_outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
-                ide_mm_outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
-                ide_mm_outb(tf->lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                ide_mm_outb((tf->device & HIHI) | drive->select, io_ports->device_addr);
-}
-static void at91_ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
-        ide_mm_outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
-                tf->error  = ide_mm_inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = ide_mm_inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = ide_mm_inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = ide_mm_inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = ide_mm_inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = ide_mm_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                ide_mm_outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = ide_mm_inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = ide_mm_inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = ide_mm_inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = ide_mm_inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = ide_mm_inb(io_ports->lbah_addr);
-        }
-}
 static void at91_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
        struct ide_timing *timing;
@@ -284,8 +199,8 @@ static const struct ide_tp_ops at91_ide_tp_ops = {
        .write_devctl   = ide_write_devctl,
        .dev_select     = ide_dev_select,
-        .tf_load        = at91_ide_tf_load,
+        .tf_load        = ide_tf_load,
-        .tf_read        = at91_ide_tf_read,
+        .tf_read        = ide_tf_read,
        .input_data     = at91_ide_input_data,
        .output_data    = at91_ide_output_data,
@@ -300,7 +215,7 @@ static const struct ide_port_info at91_ide_port_info __initdata = {
        .tp_ops         = &at91_ide_tp_ops,
        .host_flags     = IDE_HFLAG_MMIO | IDE_HFLAG_NO_DMA | IDE_HFLAG_SINGLE |
                          IDE_HFLAG_NO_IO_32BIT | IDE_HFLAG_UNMASK_IRQS,
-        .pio_mask       = ATA_PIO5,
+        .pio_mask       = ATA_PIO6,
 };
 /*
diff --git a/drivers/ide/falconide.c b/drivers/ide/falconide.c
index afa2af9a362b..0e2df6755ec9 100644
--- a/drivers/ide/falconide.c
+++ b/drivers/ide/falconide.c
@@ -20,6 +20,7 @@
 #include <asm/atarihw.h>
 #include <asm/atariints.h>
 #include <asm/atari_stdma.h>
+#include <asm/ide.h>
 #define DRV_NAME "falconide"
@@ -67,8 +68,10 @@ static void falconide_input_data(ide_drive_t *drive, struct ide_cmd *cmd,
 {
        unsigned long data_addr = drive->hwif->io_ports.data_addr;
-        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS))
+        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS)) {
-                return insw(data_addr, buf, (len + 1) / 2);
+                __ide_mm_insw(data_addr, buf, (len + 1) / 2);
+                return;
+        }
        raw_insw_swapw((u16 *)data_addr, buf, (len + 1) / 2);
 }
@@ -78,8 +81,10 @@ static void falconide_output_data(ide_drive_t *drive, struct ide_cmd *cmd,
 {
        unsigned long data_addr = drive->hwif->io_ports.data_addr;
-        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS))
+        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS)) {
-                return outsw(data_addr, buf, (len + 1) / 2);
+                __ide_mm_outsw(data_addr, buf, (len + 1) / 2);
+                return;
+        }
        raw_outsw_swapw((u16 *)data_addr, buf, (len + 1) / 2);
 }
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index 12f436951bff..77f79d26b264 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -318,8 +318,9 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
                /* convert GTF to taskfile */
                memset(&cmd, 0, sizeof(cmd));
-                memcpy(&cmd.tf_array[7], gtf, REGS_PER_GTF);
+                memcpy(&cmd.tf.feature, gtf, REGS_PER_GTF);
-                cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+                cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+                cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
                err = ide_no_data_taskfile(drive, &cmd);
                if (err) {
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 3e43b889dd64..7201b176d75b 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -254,16 +254,13 @@ EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
 void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
 {
-        struct ide_cmd cmd;
+        struct ide_taskfile tf;
-        memset(&cmd, 0, sizeof(cmd));
+        drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT |
-        cmd.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
+                                     IDE_VALID_LBAM | IDE_VALID_LBAH);
-                       IDE_TFLAG_IN_NSECT;
-        drive->hwif->tp_ops->tf_read(drive, &cmd);
+        *bcount = (tf.lbah << 8) | tf.lbam;
+        *ireason = tf.nsect & 3;
-        *bcount = (cmd.tf.lbah << 8) | cmd.tf.lbam;
-        *ireason = cmd.tf.nsect & 3;
 }
 EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
@@ -439,12 +436,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
        return ide_started;
 }
-static void ide_init_packet_cmd(struct ide_cmd *cmd, u32 tf_flags,
+static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf,
                                u16 bcount, u8 dma)
 {
-        cmd->protocol  = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
+        cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
-        cmd->tf_flags |= IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
+        cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM |
-                         IDE_TFLAG_OUT_FEATURE | tf_flags;
+                            IDE_VALID_FEATURE | valid_tf;
        cmd->tf.command = ATA_CMD_PACKET;
        cmd->tf.feature = dma;          /* Use PIO/DMA */
        cmd->tf.lbam    = bcount & 0xff;
@@ -453,14 +450,11 @@ static void ide_init_packet_cmd(struct ide_cmd *cmd, u32 tf_flags,
 static u8 ide_read_ireason(ide_drive_t *drive)
 {
-        struct ide_cmd cmd;
+        struct ide_taskfile tf;
-        memset(&cmd, 0, sizeof(cmd));
-        cmd.tf_flags = IDE_TFLAG_IN_NSECT;
-        drive->hwif->tp_ops->tf_read(drive, &cmd);
+        drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT);
-        return cmd.tf.nsect & 3;
+        return tf.nsect & 3;
 }
 static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
@@ -588,12 +582,12 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
        ide_expiry_t *expiry = NULL;
        struct request *rq = hwif->rq;
        unsigned int timeout;
-        u32 tf_flags;
        u16 bcount;
+        u8 valid_tf;
        u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
        if (dev_is_idecd(drive)) {
-                tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
+                valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL;
                bcount = ide_cd_get_xferlen(rq);
                expiry = ide_cd_expiry;
                timeout = ATAPI_WAIT_PC;
@@ -607,7 +601,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
                pc->xferred = 0;
                pc->cur_pos = pc->buf;
-                tf_flags = IDE_TFLAG_OUT_DEVICE;
+                valid_tf = IDE_VALID_DEVICE;
                bcount = ((drive->media == ide_tape) ?
                                pc->req_xfer :
                                min(pc->req_xfer, 63 * 1024));
@@ -627,7 +621,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
                                                       : WAIT_TAPE_CMD;
        }
-        ide_init_packet_cmd(cmd, tf_flags, bcount, drive->dma);
+        ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma);
        (void)do_rw_taskfile(drive, cmd);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 35729a47f797..3aec19d1fdfc 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -265,35 +265,62 @@ static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq)
                cdrom_analyze_sense_data(drive, NULL, sense);
 }
 /*
+ * Allow the drive 5 seconds to recover; some devices will return NOT_READY
+ * while flushing data from cache.
+ *
+ * returns: 0 failed (write timeout expired)
+ *          1 success
+ */
+static int ide_cd_breathe(ide_drive_t *drive, struct request *rq)
+{
+        struct cdrom_info *info = drive->driver_data;
+        if (!rq->errors)
+                info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
+        rq->errors = 1;
+        if (time_after(jiffies, info->write_timeout))
+                return 0;
+        else {
+                struct request_queue *q = drive->queue;
+                unsigned long flags;
+                /*
+                 * take a breather relying on the unplug timer to kick us again
+                 */
+                spin_lock_irqsave(q->queue_lock, flags);
+                blk_plug_device(q);
+                spin_unlock_irqrestore(q->queue_lock, flags);
+                return 1;
+        }
+}
+/**
 * Returns:
 * 0: if the request should be continued.
 * 1: if the request will be going through error recovery.
 * 2: if the request should be ended.
 */
-static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
+static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct request *rq = hwif->rq;
-        int stat, err, sense_key;
+        int err, sense_key, do_end_request = 0;
+        u8 quiet = rq->cmd_flags & REQ_QUIET;
-        /* check for errors */
-        stat = hwif->tp_ops->read_status(hwif);
-        if (stat_ret)
-                *stat_ret = stat;
-        if (OK_STAT(stat, good_stat, BAD_R_STAT))
-                return 0;
        /* get the IDE error register */
        err = ide_read_error(drive);
        sense_key = err >> 4;
-        ide_debug_log(IDE_DBG_RQ, "stat: 0x%x, good_stat: 0x%x, cmd[0]: 0x%x, "
+        ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, rq->cmd_type: 0x%x, err: 0x%x, "
-                                  "rq->cmd_type: 0x%x, err: 0x%x",
+                                  "stat 0x%x",
-                                  stat, good_stat, rq->cmd[0], rq->cmd_type,
+                                  rq->cmd[0], rq->cmd_type, err, stat);
-                                  err);
        if (blk_sense_request(rq)) {
                /*
@@ -303,151 +330,108 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                 */
                rq->cmd_flags |= REQ_FAILED;
                return 2;
-        } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
+        }
-                /* All other functions, except for READ. */
-                /*
+        /* if we have an error, pass CHECK_CONDITION as the SCSI status byte */
-                 * if we have an error, pass back CHECK_CONDITION as the
+        if (blk_pc_request(rq) && !rq->errors)
-                 * scsi status byte
+                rq->errors = SAM_STAT_CHECK_CONDITION;
-                 */
-                if (blk_pc_request(rq) && !rq->errors)
-                        rq->errors = SAM_STAT_CHECK_CONDITION;
-                /* check for tray open */
+        if (blk_noretry_request(rq))
-                if (sense_key == NOT_READY) {
+                do_end_request = 1;
-                        cdrom_saw_media_change(drive);
-                } else if (sense_key == UNIT_ATTENTION) {
+        switch (sense_key) {
-                        /* check for media change */
+        case NOT_READY:
+                if (blk_fs_request(rq) && rq_data_dir(rq) == WRITE) {
+                        if (ide_cd_breathe(drive, rq))
+                                return 1;
+                } else {
                        cdrom_saw_media_change(drive);
-                        return 0;
-                } else if (sense_key == ILLEGAL_REQUEST &&
+                        if (blk_fs_request(rq) && !quiet)
-                           rq->cmd[0] == GPCMD_START_STOP_UNIT) {
+                                printk(KERN_ERR PFX "%s: tray open\n",
-                        /*
+                                        drive->name);
-                         * Don't print error message for this condition--
-                         * SFF8090i indicates that 5/24/00 is the correct
-                         * response to a request to close the tray if the
-                         * drive doesn't have that capability.
-                         * cdrom_log_sense() knows this!
-                         */
-                } else if (!(rq->cmd_flags & REQ_QUIET)) {
-                        /* otherwise, print an error */
-                        ide_dump_status(drive, "packet command error", stat);
                }
+                do_end_request = 1;
+                break;
+        case UNIT_ATTENTION:
+                cdrom_saw_media_change(drive);
-                rq->cmd_flags |= REQ_FAILED;
+                if (blk_fs_request(rq) == 0)
+                        return 0;
                /*
-                 * instead of playing games with moving completions around,
+                 * Arrange to retry the request but be sure to give up if we've
-                 * remove failed request completely and end it when the
+                 * retried too many times.
-                 * request sense has completed
                 */
-                goto end_request;
+                if (++rq->errors > ERROR_MAX)
-        } else if (blk_fs_request(rq)) {
-                int do_end_request = 0;
-                /* handle errors from READ and WRITE requests */
-                if (blk_noretry_request(rq))
                        do_end_request = 1;
+                break;
-                if (sense_key == NOT_READY) {
+        case ILLEGAL_REQUEST:
-                        /* tray open */
+                /*
-                        if (rq_data_dir(rq) == READ) {
+                 * Don't print error message for this condition -- SFF8090i
-                                cdrom_saw_media_change(drive);
+                 * indicates that 5/24/00 is the correct response to a request
+                 * to close the tray if the drive doesn't have that capability.
-                                /* fail the request */
+                 *
-                                printk(KERN_ERR PFX "%s: tray open\n",
+                 * cdrom_log_sense() knows this!
-                                                drive->name);
+                 */
-                                do_end_request = 1;
+                if (rq->cmd[0] == GPCMD_START_STOP_UNIT)
-                        } else {
+                        break;
-                                struct cdrom_info *info = drive->driver_data;
+                /* fall-through */
+        case DATA_PROTECT:
-                                /*
+                /*
-                                 * Allow the drive 5 seconds to recover, some
+                 * No point in retrying after an illegal request or data
-                                 * devices will return this error while flushing
+                 * protect error.
-                                 * data from cache.
+                 */
-                                 */
+                if (!quiet)
-                                if (!rq->errors)
-                                        info->write_timeout = jiffies +
-                                                        ATAPI_WAIT_WRITE_BUSY;
-                                rq->errors = 1;
-                                if (time_after(jiffies, info->write_timeout))
-                                        do_end_request = 1;
-                                else {
-                                        struct request_queue *q = drive->queue;
-                                        unsigned long flags;
-                                        /*
-                                         * take a breather relying on the unplug
-                                         * timer to kick us again
-                                         */
-                                        spin_lock_irqsave(q->queue_lock, flags);
-                                        blk_plug_device(q);
-                                        spin_unlock_irqrestore(q->queue_lock, flags);
-                                        return 1;
-                                }
-                        }
-                } else if (sense_key == UNIT_ATTENTION) {
-                        /* media change */
-                        cdrom_saw_media_change(drive);
-                        /*
-                         * Arrange to retry the request but be sure to give up
-                         * if we've retried too many times.
-                         */
-                        if (++rq->errors > ERROR_MAX)
-                                do_end_request = 1;
-                } else if (sense_key == ILLEGAL_REQUEST ||
-                           sense_key == DATA_PROTECT) {
-                        /*
-                         * No point in retrying after an illegal request or data
-                         * protect error.
-                         */
                        ide_dump_status(drive, "command error", stat);
-                        do_end_request = 1;
+                do_end_request = 1;
-                } else if (sense_key == MEDIUM_ERROR) {
+                break;
-                        /*
+        case MEDIUM_ERROR:
-                         * No point in re-trying a zillion times on a bad
+                /*
-                         * sector. If we got here the error is not correctable.
+                 * No point in re-trying a zillion times on a bad sector.
-                         */
+                 * If we got here the error is not correctable.
-                        ide_dump_status(drive, "media error (bad sector)",
+                 */
+                if (!quiet)
+                        ide_dump_status(drive, "media error "
+                                        "(bad sector)", stat);
+                do_end_request = 1;
+                break;
+        case BLANK_CHECK:
+                /* disk appears blank? */
+                if (!quiet)
+                        ide_dump_status(drive, "media error (blank)",
                                        stat);
-                        do_end_request = 1;
+                do_end_request = 1;
-                } else if (sense_key == BLANK_CHECK) {
+                break;
-                        /* disk appears blank ?? */
+        default:
-                        ide_dump_status(drive, "media error (blank)", stat);
+                if (blk_fs_request(rq) == 0)
-                        do_end_request = 1;
+                        break;
-                } else if ((err & ~ATA_ABORTED) != 0) {
+                if (err & ~ATA_ABORTED) {
                        /* go to the default handler for other errors */
                        ide_error(drive, "cdrom_decode_status", stat);
                        return 1;
-                } else if ((++rq->errors > ERROR_MAX)) {
+                } else if (++rq->errors > ERROR_MAX)
                        /* we've racked up too many retries, abort */
                        do_end_request = 1;
-                }
+        }
-                /*
-                 * End a request through request sense analysis when we have
-                 * sense data. We need this in order to perform end of media
-                 * processing.
-                 */
-                if (do_end_request)
-                        goto end_request;
-                /*
+        if (blk_fs_request(rq) == 0) {
-                 * If we got a CHECK_CONDITION status, queue
+                rq->cmd_flags |= REQ_FAILED;
-                 * a request sense command.
+                do_end_request = 1;
-                 */
-                if (stat & ATA_ERR)
-                        cdrom_queue_request_sense(drive, NULL, NULL);
-                return 1;
-        } else {
-                blk_dump_rq_flags(rq, PFX "bad rq");
-                return 2;
        }
+        /*
+         * End a request through request sense analysis when we have sense data.
+         * We need this in order to perform end of media processing.
+         */
+        if (do_end_request)
+                goto end_request;
+        /* if we got a CHECK_CONDITION status, queue a request sense command */
+        if (stat & ATA_ERR)
+                cdrom_queue_request_sense(drive, NULL, NULL);
+        return 1;
 end_request:
        if (stat & ATA_ERR) {
                struct request_queue *q = drive->queue;
@@ -624,15 +608,14 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        struct ide_cmd *cmd = &hwif->cmd;
        struct request *rq = hwif->rq;
        ide_expiry_t *expiry = NULL;
-        int dma_error = 0, dma, stat, thislen, uptodate = 0;
+        int dma_error = 0, dma, thislen, uptodate = 0;
        int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc, nsectors;
        int sense = blk_sense_request(rq);
        unsigned int timeout;
        u16 len;
-        u8 ireason;
+        u8 ireason, stat;
-        ide_debug_log(IDE_DBG_PC, "cmd[0]: 0x%x, write: 0x%x",
+        ide_debug_log(IDE_DBG_PC, "cmd: 0x%x, write: 0x%x", rq->cmd[0], write);
-                                  rq->cmd[0], write);
        /* check for errors */
        dma = drive->dma;
@@ -648,11 +631,16 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                }
        }
-        rc = cdrom_decode_status(drive, 0, &stat);
+        /* check status */
-        if (rc) {
+        stat = hwif->tp_ops->read_status(hwif);
-                if (rc == 2)
-                        goto out_end;
+        if (!OK_STAT(stat, 0, BAD_R_STAT)) {
-                return ide_stopped;
+                rc = cdrom_decode_status(drive, stat);
+                if (rc) {
+                        if (rc == 2)
+                                goto out_end;
+                        return ide_stopped;
+                }
        }
        /* using dma, transfer is complete now */
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index c998cf8e971a..a9fbe2c31210 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -97,35 +97,38 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
        }
        memset(&cmd, 0, sizeof(cmd));
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        if (drive->dev_flags & IDE_DFLAG_LBA) {
                if (lba48) {
                        pr_debug("%s: LBA=0x%012llx\n", drive->name,
                                        (unsigned long long)block);
-                        tf->hob_nsect = (nsectors >> 8) & 0xff;
-                        tf->hob_lbal  = (u8)(block >> 24);
-                        if (sizeof(block) != 4) {
-                                tf->hob_lbam = (u8)((u64)block >> 32);
-                                tf->hob_lbah = (u8)((u64)block >> 40);
-                        }
                        tf->nsect  = nsectors & 0xff;
                        tf->lbal   = (u8) block;
                        tf->lbam   = (u8)(block >>  8);
                        tf->lbah   = (u8)(block >> 16);
+                        tf->device = ATA_LBA;
-                        cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+                        tf = &cmd.hob;
+                        tf->nsect = (nsectors >> 8) & 0xff;
+                        tf->lbal  = (u8)(block >> 24);
+                        if (sizeof(block) != 4) {
+                                tf->lbam = (u8)((u64)block >> 32);
+                                tf->lbah = (u8)((u64)block >> 40);
+                        }
+                        cmd.valid.out.hob = IDE_VALID_OUT_HOB;
+                        cmd.valid.in.hob  = IDE_VALID_IN_HOB;
+                        cmd.tf_flags |= IDE_TFLAG_LBA48;
                } else {
                        tf->nsect  = nsectors & 0xff;
                        tf->lbal   = block;
                        tf->lbam   = block >>= 8;
                        tf->lbah   = block >>= 8;
-                        tf->device = (block >> 8) & 0xf;
+                        tf->device = ((block >> 8) & 0xf) | ATA_LBA;
                }
-                tf->device |= ATA_LBA;
        } else {
                unsigned int sect, head, cyl, track;
@@ -220,15 +223,19 @@ static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
                tf->command = ATA_CMD_READ_NATIVE_MAX;
        tf->device  = ATA_LBA;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
-        if (lba48)
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
-                cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+        if (lba48) {
+                cmd.valid.out.hob = IDE_VALID_OUT_HOB;
+                cmd.valid.in.hob  = IDE_VALID_IN_HOB;
+                cmd.tf_flags = IDE_TFLAG_LBA48;
+        }
        ide_no_data_taskfile(drive, &cmd);
        /* if OK, compute maximum address value */
        if (!(tf->status & ATA_ERR))
-                addr = ide_get_lba_addr(tf, lba48) + 1;
+                addr = ide_get_lba_addr(&cmd, lba48) + 1;
        return addr;
 }
@@ -250,9 +257,9 @@ static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
        tf->lbam     = (addr_req >>= 8) & 0xff;
        tf->lbah     = (addr_req >>= 8) & 0xff;
        if (lba48) {
-                tf->hob_lbal = (addr_req >>= 8) & 0xff;
+                cmd.hob.lbal = (addr_req >>= 8) & 0xff;
-                tf->hob_lbam = (addr_req >>= 8) & 0xff;
+                cmd.hob.lbam = (addr_req >>= 8) & 0xff;
-                tf->hob_lbah = (addr_req >>= 8) & 0xff;
+                cmd.hob.lbah = (addr_req >>= 8) & 0xff;
                tf->command  = ATA_CMD_SET_MAX_EXT;
        } else {
                tf->device   = (addr_req >>= 8) & 0x0f;
@@ -260,15 +267,19 @@ static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
        }
        tf->device |= ATA_LBA;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
-        if (lba48)
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
-                cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
+        if (lba48) {
+                cmd.valid.out.hob = IDE_VALID_OUT_HOB;
+                cmd.valid.in.hob  = IDE_VALID_IN_HOB;
+                cmd.tf_flags = IDE_TFLAG_LBA48;
+        }
        ide_no_data_taskfile(drive, &cmd);
        /* if OK, compute maximum address value */
        if (!(tf->status & ATA_ERR))
-                addr_set = ide_get_lba_addr(tf, lba48) + 1;
+                addr_set = ide_get_lba_addr(&cmd, lba48) + 1;
        return addr_set;
 }
@@ -395,8 +406,8 @@ static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
                cmd->tf.command = ATA_CMD_FLUSH_EXT;
        else
                cmd->tf.command = ATA_CMD_FLUSH;
-        cmd->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
+        cmd->valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
-                        IDE_TFLAG_DYN;
+        cmd->tf_flags = IDE_TFLAG_DYN;
        cmd->protocol = ATA_PROT_NODATA;
        rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
@@ -457,7 +468,8 @@ static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
        cmd.tf.feature = feature;
        cmd.tf.nsect   = nsect;
        cmd.tf.command = ATA_CMD_SET_FEATURES;
-        cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        return ide_no_data_taskfile(drive, &cmd);
 }
@@ -533,7 +545,8 @@ static int do_idedisk_flushcache(ide_drive_t *drive)
                cmd.tf.command = ATA_CMD_FLUSH_EXT;
        else
                cmd.tf.command = ATA_CMD_FLUSH;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        return ide_no_data_taskfile(drive, &cmd);
 }
@@ -715,7 +728,8 @@ static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,
        memset(&cmd, 0, sizeof(cmd));
        cmd.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
-        cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        ret = ide_no_data_taskfile(drive, &cmd);
diff --git a/drivers/ide/ide-disk_proc.c b/drivers/ide/ide-disk_proc.c
index eaea3bef2073..19f263bf0a9e 100644
--- a/drivers/ide/ide-disk_proc.c
+++ b/drivers/ide/ide-disk_proc.c
@@ -13,7 +13,8 @@ static int smart_enable(ide_drive_t *drive)
        tf->lbam    = ATA_SMART_LBAM_PASS;
        tf->lbah    = ATA_SMART_LBAH_PASS;
        tf->command = ATA_CMD_SMART;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        return ide_no_data_taskfile(drive, &cmd);
 }
@@ -29,7 +30,8 @@ static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
        tf->lbam    = ATA_SMART_LBAM_PASS;
        tf->lbah    = ATA_SMART_LBAH_PASS;
        tf->command = ATA_CMD_SMART;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        cmd.protocol = ATA_PROT_PIO;
        return ide_raw_taskfile(drive, &cmd, buf, 1);
diff --git a/drivers/ide/ide-dma-sff.c b/drivers/ide/ide-dma-sff.c
index 16fc46edc32d..e4cdf78cc3e9 100644
--- a/drivers/ide/ide-dma-sff.c
+++ b/drivers/ide/ide-dma-sff.c
@@ -277,8 +277,6 @@ void ide_dma_start(ide_drive_t *drive)
                dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD);
                outb(dma_cmd | ATA_DMA_START, hwif->dma_base + ATA_DMA_CMD);
        }
-        wmb();
 }
 EXPORT_SYMBOL_GPL(ide_dma_start);
@@ -286,7 +284,7 @@ EXPORT_SYMBOL_GPL(ide_dma_start);
 int ide_dma_end(ide_drive_t *drive)
 {
        ide_hwif_t *hwif = drive->hwif;
-        u8 dma_stat = 0, dma_cmd = 0, mask;
+        u8 dma_stat = 0, dma_cmd = 0;
        /* stop DMA */
        if (hwif->host_flags & IDE_HFLAG_MMIO) {
@@ -304,11 +302,10 @@ int ide_dma_end(ide_drive_t *drive)
        /* clear INTR & ERROR bits */
        ide_dma_sff_write_status(hwif, dma_stat | ATA_DMA_ERR | ATA_DMA_INTR);
-        wmb();
+#define CHECK_DMA_MASK (ATA_DMA_ACTIVE | ATA_DMA_ERR | ATA_DMA_INTR)
        /* verify good DMA status */
-        mask = ATA_DMA_ACTIVE | ATA_DMA_ERR | ATA_DMA_INTR;
+        if ((dma_stat & CHECK_DMA_MASK) != ATA_DMA_INTR)
-        if ((dma_stat & mask) != ATA_DMA_INTR)
                return 0x10 | dma_stat;
        return 0;
 }
diff --git a/drivers/ide/ide-h8300.c b/drivers/ide/ide-h8300.c
index dac9a6d44963..c06ebdc4a130 100644
--- a/drivers/ide/ide-h8300.c
+++ b/drivers/ide/ide-h8300.c
@@ -22,103 +22,6 @@
        (r);                            \
 })
-static void mm_outw(u16 d, unsigned long a)
-{
-        __asm__("mov.b %w0,r2h\n\t"
-                "mov.b %x0,r2l\n\t"
-                "mov.w r2,@%1"
-                :
-                :"r"(d),"r"(a)
-                :"er2");
-}
-static u16 mm_inw(unsigned long a)
-{
-        register u16 r __asm__("er0");
-        __asm__("mov.w @%1,r2\n\t"
-                "mov.b r2l,%x0\n\t"
-                "mov.b r2h,%w0"
-                :"=r"(r)
-                :"r"(a)
-                :"er2");
-        return r;
-}
-static void h8300_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
-                outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
-                outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
-                outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
-                outb(tf->lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                outb((tf->device & HIHI) | drive->select,
-                     io_ports->device_addr);
-}
-static void h8300_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
-        outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
-                tf->error  = inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = inb(io_ports->lbah_addr);
-        }
-}
 static void mm_outsw(unsigned long addr, void *buf, u32 len)
 {
        unsigned short *bp = (unsigned short *)buf;
@@ -152,8 +55,8 @@ static const struct ide_tp_ops h8300_tp_ops = {
        .write_devctl           = ide_write_devctl,
        .dev_select             = ide_dev_select,
-        .tf_load                = h8300_tf_load,
+        .tf_load                = ide_tf_load,
-        .tf_read                = h8300_tf_read,
+        .tf_read                = ide_tf_read,
        .input_data             = h8300_input_data,
        .output_data            = h8300_output_data,
diff --git a/drivers/ide/ide-io-std.c b/drivers/ide/ide-io-std.c
index 9cac281d82c4..46721c454518 100644
--- a/drivers/ide/ide-io-std.c
+++ b/drivers/ide/ide-io-std.c
@@ -85,98 +85,57 @@ void ide_dev_select(ide_drive_t *drive)
 }
 EXPORT_SYMBOL_GPL(ide_dev_select);
-void ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
+void ide_tf_load(ide_drive_t *drive, struct ide_taskfile *tf, u8 valid)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
        void (*tf_outb)(u8 addr, unsigned long port);
        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
        if (mmio)
                tf_outb = ide_mm_outb;
        else
                tf_outb = ide_outb;
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
+        if (valid & IDE_VALID_FEATURE)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                tf_outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                tf_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                tf_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                tf_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                tf_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                tf_outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
+        if (valid & IDE_VALID_NSECT)
                tf_outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
+        if (valid & IDE_VALID_LBAL)
                tf_outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
+        if (valid & IDE_VALID_LBAM)
                tf_outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
+        if (valid & IDE_VALID_LBAH)
                tf_outb(tf->lbah, io_ports->lbah_addr);
+        if (valid & IDE_VALID_DEVICE)
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
+                tf_outb(tf->device, io_ports->device_addr);
-                tf_outb((tf->device & HIHI) | drive->select,
-                         io_ports->device_addr);
 }
 EXPORT_SYMBOL_GPL(ide_tf_load);
-void ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
+void ide_tf_read(ide_drive_t *drive, struct ide_taskfile *tf, u8 valid)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        void (*tf_outb)(u8 addr, unsigned long port);
        u8 (*tf_inb)(unsigned long port);
        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        if (mmio) {
+        if (mmio)
-                tf_outb = ide_mm_outb;
                tf_inb  = ide_mm_inb;
-        } else {
+        else
-                tf_outb = ide_outb;
                tf_inb  = ide_inb;
-        }
-        /* be sure we're looking at the low order bits */
-        tf_outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
+        if (valid & IDE_VALID_ERROR)
                tf->error  = tf_inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
+        if (valid & IDE_VALID_NSECT)
                tf->nsect  = tf_inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
+        if (valid & IDE_VALID_LBAL)
                tf->lbal   = tf_inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
+        if (valid & IDE_VALID_LBAM)
                tf->lbam   = tf_inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
+        if (valid & IDE_VALID_LBAH)
                tf->lbah   = tf_inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
+        if (valid & IDE_VALID_DEVICE)
                tf->device = tf_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                tf_outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = tf_inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = tf_inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = tf_inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = tf_inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = tf_inb(io_ports->lbah_addr);
-        }
 }
 EXPORT_SYMBOL_GPL(ide_tf_read);
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 1deb6d29b186..2ae02b8d7f8e 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -86,18 +86,18 @@ void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
                tp_ops->input_data(drive, cmd, data, 2);
-                tf->data = data[0];
+                cmd->tf.data  = data[0];
-                tf->hob_data = data[1];
+                cmd->hob.data = data[1];
        }
-        tp_ops->tf_read(drive, cmd);
+        ide_tf_readback(drive, cmd);
        if ((cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) &&
            tf_cmd == ATA_CMD_IDLEIMMEDIATE) {
                if (tf->lbal != 0xc4) {
                        printk(KERN_ERR "%s: head unload failed!\n",
                               drive->name);
-                        ide_tf_dump(drive->name, tf);
+                        ide_tf_dump(drive->name, cmd);
                } else
                        drive->dev_flags |= IDE_DFLAG_PARKED;
        }
@@ -205,8 +205,9 @@ static ide_startstop_t ide_disk_special(ide_drive_t *drive)
                return ide_stopped;
        }
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE |
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
-                       IDE_TFLAG_CUSTOM_HANDLER;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
+        cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER;
        do_rw_taskfile(drive, &cmd);
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index 770142767437..c1c25ebbaa1f 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -141,11 +141,12 @@ static int ide_cmd_ioctl(ide_drive_t *drive, unsigned long arg)
                tf->lbal  = args[1];
                tf->lbam  = 0x4f;
                tf->lbah  = 0xc2;
-                cmd.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_IN_NSECT;
+                cmd.valid.out.tf = IDE_VALID_OUT_TF;
+                cmd.valid.in.tf  = IDE_VALID_NSECT;
        } else {
                tf->nsect = args[1];
-                cmd.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
+                cmd.valid.out.tf = IDE_VALID_FEATURE | IDE_VALID_NSECT;
-                               IDE_TFLAG_IN_NSECT;
+                cmd.valid.in.tf  = IDE_VALID_NSECT;
        }
        tf->command = args[0];
        cmd.protocol = args[3] ? ATA_PROT_PIO : ATA_PROT_NODATA;
@@ -205,14 +206,15 @@ static int ide_task_ioctl(ide_drive_t *drive, unsigned long arg)
                return -EFAULT;
        memset(&cmd, 0, sizeof(cmd));
-        memcpy(&cmd.tf_array[7], &args[1], 6);
+        memcpy(&cmd.tf.feature, &args[1], 6);
        cmd.tf.command = args[0];
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        err = ide_no_data_taskfile(drive, &cmd);
        args[0] = cmd.tf.command;
-        memcpy(&args[1], &cmd.tf_array[7], 6);
+        memcpy(&args[1], &cmd.tf.feature, 6);
        if (copy_to_user(p, args, 7))
                err = -EFAULT;
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 27bb70ddd459..c19a221b1e18 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -37,14 +37,11 @@ void SELECT_MASK(ide_drive_t *drive, int mask)
 u8 ide_read_error(ide_drive_t *drive)
 {
-        struct ide_cmd cmd;
+        struct ide_taskfile tf;
-        memset(&cmd, 0, sizeof(cmd));
+        drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
-        cmd.tf_flags = IDE_TFLAG_IN_ERROR;
-        drive->hwif->tp_ops->tf_read(drive, &cmd);
+        return tf.error;
-        return cmd.tf.error;
 }
 EXPORT_SYMBOL_GPL(ide_read_error);
@@ -312,10 +309,10 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 {
        ide_hwif_t *hwif = drive->hwif;
        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
+        struct ide_taskfile tf;
        u16 *id = drive->id, i;
        int error = 0;
        u8 stat;
-        struct ide_cmd cmd;
 #ifdef CONFIG_BLK_DEV_IDEDMA
        if (hwif->dma_ops)      /* check if host supports DMA */
@@ -347,12 +344,11 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
        udelay(1);
        tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
-        memset(&cmd, 0, sizeof(cmd));
+        memset(&tf, 0, sizeof(tf));
-        cmd.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT;
+        tf.feature = SETFEATURES_XFER;
-        cmd.tf.feature = SETFEATURES_XFER;
+        tf.nsect   = speed;
-        cmd.tf.nsect   = speed;
-        tp_ops->tf_load(drive, &cmd);
+        tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
        tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 217b7fdf2b17..56ff8c46c7d1 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -49,16 +49,17 @@ static void ide_dump_opcode(ide_drive_t *drive)
                printk(KERN_CONT "0x%02x\n", cmd->tf.command);
 }
-u64 ide_get_lba_addr(struct ide_taskfile *tf, int lba48)
+u64 ide_get_lba_addr(struct ide_cmd *cmd, int lba48)
 {
+        struct ide_taskfile *tf = &cmd->tf;
        u32 high, low;
-        if (lba48)
-                high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
-                        tf->hob_lbal;
-        else
-                high = tf->device & 0xf;
        low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
+        if (lba48) {
+                tf = &cmd->hob;
+                high = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
+        } else
+                high = tf->device & 0xf;
        return ((u64)high << 24) | low;
 }
@@ -71,17 +72,18 @@ static void ide_dump_sector(ide_drive_t *drive)
        u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
        memset(&cmd, 0, sizeof(cmd));
-        if (lba48)
+        if (lba48) {
-                cmd.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_HOB_LBA |
+                cmd.valid.in.tf  = IDE_VALID_LBA;
-                                IDE_TFLAG_LBA48;
+                cmd.valid.in.hob = IDE_VALID_LBA;
-        else
+                cmd.tf_flags = IDE_TFLAG_LBA48;
-                cmd.tf_flags = IDE_TFLAG_IN_LBA | IDE_TFLAG_IN_DEVICE;
+        } else
+                cmd.valid.in.tf  = IDE_VALID_LBA | IDE_VALID_DEVICE;
-        drive->hwif->tp_ops->tf_read(drive, &cmd);
+        ide_tf_readback(drive, &cmd);
        if (lba48 || (tf->device & ATA_LBA))
                printk(KERN_CONT ", LBAsect=%llu",
-                        (unsigned long long)ide_get_lba_addr(tf, lba48));
+                        (unsigned long long)ide_get_lba_addr(&cmd, lba48));
        else
                printk(KERN_CONT ", CHS=%d/%d/%d", (tf->lbah << 8) + tf->lbam,
                        tf->device & 0xf, tf->lbal);
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 9490b446519f..310d03f2b5b7 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -74,7 +74,8 @@ ide_startstop_t ide_do_park_unpark(ide_drive_t *drive, struct request *rq)
                tf->lbal = 0x4c;
                tf->lbam = 0x4e;
                tf->lbah = 0x55;
-                cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+                cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+                cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        } else          /* cmd == REQ_UNPARK_HEADS */
                tf->command = ATA_CMD_CHK_POWER;
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index bb7858ebb7d1..0d8a151c0a01 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -163,7 +163,8 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
        return ide_stopped;
 out_do_tf:
-        cmd->tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd->valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd->valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        cmd->protocol = ATA_PROT_NODATA;
        return do_rw_taskfile(drive, cmd);
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index d8c1c3e735bb..7f264ed1141b 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -283,13 +283,11 @@ int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id)
         * identify command to be sure of reply
         */
        if (cmd == ATA_CMD_ID_ATAPI) {
-                struct ide_cmd cmd;
+                struct ide_taskfile tf;
-                memset(&cmd, 0, sizeof(cmd));
+                memset(&tf, 0, sizeof(tf));
                /* disable DMA & overlap */
-                cmd.tf_flags = IDE_TFLAG_OUT_FEATURE;
+                tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
-                tp_ops->tf_load(drive, &cmd);
        }
        /* ask drive for ID */
@@ -337,14 +335,11 @@ int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
 static u8 ide_read_device(ide_drive_t *drive)
 {
-        struct ide_cmd cmd;
+        struct ide_taskfile tf;
-        memset(&cmd, 0, sizeof(cmd));
-        cmd.tf_flags = IDE_TFLAG_IN_DEVICE;
-        drive->hwif->tp_ops->tf_read(drive, &cmd);
+        drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
-        return cmd.tf.device;
+        return tf.device;
 }
 /**
@@ -1314,6 +1309,7 @@ struct ide_host *ide_host_alloc(const struct ide_port_info *d, hw_regs_t **hws)
                host->get_lock     = d->get_lock;
                host->release_lock = d->release_lock;
                host->host_flags = d->host_flags;
+                host->irq_flags = d->irq_flags;
        }
        return host;
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index 10a88bf3eefa..3242698832a4 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -204,8 +204,8 @@ static int set_xfer_rate (ide_drive_t *drive, int arg)
        cmd.tf.command = ATA_CMD_SET_FEATURES;
        cmd.tf.feature = SETFEATURES_XFER;
        cmd.tf.nsect   = (u8)arg;
-        cmd.tf_flags   = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
+        cmd.valid.out.tf = IDE_VALID_FEATURE | IDE_VALID_NSECT;
-                         IDE_TFLAG_IN_NSECT;
+        cmd.valid.in.tf  = IDE_VALID_NSECT;
        err = ide_no_data_taskfile(drive, &cmd);
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 243421ce40d0..4aa6223c11be 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -23,17 +23,33 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
-void ide_tf_dump(const char *s, struct ide_taskfile *tf)
+void ide_tf_readback(ide_drive_t *drive, struct ide_cmd *cmd)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
+        /* Be sure we're looking at the low order bytes */
+        tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
+        tp_ops->tf_read(drive, &cmd->tf, cmd->valid.in.tf);
+        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
+                tp_ops->write_devctl(hwif, ATA_HOB | ATA_DEVCTL_OBS);
+                tp_ops->tf_read(drive, &cmd->hob, cmd->valid.in.hob);
+        }
+}
+void ide_tf_dump(const char *s, struct ide_cmd *cmd)
 {
 #ifdef DEBUG
        printk("%s: tf: feat 0x%02x nsect 0x%02x lbal 0x%02x "
                "lbam 0x%02x lbah 0x%02x dev 0x%02x cmd 0x%02x\n",
-                s, tf->feature, tf->nsect, tf->lbal,
+               s, cmd->tf.feature, cmd->tf.nsect,
-                tf->lbam, tf->lbah, tf->device, tf->command);
+               cmd->tf.lbal, cmd->tf.lbam, cmd->tf.lbah,
-        printk("%s: hob: nsect 0x%02x lbal 0x%02x "
+               cmd->tf.device, cmd->tf.command);
-                "lbam 0x%02x lbah 0x%02x\n",
+        printk("%s: hob: nsect 0x%02x lbal 0x%02x lbam 0x%02x lbah 0x%02x\n",
-                s, tf->hob_nsect, tf->hob_lbal,
+               s, cmd->hob.nsect, cmd->hob.lbal, cmd->hob.lbam, cmd->hob.lbah);
-                tf->hob_lbam, tf->hob_lbah);
 #endif
 }
@@ -47,7 +63,8 @@ int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf)
                cmd.tf.command = ATA_CMD_ID_ATA;
        else
                cmd.tf.command = ATA_CMD_ID_ATAPI;
-        cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
        cmd.protocol = ATA_PROT_PIO;
        return ide_raw_taskfile(drive, &cmd, buf, 1);
@@ -79,16 +96,27 @@ ide_startstop_t do_rw_taskfile(ide_drive_t *drive, struct ide_cmd *orig_cmd)
        memcpy(cmd, orig_cmd, sizeof(*cmd));
        if ((cmd->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) {
-                ide_tf_dump(drive->name, tf);
+                ide_tf_dump(drive->name, cmd);
                tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
                SELECT_MASK(drive, 0);
                if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA) {
-                        u8 data[2] = { tf->data, tf->hob_data };
+                        u8 data[2] = { cmd->tf.data, cmd->hob.data };
                        tp_ops->output_data(drive, cmd, data, 2);
                }
-                tp_ops->tf_load(drive, cmd);
+                if (cmd->valid.out.tf & IDE_VALID_DEVICE) {
+                        u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ?
+                                  0xE0 : 0xEF;
+                        if (!(cmd->ftf_flags & IDE_FTFLAG_FLAGGED))
+                                cmd->tf.device &= HIHI;
+                        cmd->tf.device |= drive->select;
+                }
+                tp_ops->tf_load(drive, &cmd->hob, cmd->valid.out.hob);
+                tp_ops->tf_load(drive, &cmd->tf,  cmd->valid.out.tf);
        }
        switch (cmd->protocol) {
@@ -489,16 +517,17 @@ int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
        memset(&cmd, 0, sizeof(cmd));
-        memcpy(&cmd.tf_array[0], req_task->hob_ports,
+        memcpy(&cmd.hob, req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE - 2);
-               HDIO_DRIVE_HOB_HDR_SIZE - 2);
+        memcpy(&cmd.tf,  req_task->io_ports,  HDIO_DRIVE_TASK_HDR_SIZE);
-        memcpy(&cmd.tf_array[6], req_task->io_ports,
-               HDIO_DRIVE_TASK_HDR_SIZE);
-        cmd.tf_flags   = IDE_TFLAG_IO_16BIT | IDE_TFLAG_DEVICE |
+        cmd.valid.out.tf = IDE_VALID_DEVICE;
-                         IDE_TFLAG_IN_TF;
+        cmd.valid.in.tf  = IDE_VALID_DEVICE | IDE_VALID_IN_TF;
+        cmd.tf_flags = IDE_TFLAG_IO_16BIT;
-        if (drive->dev_flags & IDE_DFLAG_LBA48)
+        if (drive->dev_flags & IDE_DFLAG_LBA48) {
-                cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_IN_HOB);
+                cmd.tf_flags |= IDE_TFLAG_LBA48;
+                cmd.valid.in.hob = IDE_VALID_IN_HOB;
+        }
        if (req_task->out_flags.all) {
                cmd.ftf_flags |= IDE_FTFLAG_FLAGGED;
@@ -507,28 +536,28 @@ int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
                        cmd.ftf_flags |= IDE_FTFLAG_OUT_DATA;
                if (req_task->out_flags.b.nsector_hob)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_HOB_NSECT;
+                        cmd.valid.out.hob |= IDE_VALID_NSECT;
                if (req_task->out_flags.b.sector_hob)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAL;
+                        cmd.valid.out.hob |= IDE_VALID_LBAL;
                if (req_task->out_flags.b.lcyl_hob)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAM;
+                        cmd.valid.out.hob |= IDE_VALID_LBAM;
                if (req_task->out_flags.b.hcyl_hob)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_HOB_LBAH;
+                        cmd.valid.out.hob |= IDE_VALID_LBAH;
                if (req_task->out_flags.b.error_feature)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_FEATURE;
+                        cmd.valid.out.tf  |= IDE_VALID_FEATURE;
                if (req_task->out_flags.b.nsector)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_NSECT;
+                        cmd.valid.out.tf  |= IDE_VALID_NSECT;
                if (req_task->out_flags.b.sector)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_LBAL;
+                        cmd.valid.out.tf  |= IDE_VALID_LBAL;
                if (req_task->out_flags.b.lcyl)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_LBAM;
+                        cmd.valid.out.tf  |= IDE_VALID_LBAM;
                if (req_task->out_flags.b.hcyl)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_LBAH;
+                        cmd.valid.out.tf  |= IDE_VALID_LBAH;
        } else {
-                cmd.tf_flags |= IDE_TFLAG_OUT_TF;
+                cmd.valid.out.tf |= IDE_VALID_OUT_TF;
                if (cmd.tf_flags & IDE_TFLAG_LBA48)
-                        cmd.tf_flags |= IDE_TFLAG_OUT_HOB;
+                        cmd.valid.out.hob |= IDE_VALID_OUT_HOB;
        }
        if (req_task->in_flags.b.data)
@@ -594,7 +623,7 @@ int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
        if (req_task->req_cmd == IDE_DRIVE_TASK_NO_DATA)
                nsect = 0;
        else if (!nsect) {
-                nsect = (cmd.tf.hob_nsect << 8) | cmd.tf.nsect;
+                nsect = (cmd.hob.nsect << 8) | cmd.tf.nsect;
                if (!nsect) {
                        printk(KERN_ERR "%s: in/out command without data\n",
@@ -606,10 +635,8 @@ int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
        err = ide_raw_taskfile(drive, &cmd, data_buf, nsect);
-        memcpy(req_task->hob_ports, &cmd.tf_array[0],
+        memcpy(req_task->hob_ports, &cmd.hob, HDIO_DRIVE_HOB_HDR_SIZE - 2);
-               HDIO_DRIVE_HOB_HDR_SIZE - 2);
+        memcpy(req_task->io_ports,  &cmd.tf,  HDIO_DRIVE_TASK_HDR_SIZE);
-        memcpy(req_task->io_ports, &cmd.tf_array[6],
-               HDIO_DRIVE_TASK_HDR_SIZE);
        if ((cmd.ftf_flags & IDE_FTFLAG_SET_IN_FLAGS) &&
            req_task->in_flags.all == 0) {
diff --git a/drivers/ide/ns87415.c b/drivers/ide/ns87415.c
index 71a39fb3856f..95327a2c2422 100644
--- a/drivers/ide/ns87415.c
+++ b/drivers/ide/ns87415.c
@@ -61,41 +61,23 @@ static u8 superio_dma_sff_read_status(ide_hwif_t *hwif)
        return superio_ide_inb(hwif->dma_base + ATA_DMA_STATUS);
 }
-static void superio_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
+static void superio_tf_read(ide_drive_t *drive, struct ide_taskfile *tf,
+                            u8 valid)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
+        if (valid & IDE_VALID_ERROR)
-        outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
                tf->error  = inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
+        if (valid & IDE_VALID_NSECT)
                tf->nsect  = inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
+        if (valid & IDE_VALID_LBAL)
                tf->lbal   = inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
+        if (valid & IDE_VALID_LBAM)
                tf->lbam   = inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
+        if (valid & IDE_VALID_LBAH)
                tf->lbah   = inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
+        if (valid & IDE_VALID_DEVICE)
                tf->device = superio_ide_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = inb(io_ports->lbah_addr);
-        }
 }
 static void ns87415_dev_select(ide_drive_t *drive);
diff --git a/drivers/ide/q40ide.c b/drivers/ide/q40ide.c
index d007e7f66598..c79346679244 100644
--- a/drivers/ide/q40ide.c
+++ b/drivers/ide/q40ide.c
@@ -16,6 +16,8 @@
 #include <linux/blkdev.h>
 #include <linux/ide.h>
+#include <asm/ide.h>
    /*
     *  Bases of the IDE interfaces
     */
@@ -77,8 +79,10 @@ static void q40ide_input_data(ide_drive_t *drive, struct ide_cmd *cmd,
 {
        unsigned long data_addr = drive->hwif->io_ports.data_addr;
-        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS))
+        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS)) {
-                return insw(data_addr, buf, (len + 1) / 2);
+                __ide_mm_insw(data_addr, buf, (len + 1) / 2);
+                return;
+        }
        raw_insw_swapw((u16 *)data_addr, buf, (len + 1) / 2);
 }
@@ -88,8 +92,10 @@ static void q40ide_output_data(ide_drive_t *drive, struct ide_cmd *cmd,
 {
        unsigned long data_addr = drive->hwif->io_ports.data_addr;
-        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS))
+        if (drive->media == ide_disk && cmd && (cmd->tf_flags & IDE_TFLAG_FS)) {
-                return outsw(data_addr, buf, (len + 1) / 2);
+                __ide_mm_outsw(data_addr, buf, (len + 1) / 2);
+                return;
+        }
        raw_outsw_swapw((u16 *)data_addr, buf, (len + 1) / 2);
 }
diff --git a/drivers/ide/scc_pata.c b/drivers/ide/scc_pata.c
index 6d8dbd9c10bc..5be41f25204f 100644
--- a/drivers/ide/scc_pata.c
+++ b/drivers/ide/scc_pata.c
@@ -337,7 +337,6 @@ static void scc_dma_start(ide_drive_t *drive)
        /* start DMA */
        scc_ide_outb(dma_cmd | 1, hwif->dma_base);
-        wmb();
 }
 static int __scc_dma_end(ide_drive_t *drive)
@@ -354,7 +353,6 @@ static int __scc_dma_end(ide_drive_t *drive)
        /* clear the INTR & ERROR bits */
        scc_ide_outb(dma_stat | 6, hwif->dma_base + 4);
        /* verify good DMA status */
-        wmb();
        return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0;
 }
@@ -647,77 +645,40 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
        return rc;
 }
-static void scc_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
+static void scc_tf_load(ide_drive_t *drive, struct ide_taskfile *tf, u8 valid)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;
+        if (valid & IDE_VALID_FEATURE)
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                scc_ide_outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                scc_ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                scc_ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                scc_ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                scc_ide_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
                scc_ide_outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
+        if (valid & IDE_VALID_NSECT)
                scc_ide_outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
+        if (valid & IDE_VALID_LBAL)
                scc_ide_outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
+        if (valid & IDE_VALID_LBAM)
                scc_ide_outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
+        if (valid & IDE_VALID_LBAH)
                scc_ide_outb(tf->lbah, io_ports->lbah_addr);
+        if (valid & IDE_VALID_DEVICE)
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
+                scc_ide_outb(tf->device, io_ports->device_addr);
-                scc_ide_outb((tf->device & HIHI) | drive->select,
-                             io_ports->device_addr);
 }
-static void scc_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
+static void scc_tf_read(ide_drive_t *drive, struct ide_taskfile *tf, u8 valid)
 {
        struct ide_io_ports *io_ports = &drive->hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
-        scc_ide_outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
+        if (valid & IDE_VALID_ERROR)
                tf->error  = scc_ide_inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
+        if (valid & IDE_VALID_NSECT)
                tf->nsect  = scc_ide_inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
+        if (valid & IDE_VALID_LBAL)
                tf->lbal   = scc_ide_inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
+        if (valid & IDE_VALID_LBAM)
                tf->lbam   = scc_ide_inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
+        if (valid & IDE_VALID_LBAH)
                tf->lbah   = scc_ide_inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
+        if (valid & IDE_VALID_DEVICE)
                tf->device = scc_ide_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                scc_ide_outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = scc_ide_inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = scc_ide_inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = scc_ide_inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = scc_ide_inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = scc_ide_inb(io_ports->lbah_addr);
-        }
 }
 static void scc_input_data(ide_drive_t *drive, struct ide_cmd *cmd,
diff --git a/drivers/ide/tx4938ide.c b/drivers/ide/tx4938ide.c
index 4cb79c4c2604..e33d764e2945 100644
--- a/drivers/ide/tx4938ide.c
+++ b/drivers/ide/tx4938ide.c
@@ -72,91 +72,6 @@ static void tx4938ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
 #ifdef __BIG_ENDIAN
 /* custom iops (independent from SWAP_IO_SPACE) */
-static u8 tx4938ide_inb(unsigned long port)
-{
-        return __raw_readb((void __iomem *)port);
-}
-static void tx4938ide_outb(u8 value, unsigned long port)
-{
-        __raw_writeb(value, (void __iomem *)port);
-}
-static void tx4938ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        u8 HIHI = cmd->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                tx4938ide_outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                tx4938ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                tx4938ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                tx4938ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                tx4938ide_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                tx4938ide_outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
-                tx4938ide_outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
-                tx4938ide_outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
-                tx4938ide_outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
-                tx4938ide_outb(tf->lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                tx4938ide_outb((tf->device & HIHI) | drive->select,
-                               io_ports->device_addr);
-}
-static void tx4938ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
-        tx4938ide_outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
-                tf->error  = tx4938ide_inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = tx4938ide_inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = tx4938ide_inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = tx4938ide_inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = tx4938ide_inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = tx4938ide_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                tx4938ide_outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = tx4938ide_inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = tx4938ide_inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = tx4938ide_inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = tx4938ide_inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = tx4938ide_inb(io_ports->lbah_addr);
-        }
-}
 static void tx4938ide_input_data_swap(ide_drive_t *drive, struct ide_cmd *cmd,
                                void *buf, unsigned int len)
 {
@@ -190,8 +105,8 @@ static const struct ide_tp_ops tx4938ide_tp_ops = {
        .write_devctl           = ide_write_devctl,
        .dev_select             = ide_dev_select,
-        .tf_load                = tx4938ide_tf_load,
+        .tf_load                = ide_tf_load,
-        .tf_read                = tx4938ide_tf_read,
+        .tf_read                = ide_tf_read,
        .input_data             = tx4938ide_input_data_swap,
        .output_data            = tx4938ide_output_data_swap,
diff --git a/drivers/ide/tx4939ide.c b/drivers/ide/tx4939ide.c
index 0040a9a3e26e..564422d23976 100644
--- a/drivers/ide/tx4939ide.c
+++ b/drivers/ide/tx4939ide.c
@@ -327,15 +327,15 @@ static int tx4939ide_dma_end(ide_drive_t *drive)
        /* read and clear the INTR & ERROR bits */
        dma_stat = tx4939ide_clear_dma_status(base);
-        wmb();
+#define CHECK_DMA_MASK (ATA_DMA_ACTIVE | ATA_DMA_ERR | ATA_DMA_INTR)
        /* verify good DMA status */
-        if ((dma_stat & (ATA_DMA_INTR | ATA_DMA_ERR | ATA_DMA_ACTIVE)) == 0 &&
+        if ((dma_stat & CHECK_DMA_MASK) == 0 &&
            (ctl & (TX4939IDE_INT_XFEREND | TX4939IDE_INT_HOST)) ==
            (TX4939IDE_INT_XFEREND | TX4939IDE_INT_HOST))
                /* INT_IDE lost... bug? */
                return 0;
-        return ((dma_stat & (ATA_DMA_INTR | ATA_DMA_ERR | ATA_DMA_ACTIVE)) !=
+        return ((dma_stat & CHECK_DMA_MASK) !=
                ATA_DMA_INTR) ? 0x10 | dma_stat : 0;
 }
@@ -434,97 +434,19 @@ static void tx4939ide_tf_load_fixup(ide_drive_t *drive)
        tx4939ide_writew(sysctl, base, TX4939IDE_Sys_Ctl);
 }
-#ifdef __BIG_ENDIAN
+static void tx4939ide_tf_load(ide_drive_t *drive, struct ide_taskfile *tf,
+                              u8 valid)
-/* custom iops (independent from SWAP_IO_SPACE) */
-static u8 tx4939ide_inb(unsigned long port)
 {
-        return __raw_readb((void __iomem *)port);
+        ide_tf_load(drive, tf, valid);
-}
-static void tx4939ide_outb(u8 value, unsigned long port)
+        if (valid & IDE_VALID_DEVICE)
-{
-        __raw_writeb(value, (void __iomem *)port);
-}
-static void tx4939ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        u8 HIHI = cmd->tf_flags & IDE_TFLAG_LBA48 ? 0xE0 : 0xEF;
-        if (cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
-                HIHI = 0xFF;
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
-                tx4939ide_outb(tf->hob_feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
-                tx4939ide_outb(tf->hob_nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
-                tx4939ide_outb(tf->hob_lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
-                tx4939ide_outb(tf->hob_lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
-                tx4939ide_outb(tf->hob_lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)
-                tx4939ide_outb(tf->feature, io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)
-                tx4939ide_outb(tf->nsect, io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)
-                tx4939ide_outb(tf->lbal, io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)
-                tx4939ide_outb(tf->lbam, io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)
-                tx4939ide_outb(tf->lbah, io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE) {
-                tx4939ide_outb((tf->device & HIHI) | drive->select,
-                               io_ports->device_addr);
                tx4939ide_tf_load_fixup(drive);
-        }
 }
-static void tx4939ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
+#ifdef __BIG_ENDIAN
-{
-        ide_hwif_t *hwif = drive->hwif;
-        struct ide_io_ports *io_ports = &hwif->io_ports;
-        struct ide_taskfile *tf = &cmd->tf;
-        /* be sure we're looking at the low order bits */
-        tx4939ide_outb(ATA_DEVCTL_OBS, io_ports->ctl_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_ERROR)
-                tf->error  = tx4939ide_inb(io_ports->feature_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)
-                tf->nsect  = tx4939ide_inb(io_ports->nsect_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)
-                tf->lbal   = tx4939ide_inb(io_ports->lbal_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)
-                tf->lbam   = tx4939ide_inb(io_ports->lbam_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)
-                tf->lbah   = tx4939ide_inb(io_ports->lbah_addr);
-        if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)
-                tf->device = tx4939ide_inb(io_ports->device_addr);
-        if (cmd->tf_flags & IDE_TFLAG_LBA48) {
-                tx4939ide_outb(ATA_HOB | ATA_DEVCTL_OBS, io_ports->ctl_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_ERROR)
-                        tf->hob_error = tx4939ide_inb(io_ports->feature_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
-                        tf->hob_nsect = tx4939ide_inb(io_ports->nsect_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
-                        tf->hob_lbal  = tx4939ide_inb(io_ports->lbal_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
-                        tf->hob_lbam  = tx4939ide_inb(io_ports->lbam_addr);
-                if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
-                        tf->hob_lbah  = tx4939ide_inb(io_ports->lbah_addr);
-        }
-}
-static void tx4939ide_input_data_swap(ide_drive_t *drive, struct request *rq,
+/* custom iops (independent from SWAP_IO_SPACE) */
+static void tx4939ide_input_data_swap(ide_drive_t *drive, struct ide_cmd *cmd,
                                void *buf, unsigned int len)
 {
        unsigned long port = drive->hwif->io_ports.data_addr;
@@ -536,7 +458,7 @@ static void tx4939ide_input_data_swap(ide_drive_t *drive, struct request *rq,
        __ide_flush_dcache_range((unsigned long)buf, roundup(len, 2));
 }
-static void tx4939ide_output_data_swap(ide_drive_t *drive, struct request *rq,
+static void tx4939ide_output_data_swap(ide_drive_t *drive, struct ide_cmd *cmd,
                                void *buf, unsigned int len)
 {
        unsigned long port = drive->hwif->io_ports.data_addr;
@@ -558,7 +480,7 @@ static const struct ide_tp_ops tx4939ide_tp_ops = {
        .dev_select             = ide_dev_select,
        .tf_load                = tx4939ide_tf_load,
-        .tf_read                = tx4939ide_tf_read,
+        .tf_read                = ide_tf_read,
        .input_data             = tx4939ide_input_data_swap,
        .output_data            = tx4939ide_output_data_swap,
@@ -566,14 +488,6 @@ static const struct ide_tp_ops tx4939ide_tp_ops = {
 #else   /* __LITTLE_ENDIAN */
-static void tx4939ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
-{
-        ide_tf_load(drive, cmd);
-        if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                tx4939ide_tf_load_fixup(drive);
-}
 static const struct ide_tp_ops tx4939ide_tp_ops = {
        .exec_command           = ide_exec_command,
        .read_status            = ide_read_status,
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index 2a2e50871b40..851de83ff455 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -297,21 +297,25 @@ static void cma_detach_from_dev(struct rdma_id_private *id_priv)
        id_priv->cma_dev = NULL;
 }
-static int cma_set_qkey(struct ib_device *device, u8 port_num,
+static int cma_set_qkey(struct rdma_id_private *id_priv)
-                        enum rdma_port_space ps,
-                        struct rdma_dev_addr *dev_addr, u32 *qkey)
 {
        struct ib_sa_mcmember_rec rec;
        int ret = 0;
-        switch (ps) {
+        if (id_priv->qkey)
+                return 0;
+        switch (id_priv->id.ps) {
        case RDMA_PS_UDP:
-                *qkey = RDMA_UDP_QKEY;
+                id_priv->qkey = RDMA_UDP_QKEY;
                break;
        case RDMA_PS_IPOIB:
-                ib_addr_get_mgid(dev_addr, &rec.mgid);
+                ib_addr_get_mgid(&id_priv->id.route.addr.dev_addr, &rec.mgid);
-                ret = ib_sa_get_mcmember_rec(device, port_num, &rec.mgid, &rec);
+                ret = ib_sa_get_mcmember_rec(id_priv->id.device,
-                *qkey = be32_to_cpu(rec.qkey);
+                                             id_priv->id.port_num, &rec.mgid,
+                                             &rec);
+                if (!ret)
+                        id_priv->qkey = be32_to_cpu(rec.qkey);
                break;
        default:
                break;
@@ -341,12 +345,7 @@ static int cma_acquire_dev(struct rdma_id_private *id_priv)
                ret = ib_find_cached_gid(cma_dev->device, &gid,
                                         &id_priv->id.port_num, NULL);
                if (!ret) {
-                        ret = cma_set_qkey(cma_dev->device,
+                        cma_attach_to_dev(id_priv, cma_dev);
-                                           id_priv->id.port_num,
-                                           id_priv->id.ps, dev_addr,
-                                           &id_priv->qkey);
-                        if (!ret)
-                                cma_attach_to_dev(id_priv, cma_dev);
                        break;
                }
        }
@@ -578,6 +577,10 @@ static int cma_ib_init_qp_attr(struct rdma_id_private *id_priv,
        *qp_attr_mask = IB_QP_STATE | IB_QP_PKEY_INDEX | IB_QP_PORT;
        if (cma_is_ud_ps(id_priv->id.ps)) {
+                ret = cma_set_qkey(id_priv);
+                if (ret)
+                        return ret;
                qp_attr->qkey = id_priv->qkey;
                *qp_attr_mask |= IB_QP_QKEY;
        } else {
@@ -2201,6 +2204,12 @@ static int cma_sidr_rep_handler(struct ib_cm_id *cm_id,
                        event.status = ib_event->param.sidr_rep_rcvd.status;
                        break;
                }
+                ret = cma_set_qkey(id_priv);
+                if (ret) {
+                        event.event = RDMA_CM_EVENT_ADDR_ERROR;
+                        event.status = -EINVAL;
+                        break;
+                }
                if (id_priv->qkey != rep->qkey) {
                        event.event = RDMA_CM_EVENT_UNREACHABLE;
                        event.status = -EINVAL;
@@ -2480,10 +2489,14 @@ static int cma_send_sidr_rep(struct rdma_id_private *id_priv,
                             const void *private_data, int private_data_len)
 {
        struct ib_cm_sidr_rep_param rep;
+        int ret;
        memset(&rep, 0, sizeof rep);
        rep.status = status;
        if (status == IB_SIDR_SUCCESS) {
+                ret = cma_set_qkey(id_priv);
+                if (ret)
+                        return ret;
                rep.qp_num = id_priv->qp_num;
                rep.qkey = id_priv->qkey;
        }
@@ -2713,6 +2726,10 @@ static int cma_join_ib_multicast(struct rdma_id_private *id_priv,
                    IB_SA_MCMEMBER_REC_FLOW_LABEL |
                    IB_SA_MCMEMBER_REC_TRAFFIC_CLASS;
+        if (id_priv->id.ps == RDMA_PS_IPOIB)
+                comp_mask |= IB_SA_MCMEMBER_REC_RATE |
+                             IB_SA_MCMEMBER_REC_RATE_SELECTOR;
        mc->multicast.ib = ib_sa_join_multicast(&sa_client, id_priv->id.device,
                                                id_priv->id.port_num, &rec,
                                                comp_mask, GFP_KERNEL,
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw/cxgb3/cxio_hal.c
index a4a82bff7100..8d71086f5a1c 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c
@@ -152,7 +152,7 @@ static int cxio_hal_clear_qp_ctx(struct cxio_rdev *rdev_p, u32 qpid)
        sge_cmd = qpid << 8 | 3;
        wqe->sge_cmd = cpu_to_be64(sge_cmd);
        skb->priority = CPL_PRIORITY_CONTROL;
-        return (cxgb3_ofld_send(rdev_p->t3cdev_p, skb));
+        return iwch_cxgb3_ofld_send(rdev_p->t3cdev_p, skb);
 }
 int cxio_create_cq(struct cxio_rdev *rdev_p, struct t3_cq *cq)
@@ -571,7 +571,7 @@ static int cxio_hal_init_ctrl_qp(struct cxio_rdev *rdev_p)
             (unsigned long long) rdev_p->ctrl_qp.dma_addr,
             rdev_p->ctrl_qp.workq, 1 << T3_CTRL_QP_SIZE_LOG2);
        skb->priority = CPL_PRIORITY_CONTROL;
-        return (cxgb3_ofld_send(rdev_p->t3cdev_p, skb));
+        return iwch_cxgb3_ofld_send(rdev_p->t3cdev_p, skb);
 err:
        kfree_skb(skb);
        return err;
@@ -701,7 +701,7 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
        u32 stag_idx;
        u32 wptr;
-        if (rdev_p->flags)
+        if (cxio_fatal_error(rdev_p))
                return -EIO;
        stag_state = stag_state > 0;
@@ -858,7 +858,7 @@ int cxio_rdma_init(struct cxio_rdev *rdev_p, struct t3_rdma_init_attr *attr)
        wqe->qp_dma_size = cpu_to_be32(attr->qp_dma_size);
        wqe->irs = cpu_to_be32(attr->irs);
        skb->priority = 0;      /* 0=>ToeQ; 1=>CtrlQ */
-        return (cxgb3_ofld_send(rdev_p->t3cdev_p, skb));
+        return iwch_cxgb3_ofld_send(rdev_p->t3cdev_p, skb);
 }
 void cxio_register_ev_cb(cxio_hal_ev_callback_func_t ev_cb)
@@ -1041,9 +1041,9 @@ void cxio_rdev_close(struct cxio_rdev *rdev_p)
                cxio_hal_pblpool_destroy(rdev_p);
                cxio_hal_rqtpool_destroy(rdev_p);
                list_del(&rdev_p->entry);
-                rdev_p->t3cdev_p->ulp = NULL;
                cxio_hal_destroy_ctrl_qp(rdev_p);
                cxio_hal_destroy_resource(rdev_p->rscp);
+                rdev_p->t3cdev_p->ulp = NULL;
        }
 }
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.h b/drivers/infiniband/hw/cxgb3/cxio_hal.h
index 094a66d1480c..bfd03bf8be54 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.h
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.h
@@ -115,6 +115,11 @@ struct cxio_rdev {
 #define CXIO_ERROR_FATAL        1
 };
+static inline int cxio_fatal_error(struct cxio_rdev *rdev_p)
+{
+        return rdev_p->flags & CXIO_ERROR_FATAL;
+}
 static inline int cxio_num_stags(struct cxio_rdev *rdev_p)
 {
        return min((int)T3_MAX_NUM_STAG, (int)((rdev_p->rnic_info.tpt_top - rdev_p->rnic_info.tpt_base) >> 5));
@@ -188,6 +193,7 @@ void cxio_count_scqes(struct t3_cq *cq, struct t3_wq *wq, int *count);
 void cxio_flush_hw_cq(struct t3_cq *cq);
 int cxio_poll_cq(struct t3_wq *wq, struct t3_cq *cq, struct t3_cqe *cqe,
                     u8 *cqe_flushed, u64 *cookie, u32 *credit);
+int iwch_cxgb3_ofld_send(struct t3cdev *tdev, struct sk_buff *skb);
 #define MOD "iw_cxgb3: "
 #define PDBG(fmt, args...) pr_debug(MOD fmt, ## args)
diff --git a/drivers/infiniband/hw/cxgb3/iwch.c b/drivers/infiniband/hw/cxgb3/iwch.c
index 37a4fc264a07..26fc0a4eaa74 100644
--- a/drivers/infiniband/hw/cxgb3/iwch.c
+++ b/drivers/infiniband/hw/cxgb3/iwch.c
@@ -165,12 +165,19 @@ static void close_rnic_dev(struct t3cdev *tdev)
 static void iwch_err_handler(struct t3cdev *tdev, u32 status, u32 error)
 {
        struct cxio_rdev *rdev = tdev->ulp;
+        struct iwch_dev *rnicp = rdev_to_iwch_dev(rdev);
+        struct ib_event event;
-        if (status == OFFLOAD_STATUS_DOWN)
+        if (status == OFFLOAD_STATUS_DOWN) {
                rdev->flags = CXIO_ERROR_FATAL;
-        return;
+                event.device = &rnicp->ibdev;
+                event.event  = IB_EVENT_DEVICE_FATAL;
+                event.element.port_num = 0;
+                ib_dispatch_event(&event);
+        }
+        return;
 }
 static int __init iwch_init_module(void)
diff --git a/drivers/infiniband/hw/cxgb3/iwch.h b/drivers/infiniband/hw/cxgb3/iwch.h
index 3773453b2cf0..84735506333f 100644
--- a/drivers/infiniband/hw/cxgb3/iwch.h
+++ b/drivers/infiniband/hw/cxgb3/iwch.h
@@ -117,6 +117,11 @@ static inline struct iwch_dev *to_iwch_dev(struct ib_device *ibdev)
        return container_of(ibdev, struct iwch_dev, ibdev);
 }
+static inline struct iwch_dev *rdev_to_iwch_dev(struct cxio_rdev *rdev)
+{
+        return container_of(rdev, struct iwch_dev, rdev);
+}
 static inline int t3b_device(const struct iwch_dev *rhp)
 {
        return rhp->rdev.t3cdev_p->type == T3B;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c
index 8699947aaf6c..fef3f1ae7225 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c
@@ -139,6 +139,38 @@ static void stop_ep_timer(struct iwch_ep *ep)
        put_ep(&ep->com);
 }
+int iwch_l2t_send(struct t3cdev *tdev, struct sk_buff *skb, struct l2t_entry *l2e)
+{
+        int     error = 0;
+        struct cxio_rdev *rdev;
+        rdev = (struct cxio_rdev *)tdev->ulp;
+        if (cxio_fatal_error(rdev)) {
+                kfree_skb(skb);
+                return -EIO;
+        }
+        error = l2t_send(tdev, skb, l2e);
+        if (error)
+                kfree_skb(skb);
+        return error;
+}
+int iwch_cxgb3_ofld_send(struct t3cdev *tdev, struct sk_buff *skb)
+{
+        int     error = 0;
+        struct cxio_rdev *rdev;
+        rdev = (struct cxio_rdev *)tdev->ulp;
+        if (cxio_fatal_error(rdev)) {
+                kfree_skb(skb);
+                return -EIO;
+        }
+        error = cxgb3_ofld_send(tdev, skb);
+        if (error)
+                kfree_skb(skb);
+        return error;
+}
 static void release_tid(struct t3cdev *tdev, u32 hwtid, struct sk_buff *skb)
 {
        struct cpl_tid_release *req;
@@ -150,7 +182,7 @@ static void release_tid(struct t3cdev *tdev, u32 hwtid, struct sk_buff *skb)
        req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_TID_RELEASE, hwtid));
        skb->priority = CPL_PRIORITY_SETUP;
-        cxgb3_ofld_send(tdev, skb);
+        iwch_cxgb3_ofld_send(tdev, skb);
        return;
 }
@@ -172,8 +204,7 @@ int iwch_quiesce_tid(struct iwch_ep *ep)
        req->val = cpu_to_be64(1 << S_TCB_RX_QUIESCE);
        skb->priority = CPL_PRIORITY_DATA;
-        cxgb3_ofld_send(ep->com.tdev, skb);
+        return iwch_cxgb3_ofld_send(ep->com.tdev, skb);
-        return 0;
 }
 int iwch_resume_tid(struct iwch_ep *ep)
@@ -194,8 +225,7 @@ int iwch_resume_tid(struct iwch_ep *ep)
        req->val = 0;
        skb->priority = CPL_PRIORITY_DATA;
-        cxgb3_ofld_send(ep->com.tdev, skb);
+        return iwch_cxgb3_ofld_send(ep->com.tdev, skb);
-        return 0;
 }
 static void set_emss(struct iwch_ep *ep, u16 opt)
@@ -252,18 +282,22 @@ static void *alloc_ep(int size, gfp_t gfp)
 void __free_ep(struct kref *kref)
 {
-        struct iwch_ep_common *epc;
+        struct iwch_ep *ep;
-        epc = container_of(kref, struct iwch_ep_common, kref);
+        ep = container_of(container_of(kref, struct iwch_ep_common, kref),
-        PDBG("%s ep %p state %s\n", __func__, epc, states[state_read(epc)]);
+                          struct iwch_ep, com);
-        kfree(epc);
+        PDBG("%s ep %p state %s\n", __func__, ep, states[state_read(&ep->com)]);
+        if (ep->com.flags & RELEASE_RESOURCES) {
+                cxgb3_remove_tid(ep->com.tdev, (void *)ep, ep->hwtid);
+                dst_release(ep->dst);
+                l2t_release(L2DATA(ep->com.tdev), ep->l2t);
+        }
+        kfree(ep);
 }
 static void release_ep_resources(struct iwch_ep *ep)
 {
        PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
-        cxgb3_remove_tid(ep->com.tdev, (void *)ep, ep->hwtid);
+        ep->com.flags |= RELEASE_RESOURCES;
-        dst_release(ep->dst);
-        l2t_release(L2DATA(ep->com.tdev), ep->l2t);
        put_ep(&ep->com);
 }
@@ -382,7 +416,7 @@ static void abort_arp_failure(struct t3cdev *dev, struct sk_buff *skb)
        PDBG("%s t3cdev %p\n", __func__, dev);
        req->cmd = CPL_ABORT_NO_RST;
-        cxgb3_ofld_send(dev, skb);
+        iwch_cxgb3_ofld_send(dev, skb);
 }
 static int send_halfclose(struct iwch_ep *ep, gfp_t gfp)
@@ -402,8 +436,7 @@ static int send_halfclose(struct iwch_ep *ep, gfp_t gfp)
        req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_CLOSE_CON));
        req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, ep->hwtid));
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        return iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
-        return 0;
 }
 static int send_abort(struct iwch_ep *ep, struct sk_buff *skb, gfp_t gfp)
@@ -424,8 +457,7 @@ static int send_abort(struct iwch_ep *ep, struct sk_buff *skb, gfp_t gfp)
        req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid));
        req->cmd = CPL_ABORT_SEND_RST;
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        return iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
-        return 0;
 }
 static int send_connect(struct iwch_ep *ep)
@@ -469,8 +501,7 @@ static int send_connect(struct iwch_ep *ep)
        req->opt0l = htonl(opt0l);
        req->params = 0;
        req->opt2 = htonl(opt2);
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        return iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
-        return 0;
 }
 static void send_mpa_req(struct iwch_ep *ep, struct sk_buff *skb)
@@ -527,7 +558,7 @@ static void send_mpa_req(struct iwch_ep *ep, struct sk_buff *skb)
        req->sndseq = htonl(ep->snd_seq);
        BUG_ON(ep->mpa_skb);
        ep->mpa_skb = skb;
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
        start_ep_timer(ep);
        state_set(&ep->com, MPA_REQ_SENT);
        return;
@@ -578,8 +609,7 @@ static int send_mpa_reject(struct iwch_ep *ep, const void *pdata, u8 plen)
        req->sndseq = htonl(ep->snd_seq);
        BUG_ON(ep->mpa_skb);
        ep->mpa_skb = skb;
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        return iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
-        return 0;
 }
 static int send_mpa_reply(struct iwch_ep *ep, const void *pdata, u8 plen)
@@ -630,8 +660,7 @@ static int send_mpa_reply(struct iwch_ep *ep, const void *pdata, u8 plen)
        req->sndseq = htonl(ep->snd_seq);
        ep->mpa_skb = skb;
        state_set(&ep->com, MPA_REP_SENT);
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        return iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
-        return 0;
 }
 static int act_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
@@ -795,7 +824,7 @@ static int update_rx_credits(struct iwch_ep *ep, u32 credits)
        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_RX_DATA_ACK, ep->hwtid));
        req->credit_dack = htonl(V_RX_CREDITS(credits) | V_RX_FORCE_ACK(1));
        skb->priority = CPL_PRIORITY_ACK;
-        cxgb3_ofld_send(ep->com.tdev, skb);
+        iwch_cxgb3_ofld_send(ep->com.tdev, skb);
        return credits;
 }
@@ -1127,8 +1156,8 @@ static int abort_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         * We get 2 abort replies from the HW.  The first one must
         * be ignored except for scribbling that we need one more.
         */
-        if (!(ep->flags & ABORT_REQ_IN_PROGRESS)) {
+        if (!(ep->com.flags & ABORT_REQ_IN_PROGRESS)) {
-                ep->flags |= ABORT_REQ_IN_PROGRESS;
+                ep->com.flags |= ABORT_REQ_IN_PROGRESS;
                return CPL_RET_BUF_DONE;
        }
@@ -1203,8 +1232,7 @@ static int listen_start(struct iwch_listen_ep *ep)
        req->opt1 = htonl(V_CONN_POLICY(CPL_CONN_POLICY_ASK));
        skb->priority = 1;
-        cxgb3_ofld_send(ep->com.tdev, skb);
+        return iwch_cxgb3_ofld_send(ep->com.tdev, skb);
-        return 0;
 }
 static int pass_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
@@ -1237,8 +1265,7 @@ static int listen_stop(struct iwch_listen_ep *ep)
        req->cpu_idx = 0;
        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_LISTSRV_REQ, ep->stid));
        skb->priority = 1;
-        cxgb3_ofld_send(ep->com.tdev, skb);
+        return iwch_cxgb3_ofld_send(ep->com.tdev, skb);
-        return 0;
 }
 static int close_listsrv_rpl(struct t3cdev *tdev, struct sk_buff *skb,
@@ -1286,7 +1313,7 @@ static void accept_cr(struct iwch_ep *ep, __be32 peer_ip, struct sk_buff *skb)
        rpl->opt2 = htonl(opt2);
        rpl->rsvd = rpl->opt2;  /* workaround for HW bug */
        skb->priority = CPL_PRIORITY_SETUP;
-        l2t_send(ep->com.tdev, skb, ep->l2t);
+        iwch_l2t_send(ep->com.tdev, skb, ep->l2t);
        return;
 }
@@ -1315,7 +1342,7 @@ static void reject_cr(struct t3cdev *tdev, u32 hwtid, __be32 peer_ip,
                rpl->opt0l_status = htonl(CPL_PASS_OPEN_REJECT);
                rpl->opt2 = 0;
                rpl->rsvd = rpl->opt2;
-                cxgb3_ofld_send(tdev, skb);
+                iwch_cxgb3_ofld_send(tdev, skb);
        }
 }
@@ -1534,8 +1561,8 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         * We get 2 peer aborts from the HW.  The first one must
         * be ignored except for scribbling that we need one more.
         */
-        if (!(ep->flags & PEER_ABORT_IN_PROGRESS)) {
+        if (!(ep->com.flags & PEER_ABORT_IN_PROGRESS)) {
-                ep->flags |= PEER_ABORT_IN_PROGRESS;
+                ep->com.flags |= PEER_ABORT_IN_PROGRESS;
                return CPL_RET_BUF_DONE;
        }
@@ -1613,7 +1640,7 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        rpl->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
        OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid));
        rpl->cmd = CPL_ABORT_NO_RST;
-        cxgb3_ofld_send(ep->com.tdev, rpl_skb);
+        iwch_cxgb3_ofld_send(ep->com.tdev, rpl_skb);
 out:
        if (release)
                release_ep_resources(ep);
@@ -2017,8 +2044,11 @@ int iwch_destroy_listen(struct iw_cm_id *cm_id)
        ep->com.rpl_done = 0;
        ep->com.rpl_err = 0;
        err = listen_stop(ep);
+        if (err)
+                goto done;
        wait_event(ep->com.waitq, ep->com.rpl_done);
        cxgb3_free_stid(ep->com.tdev, ep->stid);
+done:
        err = ep->com.rpl_err;
        cm_id->rem_ref(cm_id);
        put_ep(&ep->com);
@@ -2030,12 +2060,22 @@ int iwch_ep_disconnect(struct iwch_ep *ep, int abrupt, gfp_t gfp)
        int ret=0;
        unsigned long flags;
        int close = 0;
+        int fatal = 0;
+        struct t3cdev *tdev;
+        struct cxio_rdev *rdev;
        spin_lock_irqsave(&ep->com.lock, flags);
        PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
             states[ep->com.state], abrupt);
+        tdev = (struct t3cdev *)ep->com.tdev;
+        rdev = (struct cxio_rdev *)tdev->ulp;
+        if (cxio_fatal_error(rdev)) {
+                fatal = 1;
+                close_complete_upcall(ep);
+                ep->com.state = DEAD;
+        }
        switch (ep->com.state) {
        case MPA_REQ_WAIT:
        case MPA_REQ_SENT:
@@ -2075,7 +2115,11 @@ int iwch_ep_disconnect(struct iwch_ep *ep, int abrupt, gfp_t gfp)
                        ret = send_abort(ep, NULL, gfp);
                else
                        ret = send_halfclose(ep, gfp);
+                if (ret)
+                        fatal = 1;
        }
+        if (fatal)
+                release_ep_resources(ep);
        return ret;
 }
diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.h b/drivers/infiniband/hw/cxgb3/iwch_cm.h
index d7c7e09f0996..43c0aea7eadc 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.h
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.h
@@ -147,6 +147,7 @@ enum iwch_ep_state {
 enum iwch_ep_flags {
        PEER_ABORT_IN_PROGRESS  = (1 << 0),
        ABORT_REQ_IN_PROGRESS   = (1 << 1),
+        RELEASE_RESOURCES       = (1 << 2),
 };
 struct iwch_ep_common {
@@ -161,6 +162,7 @@ struct iwch_ep_common {
        wait_queue_head_t waitq;
        int rpl_done;
        int rpl_err;
+        u32 flags;
 };
 struct iwch_listen_ep {
@@ -188,7 +190,6 @@ struct iwch_ep {
        u16 plen;
        u32 ird;
        u32 ord;
-        u32 flags;
 };
 static inline struct iwch_ep *to_ep(struct iw_cm_id *cm_id)
diff --git a/drivers/infiniband/hw/cxgb3/iwch_qp.c b/drivers/infiniband/hw/cxgb3/iwch_qp.c
index c758fbd58478..2f546a625330 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_qp.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_qp.c
@@ -751,7 +751,7 @@ int iwch_post_zb_read(struct iwch_qp *qhp)
        wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(qhp->ep->hwtid)|
                                                V_FW_RIWR_LEN(flit_cnt));
        skb->priority = CPL_PRIORITY_DATA;
-        return cxgb3_ofld_send(qhp->rhp->rdev.t3cdev_p, skb);
+        return iwch_cxgb3_ofld_send(qhp->rhp->rdev.t3cdev_p, skb);
 }
 /*
@@ -783,7 +783,7 @@ int iwch_post_terminate(struct iwch_qp *qhp, struct respQ_msg_t *rsp_msg)
                         V_FW_RIWR_FLAGS(T3_COMPLETION_FLAG | T3_NOTIFY_FLAG));
        wqe->send.wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(qhp->ep->hwtid));
        skb->priority = CPL_PRIORITY_DATA;
-        return cxgb3_ofld_send(qhp->rhp->rdev.t3cdev_p, skb);
+        return iwch_cxgb3_ofld_send(qhp->rhp->rdev.t3cdev_p, skb);
 }
 /*
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 2ccb9d31771f..ae3d7590346e 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -394,8 +394,7 @@ static int mlx4_ib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
                                       PAGE_SIZE, vma->vm_page_prot))
                        return -EAGAIN;
        } else if (vma->vm_pgoff == 1 && dev->dev->caps.bf_reg_size != 0) {
-                /* FIXME want pgprot_writecombine() for BlueFlame pages */
+                vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
-                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
                if (io_remap_pfn_range(vma, vma->vm_start,
                                       to_mucontext(context)->uar.pfn +
diff --git a/drivers/infiniband/hw/nes/nes.h b/drivers/infiniband/hw/nes/nes.h
index 04b12ad23390..17621de54a9f 100644
--- a/drivers/infiniband/hw/nes/nes.h
+++ b/drivers/infiniband/hw/nes/nes.h
@@ -289,8 +289,8 @@ static inline __le32 get_crc_value(struct nes_v4_quad *nes_quad)
 static inline void
 set_wqe_64bit_value(__le32 *wqe_words, u32 index, u64 value)
 {
-        wqe_words[index]     = cpu_to_le32((u32) ((unsigned long)value));
+        wqe_words[index]     = cpu_to_le32((u32) value);
-        wqe_words[index + 1] = cpu_to_le32((u32)(upper_32_bits((unsigned long)value)));
+        wqe_words[index + 1] = cpu_to_le32(upper_32_bits(value));
 }
 static inline void
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index 52425154acd4..dbd9a75474e3 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -426,6 +426,7 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
        if (type == NES_TIMER_TYPE_CLOSE) {
                new_send->timetosend += (HZ/10);
                if (cm_node->recv_entry) {
+                        kfree(new_send);
                        WARN_ON(1);
                        return -EINVAL;
                }
@@ -445,8 +446,8 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
                if (ret != NETDEV_TX_OK) {
                        nes_debug(NES_DBG_CM, "Error sending packet %p "
                                "(jiffies = %lu)\n", new_send, jiffies);
-                        atomic_dec(&new_send->skb->users);
                        new_send->timetosend = jiffies;
+                        ret = NETDEV_TX_OK;
                } else {
                        cm_packets_sent++;
                        if (!send_retrans) {
@@ -630,7 +631,6 @@ static void nes_cm_timer_tick(unsigned long pass)
                                nes_debug(NES_DBG_CM, "rexmit failed for "
                                        "node=%p\n", cm_node);
                                cm_packets_bounced++;
-                                atomic_dec(&send_entry->skb->users);
                                send_entry->retrycount--;
                                nexttimeout = jiffies + NES_SHORT_TIME;
                                settimer = 1;
@@ -666,11 +666,6 @@ static void nes_cm_timer_tick(unsigned long pass)
                spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
                rem_ref_cm_node(cm_node->cm_core, cm_node);
-                if (ret != NETDEV_TX_OK) {
-                        nes_debug(NES_DBG_CM, "rexmit failed for cm_node=%p\n",
-                                cm_node);
-                        break;
-                }
        }
        if (settimer) {
@@ -1262,7 +1257,6 @@ static int rem_ref_cm_node(struct nes_cm_core *cm_core,
                cm_node->nesqp = NULL;
        }
-        cm_node->freed = 1;
        kfree(cm_node);
        return 0;
 }
@@ -1999,13 +1993,17 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
                if (loopbackremotelistener == NULL) {
                        create_event(cm_node, NES_CM_EVENT_ABORTED);
                } else {
-                        atomic_inc(&cm_loopbacks);
                        loopback_cm_info = *cm_info;
                        loopback_cm_info.loc_port = cm_info->rem_port;
                        loopback_cm_info.rem_port = cm_info->loc_port;
                        loopback_cm_info.cm_id = loopbackremotelistener->cm_id;
                        loopbackremotenode = make_cm_node(cm_core, nesvnic,
                                &loopback_cm_info, loopbackremotelistener);
+                        if (!loopbackremotenode) {
+                                rem_ref_cm_node(cm_node->cm_core, cm_node);
+                                return NULL;
+                        }
+                        atomic_inc(&cm_loopbacks);
                        loopbackremotenode->loopbackpartner = cm_node;
                        loopbackremotenode->tcp_cntxt.rcv_wscale =
                                NES_CM_DEFAULT_RCV_WND_SCALE;
@@ -2690,6 +2688,7 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        struct ib_mr *ibmr = NULL;
        struct ib_phys_buf ibphysbuf;
        struct nes_pd *nespd;
+        u64 tagged_offset;
@@ -2755,10 +2754,11 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                ibphysbuf.addr = nesqp->ietf_frame_pbase;
                ibphysbuf.size = conn_param->private_data_len +
                                        sizeof(struct ietf_mpa_frame);
+                tagged_offset = (u64)(unsigned long)nesqp->ietf_frame;
                ibmr = nesibdev->ibdev.reg_phys_mr((struct ib_pd *)nespd,
                                                &ibphysbuf, 1,
                                                IB_ACCESS_LOCAL_WRITE,
-                                                (u64 *)&nesqp->ietf_frame);
+                                                &tagged_offset);
                if (!ibmr) {
                        nes_debug(NES_DBG_CM, "Unable to register memory region"
                                        "for lSMM for cm_node = %p \n",
@@ -2782,7 +2782,7 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                        sizeof(struct ietf_mpa_frame));
                set_wqe_64bit_value(wqe->wqe_words,
                                        NES_IWARP_SQ_WQE_FRAG0_LOW_IDX,
-                                        (u64)nesqp->ietf_frame);
+                                        (u64)(unsigned long)nesqp->ietf_frame);
                wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] =
                        cpu_to_le32(conn_param->private_data_len +
                        sizeof(struct ietf_mpa_frame));
diff --git a/drivers/infiniband/hw/nes/nes_cm.h b/drivers/infiniband/hw/nes/nes_cm.h
index d5f778202eb7..80bba1892571 100644
--- a/drivers/infiniband/hw/nes/nes_cm.h
+++ b/drivers/infiniband/hw/nes/nes_cm.h
@@ -298,7 +298,6 @@ struct nes_cm_node {
        struct nes_vnic           *nesvnic;
        int                       apbvt_set;
        int                       accept_pend;
-        int                     freed;
        struct list_head        timer_entry;
        struct list_head        reset_entry;
        struct nes_qp           *nesqp;
diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c
index 52e734042b8e..d6fc9ae44062 100644
--- a/drivers/infiniband/hw/nes/nes_hw.c
+++ b/drivers/infiniband/hw/nes/nes_hw.c
@@ -46,6 +46,10 @@ static unsigned int nes_lro_max_aggr = NES_LRO_MAX_AGGR;
 module_param(nes_lro_max_aggr, uint, 0444);
 MODULE_PARM_DESC(nes_lro_max_aggr, "NIC LRO max packet aggregation");
+static int wide_ppm_offset;
+module_param(wide_ppm_offset, int, 0644);
+MODULE_PARM_DESC(wide_ppm_offset, "Increase CX4 interface clock ppm offset, 0=100ppm (default), 1=300ppm");
 static u32 crit_err_count;
 u32 int_mod_timer_init;
 u32 int_mod_cq_depth_256;
@@ -546,8 +550,11 @@ struct nes_adapter *nes_init_adapter(struct nes_device *nesdev, u8 hw_rev) {
                        msleep(1);
                }
                if (int_cnt > 1) {
+                        u32 sds;
                        spin_lock_irqsave(&nesadapter->phy_lock, flags);
-                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, 0x0000F088);
+                        sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
+                        sds |= 0x00000040;
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
                        mh_detected++;
                        reset_value = nes_read32(nesdev->regs+NES_SOFTWARE_RESET);
                        reset_value |= 0x0000003d;
@@ -736,39 +743,49 @@ static int nes_init_serdes(struct nes_device *nesdev, u8 hw_rev, u8 port_count,
 {
        int i;
        u32 u32temp;
-        u32 serdes_common_control;
+        u32 sds;
        if (hw_rev != NE020_REV) {
                /* init serdes 0 */
+                if (wide_ppm_offset && (nesadapter->phy_type[0] == NES_PHY_TYPE_CX4))
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL0, 0x000FFFAA);
+                else
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL0, 0x000000FF);
-                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL0, 0x000000FF);
                if (nesadapter->phy_type[0] == NES_PHY_TYPE_PUMA_1G) {
-                        serdes_common_control = nes_read_indexed(nesdev,
+                        sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0);
-                                        NES_IDX_ETH_SERDES_COMMON_CONTROL0);
+                        sds |= 0x00000100;
-                        serdes_common_control |= 0x000000100;
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0, sds);
-                        nes_write_indexed(nesdev,
-                                        NES_IDX_ETH_SERDES_COMMON_CONTROL0,
-                                        serdes_common_control);
-                } else if (!OneG_Mode) {
-                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_HIGHZ_LANE_MODE0, 0x11110000);
                }
-                if (((port_count > 1) &&
+                if (!OneG_Mode)
-                        (nesadapter->phy_type[0] != NES_PHY_TYPE_PUMA_1G)) ||
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_HIGHZ_LANE_MODE0, 0x11110000);
-                        ((port_count > 2) &&
-                        (nesadapter->phy_type[0] == NES_PHY_TYPE_PUMA_1G))) {
+                if (port_count < 2)
-                        /* init serdes 1 */
+                        return 0;
-                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000000FF);
-                        if (nesadapter->phy_type[0] == NES_PHY_TYPE_PUMA_1G) {
+                /* init serdes 1 */
-                                serdes_common_control = nes_read_indexed(nesdev,
+                switch (nesadapter->phy_type[1]) {
-                                        NES_IDX_ETH_SERDES_COMMON_CONTROL1);
+                case NES_PHY_TYPE_ARGUS:
-                                serdes_common_control |= 0x000000100;
+                case NES_PHY_TYPE_SFP_D:
-                                nes_write_indexed(nesdev,
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_EMP0, 0x00000000);
-                                        NES_IDX_ETH_SERDES_COMMON_CONTROL1,
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_EMP1, 0x00000000);
-                                        serdes_common_control);
+                        break;
-                        } else if (!OneG_Mode) {
+                case NES_PHY_TYPE_CX4:
-                                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_HIGHZ_LANE_MODE1, 0x11110000);
+                        sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
-                        }
+                        sds &= 0xFFFFFFBF;
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
+                        if (wide_ppm_offset)
+                                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000FFFAA);
+                        else
+                                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_CDR_CONTROL1, 0x000000FF);
+                        break;
+                case NES_PHY_TYPE_PUMA_1G:
+                        sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1);
+                        sds |= 0x000000100;
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL1, sds);
                }
+                if (!OneG_Mode)
+                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_HIGHZ_LANE_MODE1, 0x11110000);
        } else {
                /* init serdes 0 */
                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0, 0x00000008);
@@ -1259,203 +1276,162 @@ int nes_init_phy(struct nes_device *nesdev)
 {
        struct nes_adapter *nesadapter = nesdev->nesadapter;
        u32 counter = 0;
-        u32 sds_common_control0;
+        u32 sds;
        u32 mac_index = nesdev->mac_index;
        u32 tx_config = 0;
        u16 phy_data;
        u32 temp_phy_data = 0;
        u32 temp_phy_data2 = 0;
-        u32 i = 0;
+        u8  phy_type = nesadapter->phy_type[mac_index];
+        u8  phy_index = nesadapter->phy_index[mac_index];
        if ((nesadapter->OneG_Mode) &&
-            (nesadapter->phy_type[mac_index] != NES_PHY_TYPE_PUMA_1G)) {
+            (phy_type != NES_PHY_TYPE_PUMA_1G)) {
                nes_debug(NES_DBG_PHY, "1G PHY, mac_index = %d.\n", mac_index);
-                if (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_1G) {
+                if (phy_type == NES_PHY_TYPE_1G) {
-                        printk(PFX "%s: Programming mdc config for 1G\n", __func__);
                        tx_config = nes_read_indexed(nesdev, NES_IDX_MAC_TX_CONFIG);
                        tx_config &= 0xFFFFFFE3;
                        tx_config |= 0x04;
                        nes_write_indexed(nesdev, NES_IDX_MAC_TX_CONFIG, tx_config);
                }
-                nes_read_1G_phy_reg(nesdev, 1, nesadapter->phy_index[mac_index], &phy_data);
+                nes_read_1G_phy_reg(nesdev, 1, phy_index, &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 1 phy address %u = 0x%X.\n",
+                nes_write_1G_phy_reg(nesdev, 23, phy_index, 0xb000);
-                                nesadapter->phy_index[mac_index], phy_data);
-                nes_write_1G_phy_reg(nesdev, 23, nesadapter->phy_index[mac_index], 0xb000);
                /* Reset the PHY */
-                nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index], 0x8000);
+                nes_write_1G_phy_reg(nesdev, 0, phy_index, 0x8000);
                udelay(100);
                counter = 0;
                do {
-                        nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index], &phy_data);
+                        nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
-                        nes_debug(NES_DBG_PHY, "Phy data from register 0 = 0x%X.\n", phy_data);
+                        if (counter++ > 100)
-                        if (counter++ > 100) break;
+                                break;
                } while (phy_data & 0x8000);
                /* Setting no phy loopback */
                phy_data &= 0xbfff;
                phy_data |= 0x1140;
-                nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index],  phy_data);
+                nes_write_1G_phy_reg(nesdev, 0, phy_index,  phy_data);
-                nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index], &phy_data);
+                nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0 = 0x%X.\n", phy_data);
+                nes_read_1G_phy_reg(nesdev, 0x17, phy_index, &phy_data);
+                nes_read_1G_phy_reg(nesdev, 0x1e, phy_index, &phy_data);
-                nes_read_1G_phy_reg(nesdev, 0x17, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x17 = 0x%X.\n", phy_data);
-                nes_read_1G_phy_reg(nesdev, 0x1e, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x1e = 0x%X.\n", phy_data);
                /* Setting the interrupt mask */
-                nes_read_1G_phy_reg(nesdev, 0x19, nesadapter->phy_index[mac_index], &phy_data);
+                nes_read_1G_phy_reg(nesdev, 0x19, phy_index, &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x19 = 0x%X.\n", phy_data);
+                nes_write_1G_phy_reg(nesdev, 0x19, phy_index, 0xffee);
-                nes_write_1G_phy_reg(nesdev, 0x19, nesadapter->phy_index[mac_index], 0xffee);
+                nes_read_1G_phy_reg(nesdev, 0x19, phy_index, &phy_data);
-                nes_read_1G_phy_reg(nesdev, 0x19, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x19 = 0x%X.\n", phy_data);
                /* turning on flow control */
-                nes_read_1G_phy_reg(nesdev, 4, nesadapter->phy_index[mac_index], &phy_data);
+                nes_read_1G_phy_reg(nesdev, 4, phy_index, &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x4 = 0x%X.\n", phy_data);
+                nes_write_1G_phy_reg(nesdev, 4, phy_index, (phy_data & ~(0x03E0)) | 0xc00);
-                nes_write_1G_phy_reg(nesdev, 4, nesadapter->phy_index[mac_index],
+                nes_read_1G_phy_reg(nesdev, 4, phy_index, &phy_data);
-                                (phy_data & ~(0x03E0)) | 0xc00);
-                /* nes_write_1G_phy_reg(nesdev, 4, nesadapter->phy_index[mac_index],
-                                phy_data | 0xc00); */
-                nes_read_1G_phy_reg(nesdev, 4, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x4 = 0x%X.\n", phy_data);
-                nes_read_1G_phy_reg(nesdev, 9, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x9 = 0x%X.\n", phy_data);
-                /* Clear Half duplex */
-                nes_write_1G_phy_reg(nesdev, 9, nesadapter->phy_index[mac_index],
-                                phy_data & ~(0x0100));
-                nes_read_1G_phy_reg(nesdev, 9, nesadapter->phy_index[mac_index], &phy_data);
-                nes_debug(NES_DBG_PHY, "Phy data from register 0x9 = 0x%X.\n", phy_data);
-                nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index], &phy_data);
-                nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[mac_index], phy_data | 0x0300);
-        } else {
-                if ((nesadapter->phy_type[mac_index] == NES_PHY_TYPE_IRIS) ||
-                    (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_ARGUS)) {
-                        /* setup 10G MDIO operation */
-                        tx_config = nes_read_indexed(nesdev, NES_IDX_MAC_TX_CONFIG);
-                        tx_config &= 0xFFFFFFE3;
-                        tx_config |= 0x15;
-                        nes_write_indexed(nesdev, NES_IDX_MAC_TX_CONFIG, tx_config);
-                }
-                if ((nesadapter->phy_type[mac_index] == NES_PHY_TYPE_ARGUS)) {
-                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0xd7ee);
-                        temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                /* Clear Half duplex */
-                        mdelay(10);
+                nes_read_1G_phy_reg(nesdev, 9, phy_index, &phy_data);
-                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0xd7ee);
+                nes_write_1G_phy_reg(nesdev, 9, phy_index, phy_data & ~(0x0100));
-                        temp_phy_data2 = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                nes_read_1G_phy_reg(nesdev, 9, phy_index, &phy_data);
-                        /*
+                nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
-                         * if firmware is already running (like from a
+                nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data | 0x0300);
-                         * driver un-load/load, don't do anything.
-                         */
-                        if (temp_phy_data == temp_phy_data2) {
-                                /* configure QT2505 AMCC PHY */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0x0000, 0x8000);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc300, 0x0000);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc302, 0x0044);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc318, 0x0052);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc319, 0x0008);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc31a, 0x0098);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0x0026, 0x0E00);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0x0027, 0x0001);
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0x0028, 0xA528);
-                                /*
+                return 0;
-                                 * remove micro from reset; chip boots from ROM,
+        }
-                                 * uploads EEPROM f/w image, uC executes f/w
-                                 */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc300, 0x0002);
-                                /*
+        if ((phy_type == NES_PHY_TYPE_IRIS) ||
-                                 * wait for heart beat to start to
+            (phy_type == NES_PHY_TYPE_ARGUS) ||
-                                 * know loading is done
+            (phy_type == NES_PHY_TYPE_SFP_D)) {
-                                 */
+                /* setup 10G MDIO operation */
-                                counter = 0;
+                tx_config = nes_read_indexed(nesdev, NES_IDX_MAC_TX_CONFIG);
-                                do {
+                tx_config &= 0xFFFFFFE3;
-                                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0xd7ee);
+                tx_config |= 0x15;
-                                        temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                nes_write_indexed(nesdev, NES_IDX_MAC_TX_CONFIG, tx_config);
-                                        if (counter++ > 1000) {
+        }
-                                                nes_debug(NES_DBG_PHY, "AMCC PHY- breaking from heartbeat check <this is bad!!!> \n");
+        if ((phy_type == NES_PHY_TYPE_ARGUS) ||
-                                                break;
+            (phy_type == NES_PHY_TYPE_SFP_D)) {
-                                        }
+                /* Check firmware heartbeat */
-                                        mdelay(100);
+                nes_read_10G_phy_reg(nesdev, phy_index, 0x3, 0xd7ee);
-                                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0xd7ee);
+                temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
-                                        temp_phy_data2 = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                udelay(1500);
-                                } while ((temp_phy_data2 == temp_phy_data));
+                nes_read_10G_phy_reg(nesdev, phy_index, 0x3, 0xd7ee);
+                temp_phy_data2 = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                if (temp_phy_data != temp_phy_data2)
+                        return 0;
-                                /*
+                /* no heartbeat, configure the PHY */
-                                 * wait for tracking to start to know
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0x0000, 0x8000);
-                                 * f/w is good to go
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc300, 0x0000);
-                                 */
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc316, 0x000A);
-                                counter = 0;
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc318, 0x0052);
-                                do {
+                if (phy_type == NES_PHY_TYPE_ARGUS) {
-                                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x3, 0xd7fd);
+                        nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc302, 0x000C);
-                                        temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                        nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc319, 0x0008);
-                                        if (counter++ > 1000) {
+                } else {
-                                                nes_debug(NES_DBG_PHY, "AMCC PHY- breaking from status check <this is bad!!!> \n");
+                        nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc302, 0x0004);
-                                                break;
+                        nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc319, 0x0038);
-                                        }
+                }
-                                        mdelay(1000);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc31a, 0x0098);
-                                        /*
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0026, 0x0E00);
-                                         * nes_debug(NES_DBG_PHY, "AMCC PHY- phy_status not ready yet = 0x%02X\n",
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0027, 0x0001);
-                                         *                      temp_phy_data);
-                                         */
-                                } while (((temp_phy_data & 0xff) != 0x50) && ((temp_phy_data & 0xff) != 0x70));
-                                /* set LOS Control invert RXLOSB_I_PADINV */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xd003, 0x0000);
-                                /* set LOS Control to mask of RXLOSB_I */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xc314, 0x0042);
-                                /* set LED1 to input mode (LED1 and LED2 share same LED) */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xd006, 0x0007);
-                                /* set LED2 to RX link_status and activity */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xd007, 0x000A);
-                                /* set LED3 to RX link_status */
-                                nes_write_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 0x1, 0xd008, 0x0009);
-                                /*
+                /* setup LEDs */
-                                 * reset the res-calibration on t2
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xd006, 0x0007);
-                                 * serdes; ensures it is stable after
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xd007, 0x000A);
-                                 * the amcc phy is stable
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xd008, 0x0009);
-                                 */
-                                sds_common_control0  = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x3, 0x0028, 0xA528);
-                                sds_common_control0 |= 0x1;
-                                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0, sds_common_control0);
-                                /* release the res-calibration reset */
+                /* Bring PHY out of reset */
-                                sds_common_control0 &= 0xfffffffe;
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc300, 0x0002);
-                                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0, sds_common_control0);
-                                i = 0;
+                /* Check for heartbeat */
-                                while (((nes_read32(nesdev->regs + NES_SOFTWARE_RESET) & 0x00000040) != 0x00000040)
+                counter = 0;
-                                                && (i++ < 5000)) {
+                mdelay(690);
-                                        /* mdelay(1); */
+                nes_read_10G_phy_reg(nesdev, phy_index, 0x3, 0xd7ee);
-                                }
+                temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                do {
+                        if (counter++ > 150) {
+                                nes_debug(NES_DBG_PHY, "No PHY heartbeat\n");
+                                break;
+                        }
+                        mdelay(1);
+                        nes_read_10G_phy_reg(nesdev, phy_index, 0x3, 0xd7ee);
+                        temp_phy_data2 = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                } while ((temp_phy_data2 == temp_phy_data));
-                                /*
+                /* wait for tracking */
-                                 * wait for link train done before moving on,
+                counter = 0;
-                                 * or will get an interupt storm
+                do {
-                                 */
+                        nes_read_10G_phy_reg(nesdev, phy_index, 0x3, 0xd7fd);
-                                counter = 0;
+                        temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
-                                do {
+                        if (counter++ > 300) {
-                                        temp_phy_data = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
+                                nes_debug(NES_DBG_PHY, "PHY did not track\n");
-                                                                (0x200 * (nesdev->mac_index & 1)));
+                                break;
-                                        if (counter++ > 1000) {
-                                                nes_debug(NES_DBG_PHY, "AMCC PHY- breaking from link train wait <this is bad, link didnt train!!!>\n");
-                                                break;
-                                        }
-                                        mdelay(1);
-                                } while (((temp_phy_data & 0x0f1f0000) != 0x0f0f0000));
                        }
-                }
+                        mdelay(10);
+                } while (((temp_phy_data & 0xff) != 0x50) && ((temp_phy_data & 0xff) != 0x70));
+                /* setup signal integrity */
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xd003, 0x0000);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xF00D, 0x00FE);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xF00E, 0x0032);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xF00F, 0x0002);
+                nes_write_10G_phy_reg(nesdev, phy_index, 0x1, 0xc314, 0x0063);
+                /* reset serdes */
+                sds = nes_read_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0 +
+                                       mac_index * 0x200);
+                sds |= 0x1;
+                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0 +
+                                  mac_index * 0x200, sds);
+                sds &= 0xfffffffe;
+                nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_COMMON_CONTROL0 +
+                                  mac_index * 0x200, sds);
+                counter = 0;
+                while (((nes_read32(nesdev->regs + NES_SOFTWARE_RESET) & 0x00000040) != 0x00000040)
+                                && (counter++ < 5000))
+                        ;
        }
        return 0;
 }
@@ -2359,6 +2335,7 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
        u16 temp_phy_data;
        u32 pcs_val  = 0x0f0f0000;
        u32 pcs_mask = 0x0f1f0000;
+        u32 cdr_ctrl;
        spin_lock_irqsave(&nesadapter->phy_lock, flags);
        if (nesadapter->mac_sw_state[mac_number] != NES_MAC_SW_IDLE) {
@@ -2473,6 +2450,7 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                                break;
                        case NES_PHY_TYPE_ARGUS:
+                        case NES_PHY_TYPE_SFP_D:
                                /* clear the alarms */
                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 4, 0x0008);
                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 4, 0xc001);
@@ -2483,19 +2461,18 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 1, 0x9004);
                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 1, 0x9005);
                                /* check link status */
-                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 1, 1);
+                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 1, 0x9003);
                                temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
-                                u32temp = 100;
-                                do {
-                                        nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 1, 1);
-                                        phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
+                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 3, 0x0021);
-                                        if ((phy_data == temp_phy_data) || (!(--u32temp)))
+                                nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
-                                                break;
+                                nes_read_10G_phy_reg(nesdev, nesadapter->phy_index[mac_index], 3, 0x0021);
-                                        temp_phy_data = phy_data;
+                                phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
-                                } while (1);
+                                phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
                                nes_debug(NES_DBG_PHY, "%s: Phy data = 0x%04X, link was %s.\n",
-                                        __func__, phy_data, nesadapter->mac_link_down ? "DOWN" : "UP");
+                                        __func__, phy_data, nesadapter->mac_link_down[mac_index] ? "DOWN" : "UP");
                                break;
                        case NES_PHY_TYPE_PUMA_1G:
@@ -2511,6 +2488,17 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                }
                if (phy_data & 0x0004) {
+                        if (wide_ppm_offset &&
+                            (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_CX4) &&
+                            (nesadapter->hw_rev != NE020_REV)) {
+                                cdr_ctrl = nes_read_indexed(nesdev,
+                                                            NES_IDX_ETH_SERDES_CDR_CONTROL0 +
+                                                            mac_index * 0x200);
+                                nes_write_indexed(nesdev,
+                                                  NES_IDX_ETH_SERDES_CDR_CONTROL0 +
+                                                  mac_index * 0x200,
+                                                  cdr_ctrl | 0x000F0000);
+                        }
                        nesadapter->mac_link_down[mac_index] = 0;
                        list_for_each_entry(nesvnic, &nesadapter->nesvnic_list[mac_index], list) {
                                nes_debug(NES_DBG_PHY, "The Link is UP!!.  linkup was %d\n",
@@ -2525,6 +2513,17 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                                }
                        }
                } else {
+                        if (wide_ppm_offset &&
+                            (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_CX4) &&
+                            (nesadapter->hw_rev != NE020_REV)) {
+                                cdr_ctrl = nes_read_indexed(nesdev,
+                                                            NES_IDX_ETH_SERDES_CDR_CONTROL0 +
+                                                            mac_index * 0x200);
+                                nes_write_indexed(nesdev,
+                                                  NES_IDX_ETH_SERDES_CDR_CONTROL0 +
+                                                  mac_index * 0x200,
+                                                  cdr_ctrl & 0xFFF0FFFF);
+                        }
                        nesadapter->mac_link_down[mac_index] = 1;
                        list_for_each_entry(nesvnic, &nesadapter->nesvnic_list[mac_index], list) {
                                nes_debug(NES_DBG_PHY, "The Link is Down!!. linkup was %d\n",
diff --git a/drivers/infiniband/hw/nes/nes_hw.h b/drivers/infiniband/hw/nes/nes_hw.h
index f41a8710d2a8..c3654c6383fe 100644
--- a/drivers/infiniband/hw/nes/nes_hw.h
+++ b/drivers/infiniband/hw/nes/nes_hw.h
@@ -35,12 +35,14 @@
 #include <linux/inet_lro.h>
+#define NES_PHY_TYPE_CX4       1
 #define NES_PHY_TYPE_1G        2
 #define NES_PHY_TYPE_IRIS      3
 #define NES_PHY_TYPE_ARGUS     4
 #define NES_PHY_TYPE_PUMA_1G   5
 #define NES_PHY_TYPE_PUMA_10G  6
 #define NES_PHY_TYPE_GLADIUS   7
+#define NES_PHY_TYPE_SFP_D     8
 #define NES_MULTICAST_PF_MAX 8
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index ecb1f6fd6276..c6e6611d3016 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -1426,49 +1426,55 @@ static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd
        struct nes_vnic *nesvnic = netdev_priv(netdev);
        struct nes_device *nesdev = nesvnic->nesdev;
        struct nes_adapter *nesadapter = nesdev->nesadapter;
+        u32 mac_index = nesdev->mac_index;
+        u8 phy_type = nesadapter->phy_type[mac_index];
+        u8 phy_index = nesadapter->phy_index[mac_index];
        u16 phy_data;
        et_cmd->duplex = DUPLEX_FULL;
        et_cmd->port   = PORT_MII;
+        et_cmd->maxtxpkt = 511;
+        et_cmd->maxrxpkt = 511;
        if (nesadapter->OneG_Mode) {
                et_cmd->speed = SPEED_1000;
-                if (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) {
+                if (phy_type == NES_PHY_TYPE_PUMA_1G) {
                        et_cmd->supported   = SUPPORTED_1000baseT_Full;
                        et_cmd->advertising = ADVERTISED_1000baseT_Full;
                        et_cmd->autoneg     = AUTONEG_DISABLE;
                        et_cmd->transceiver = XCVR_INTERNAL;
-                        et_cmd->phy_address = nesdev->mac_index;
+                        et_cmd->phy_address = mac_index;
                } else {
-                        et_cmd->supported   = SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg;
+                        et_cmd->supported   = SUPPORTED_1000baseT_Full
-                        et_cmd->advertising = ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg;
+                                            | SUPPORTED_Autoneg;
-                        nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index], &phy_data);
+                        et_cmd->advertising = ADVERTISED_1000baseT_Full
+                                            | ADVERTISED_Autoneg;
+                        nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
                        if (phy_data & 0x1000)
                                et_cmd->autoneg = AUTONEG_ENABLE;
                        else
                                et_cmd->autoneg = AUTONEG_DISABLE;
                        et_cmd->transceiver = XCVR_EXTERNAL;
-                        et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
+                        et_cmd->phy_address = phy_index;
                }
+                return 0;
+        }
+        if ((phy_type == NES_PHY_TYPE_IRIS) ||
+            (phy_type == NES_PHY_TYPE_ARGUS) ||
+            (phy_type == NES_PHY_TYPE_SFP_D)) {
+                et_cmd->transceiver = XCVR_EXTERNAL;
+                et_cmd->port        = PORT_FIBRE;
+                et_cmd->supported   = SUPPORTED_FIBRE;
+                et_cmd->advertising = ADVERTISED_FIBRE;
+                et_cmd->phy_address = phy_index;
        } else {
-                if ((nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_IRIS) ||
+                et_cmd->transceiver = XCVR_INTERNAL;
-                    (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_ARGUS)) {
+                et_cmd->supported   = SUPPORTED_10000baseT_Full;
-                        et_cmd->transceiver = XCVR_EXTERNAL;
+                et_cmd->advertising = ADVERTISED_10000baseT_Full;
-                        et_cmd->port        = PORT_FIBRE;
+                et_cmd->phy_address = mac_index;
-                        et_cmd->supported   = SUPPORTED_FIBRE;
-                        et_cmd->advertising = ADVERTISED_FIBRE;
-                        et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
-                } else {
-                        et_cmd->transceiver = XCVR_INTERNAL;
-                        et_cmd->supported   = SUPPORTED_10000baseT_Full;
-                        et_cmd->advertising = ADVERTISED_10000baseT_Full;
-                        et_cmd->phy_address = nesdev->mac_index;
-                }
-                et_cmd->speed = SPEED_10000;
-                et_cmd->autoneg = AUTONEG_DISABLE;
        }
-        et_cmd->maxtxpkt = 511;
+        et_cmd->speed = SPEED_10000;
-        et_cmd->maxrxpkt = 511;
+        et_cmd->autoneg = AUTONEG_DISABLE;
        return 0;
 }
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
index 5a76a5510350..4c57f329dd50 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
@@ -70,12 +70,14 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
         */
        if (ppriv->pkey == pkey) {
                result = -ENOTUNIQ;
+                priv = NULL;
                goto err;
        }
        list_for_each_entry(priv, &ppriv->child_intfs, list) {
                if (priv->pkey == pkey) {
                        result = -ENOTUNIQ;
+                        priv = NULL;
                        goto err;
                }
        }
@@ -96,7 +98,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
        result = ipoib_set_dev_features(priv, ppriv->ca);
        if (result)
-                goto device_init_failed;
+                goto err;
        priv->pkey = pkey;
@@ -109,7 +111,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
                ipoib_warn(ppriv, "failed to initialize subinterface: "
                           "device %s, port %d",
                           ppriv->ca->name, ppriv->port);
-                goto device_init_failed;
+                goto err;
        }
        result = register_netdevice(priv->dev);
@@ -146,19 +148,19 @@ sysfs_failed:
 register_failed:
        ipoib_dev_cleanup(priv->dev);
-device_init_failed:
-        free_netdev(priv->dev);
 err:
        mutex_unlock(&ppriv->vlan_mutex);
        rtnl_unlock();
+        if (priv)
+                free_netdev(priv->dev);
        return result;
 }
 int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
 {
        struct ipoib_dev_priv *ppriv, *priv, *tpriv;
-        int ret = -ENOENT;
+        struct net_device *dev = NULL;
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
@@ -172,14 +174,17 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
                        unregister_netdevice(priv->dev);
                        ipoib_dev_cleanup(priv->dev);
                        list_del(&priv->list);
-                        free_netdev(priv->dev);
+                        dev = priv->dev;
-                        ret = 0;
                        break;
                }
        }
        mutex_unlock(&ppriv->vlan_mutex);
        rtnl_unlock();
-        return ret;
+        if (dev) {
+                free_netdev(dev);
+                return 0;
+        }
+        return -ENODEV;
 }
diff --git a/drivers/net/mlx4/port.c b/drivers/net/mlx4/port.c
index 7cce3342ef8c..606aa58afdea 100644
--- a/drivers/net/mlx4/port.c
+++ b/drivers/net/mlx4/port.c
@@ -299,13 +299,14 @@ int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port)
        struct mlx4_cmd_mailbox *mailbox;
        int err;
+        if (dev->caps.port_type[port] == MLX4_PORT_TYPE_ETH)
+                return 0;
        mailbox = mlx4_alloc_cmd_mailbox(dev);
        if (IS_ERR(mailbox))
                return PTR_ERR(mailbox);
        memset(mailbox->buf, 0, 256);
-        if (dev->caps.port_type[port] == MLX4_PORT_TYPE_ETH)
-                return 0;
        ((__be32 *) mailbox->buf)[1] = dev->caps.ib_port_def_cap[port];
        err = mlx4_cmd(dev, mailbox->dma, port, 0, MLX4_CMD_SET_PORT,
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index ac77d8b8251d..6132353dcf62 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -342,7 +342,7 @@ static int ext4_valid_extent_idx(struct inode *inode,
        ext4_fsblk_t block = idx_pblock(ext_idx);
        struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
        if (unlikely(block < le32_to_cpu(es->s_first_data_block) ||
-                        (block > ext4_blocks_count(es))))
+                        (block >= ext4_blocks_count(es))))
                return 0;
        else
                return 1;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index a2e7952bc5f9..c6bd6ced3bb7 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -372,16 +372,16 @@ static int ext4_block_to_path(struct inode *inode,
 }
 static int __ext4_check_blockref(const char *function, struct inode *inode,
-                                 unsigned int *p, unsigned int max) {
+                                 __le32 *p, unsigned int max) {
        unsigned int maxblocks = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es);
-        unsigned int *bref = p;
+        __le32 *bref = p;
        while (bref < p+max) {
-                if (unlikely(*bref >= maxblocks)) {
+                if (unlikely(le32_to_cpu(*bref) >= maxblocks)) {
                        ext4_error(inode->i_sb, function,
                                   "block reference %u >= max (%u) "
                                   "in inode #%lu, offset=%d",
-                                   *bref, maxblocks,
+                                   le32_to_cpu(*bref), maxblocks,
                                   inode->i_ino, (int)(bref-p));
                        return -EIO;
                }
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 9987bba99db3..2958f4e6f222 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -2508,6 +2508,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
        if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
                goto cantfind_ext4;
+        /* check blocks count against device size */
+        blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
+        if (blocks_count && ext4_blocks_count(es) > blocks_count) {
+                printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu "
+                       "exceeds size of device (%llu blocks)\n",
+                       ext4_blocks_count(es), blocks_count);
+                goto failed_mount;
+        }
        /*
         * It makes no sense for the first data block to be beyond the end
         * of the filesystem.
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a5d26f66ef78..ff65fffb078f 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -240,65 +240,38 @@ typedef enum {
 } ide_startstop_t;
 enum {
+        IDE_VALID_ERROR                 = (1 << 1),
+        IDE_VALID_FEATURE               = IDE_VALID_ERROR,
+        IDE_VALID_NSECT                 = (1 << 2),
+        IDE_VALID_LBAL                  = (1 << 3),
+        IDE_VALID_LBAM                  = (1 << 4),
+        IDE_VALID_LBAH                  = (1 << 5),
+        IDE_VALID_DEVICE                = (1 << 6),
+        IDE_VALID_LBA                   = IDE_VALID_LBAL |
+                                          IDE_VALID_LBAM |
+                                          IDE_VALID_LBAH,
+        IDE_VALID_OUT_TF                = IDE_VALID_FEATURE |
+                                          IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+        IDE_VALID_IN_TF                 = IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+        IDE_VALID_OUT_HOB               = IDE_VALID_OUT_TF,
+        IDE_VALID_IN_HOB                = IDE_VALID_ERROR |
+                                          IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+};
+enum {
        IDE_TFLAG_LBA48                 = (1 << 0),
-        IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 1),
+        IDE_TFLAG_WRITE                 = (1 << 1),
-        IDE_TFLAG_OUT_HOB_NSECT         = (1 << 2),
+        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 2),
-        IDE_TFLAG_OUT_HOB_LBAL          = (1 << 3),
+        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 3),
-        IDE_TFLAG_OUT_HOB_LBAM          = (1 << 4),
-        IDE_TFLAG_OUT_HOB_LBAH          = (1 << 5),
-        IDE_TFLAG_OUT_HOB               = IDE_TFLAG_OUT_HOB_FEATURE |
-                                          IDE_TFLAG_OUT_HOB_NSECT |
-                                          IDE_TFLAG_OUT_HOB_LBAL |
-                                          IDE_TFLAG_OUT_HOB_LBAM |
-                                          IDE_TFLAG_OUT_HOB_LBAH,
-        IDE_TFLAG_OUT_FEATURE           = (1 << 6),
-        IDE_TFLAG_OUT_NSECT             = (1 << 7),
-        IDE_TFLAG_OUT_LBAL              = (1 << 8),
-        IDE_TFLAG_OUT_LBAM              = (1 << 9),
-        IDE_TFLAG_OUT_LBAH              = (1 << 10),
-        IDE_TFLAG_OUT_TF                = IDE_TFLAG_OUT_FEATURE |
-                                          IDE_TFLAG_OUT_NSECT |
-                                          IDE_TFLAG_OUT_LBAL |
-                                          IDE_TFLAG_OUT_LBAM |
-                                          IDE_TFLAG_OUT_LBAH,
-        IDE_TFLAG_OUT_DEVICE            = (1 << 11),
-        IDE_TFLAG_WRITE                 = (1 << 12),
-        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 13),
-        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 14),
-        IDE_TFLAG_IN_HOB_ERROR          = (1 << 15),
-        IDE_TFLAG_IN_HOB_NSECT          = (1 << 16),
-        IDE_TFLAG_IN_HOB_LBAL           = (1 << 17),
-        IDE_TFLAG_IN_HOB_LBAM           = (1 << 18),
-        IDE_TFLAG_IN_HOB_LBAH           = (1 << 19),
-        IDE_TFLAG_IN_HOB_LBA            = IDE_TFLAG_IN_HOB_LBAL |
-                                          IDE_TFLAG_IN_HOB_LBAM |
-                                          IDE_TFLAG_IN_HOB_LBAH,
-        IDE_TFLAG_IN_HOB                = IDE_TFLAG_IN_HOB_ERROR |
-                                          IDE_TFLAG_IN_HOB_NSECT |
-                                          IDE_TFLAG_IN_HOB_LBA,
-        IDE_TFLAG_IN_ERROR              = (1 << 20),
-        IDE_TFLAG_IN_NSECT              = (1 << 21),
-        IDE_TFLAG_IN_LBAL               = (1 << 22),
-        IDE_TFLAG_IN_LBAM               = (1 << 23),
-        IDE_TFLAG_IN_LBAH               = (1 << 24),
-        IDE_TFLAG_IN_LBA                = IDE_TFLAG_IN_LBAL |
-                                          IDE_TFLAG_IN_LBAM |
-                                          IDE_TFLAG_IN_LBAH,
-        IDE_TFLAG_IN_TF                 = IDE_TFLAG_IN_NSECT |
-                                          IDE_TFLAG_IN_LBA,
-        IDE_TFLAG_IN_DEVICE             = (1 << 25),
-        IDE_TFLAG_HOB                   = IDE_TFLAG_OUT_HOB |
-                                          IDE_TFLAG_IN_HOB,
-        IDE_TFLAG_TF                    = IDE_TFLAG_OUT_TF |
-                                          IDE_TFLAG_IN_TF,
-        IDE_TFLAG_DEVICE                = IDE_TFLAG_OUT_DEVICE |
-                                          IDE_TFLAG_IN_DEVICE,
        /* force 16-bit I/O operations */
-        IDE_TFLAG_IO_16BIT              = (1 << 26),
+        IDE_TFLAG_IO_16BIT              = (1 << 4),
        /* struct ide_cmd was allocated using kmalloc() */
-        IDE_TFLAG_DYN                   = (1 << 27),
+        IDE_TFLAG_DYN                   = (1 << 5),
-        IDE_TFLAG_FS                    = (1 << 28),
+        IDE_TFLAG_FS                    = (1 << 6),
-        IDE_TFLAG_MULTI_PIO             = (1 << 29),
+        IDE_TFLAG_MULTI_PIO             = (1 << 7),
 };
 enum {
@@ -309,45 +282,34 @@ enum {
 };
 struct ide_taskfile {
-        u8      hob_data;       /*  0: high data byte (for TASKFILE IOCTL) */
+        u8      data;           /* 0: data byte (for TASKFILE ioctl) */
-                                /*  1-5: additional data to support LBA48 */
+        union {                 /* 1: */
-        union {
+                u8 error;       /*  read: error */
-                u8 hob_error;   /*   read: error */
+                u8 feature;     /* write: feature */
-                u8 hob_feature; /*  write: feature */
-        };
-        u8      hob_nsect;
-        u8      hob_lbal;
-        u8      hob_lbam;
-        u8      hob_lbah;
-        u8      data;           /*  6: low data byte (for TASKFILE IOCTL) */
-        union {                 /*  7: */
-                u8 error;       /*   read:  error */
-                u8 feature;     /*  write: feature */
        };
+        u8      nsect;          /* 2: number of sectors */
-        u8      nsect;          /*  8: number of sectors */
+        u8      lbal;           /* 3: LBA low */
-        u8      lbal;           /*  9: LBA low */
+        u8      lbam;           /* 4: LBA mid */
-        u8      lbam;           /* 10: LBA mid */
+        u8      lbah;           /* 5: LBA high */
-        u8      lbah;           /* 11: LBA high */
+        u8      device;         /* 6: device select */
+        union {                 /* 7: */
-        u8      device;         /* 12: device select */
+                u8 status;      /*  read: status */
-        union {                 /* 13: */
-                u8 status;      /*  read: status  */
                u8 command;     /* write: command */
        };
 };
 struct ide_cmd {
-        union {
+        struct ide_taskfile     tf;
-                struct ide_taskfile     tf;
+        struct ide_taskfile     hob;
-                u8                      tf_array[14];
+        struct {
-        };
+                struct {
+                        u8              tf;
+                        u8              hob;
+                } out, in;
+        } valid;
+        u8                      tf_flags;
        u8                      ftf_flags;      /* for TASKFILE ioctl */
-        u32                     tf_flags;
        int                     protocol;
        int                     sg_nents;         /* number of sg entries */
@@ -662,8 +624,8 @@ struct ide_tp_ops {
        void    (*write_devctl)(struct hwif_s *, u8);
        void    (*dev_select)(ide_drive_t *);
-        void    (*tf_load)(ide_drive_t *, struct ide_cmd *);
+        void    (*tf_load)(ide_drive_t *, struct ide_taskfile *, u8);
-        void    (*tf_read)(ide_drive_t *, struct ide_cmd *);
+        void    (*tf_read)(ide_drive_t *, struct ide_taskfile *, u8);
        void    (*input_data)(ide_drive_t *, struct ide_cmd *,
                              void *, unsigned int);
@@ -1162,7 +1124,8 @@ extern int ide_devset_execute(ide_drive_t *drive,
 void ide_complete_cmd(ide_drive_t *, struct ide_cmd *, u8, u8);
 int ide_complete_rq(ide_drive_t *, int, unsigned int);
-void ide_tf_dump(const char *, struct ide_taskfile *);
+void ide_tf_readback(ide_drive_t *drive, struct ide_cmd *cmd);
+void ide_tf_dump(const char *, struct ide_cmd *);
 void ide_exec_command(ide_hwif_t *, u8);
 u8 ide_read_status(ide_hwif_t *);
@@ -1170,8 +1133,8 @@ u8 ide_read_altstatus(ide_hwif_t *);
 void ide_write_devctl(ide_hwif_t *, u8);
 void ide_dev_select(ide_drive_t *);
-void ide_tf_load(ide_drive_t *, struct ide_cmd *);
+void ide_tf_load(ide_drive_t *, struct ide_taskfile *, u8);
-void ide_tf_read(ide_drive_t *, struct ide_cmd *);
+void ide_tf_read(ide_drive_t *, struct ide_taskfile *, u8);
 void ide_input_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
 void ide_output_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
@@ -1529,7 +1492,7 @@ static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data)
 extern void ide_toggle_bounce(ide_drive_t *drive, int on);
-u64 ide_get_lba_addr(struct ide_taskfile *, int);
+u64 ide_get_lba_addr(struct ide_cmd *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 struct ide_timing {