if (ide_read_status(drive) & (BUSY_STAT | DRQ_STAT))
                /* force an abort */
-               hwif->OUTBSYNC(hwif, WIN_IDLEIMMEDIATE,
-                              hwif->io_ports.command_addr);
+               hwif->exec_command(hwif, WIN_IDLEIMMEDIATE);
 
        if (rq->errors >= ERROR_MAX) {
                ide_kill_rq(drive, rq);
 
                port_ops->maskproc(drive, mask);
 }
 
+static void ide_exec_command(ide_hwif_t *hwif, u8 cmd)
+{
+       if (hwif->host_flags & IDE_HFLAG_MMIO)
+               writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
+       else
+               outb(cmd, hwif->io_ports.command_addr);
+}
+
 static u8 ide_read_sff_dma_status(ide_hwif_t *hwif)
 {
        if (hwif->host_flags & IDE_HFLAG_MMIO)
 
 void default_hwif_transport(ide_hwif_t *hwif)
 {
+       hwif->exec_command        = ide_exec_command;
        hwif->read_sff_dma_status = ide_read_sff_dma_status;
 
        hwif->tf_load     = ide_tf_load;
        SELECT_MASK(drive, 1);
        ide_set_irq(drive, 0);
        msleep(50);
-       hwif->OUTBSYNC(hwif, WIN_IDENTIFY, hwif->io_ports.command_addr);
+       hwif->exec_command(hwif, WIN_IDENTIFY);
        timeout = jiffies + WAIT_WORSTCASE;
        do {
                if (time_after(jiffies, timeout)) {
        ide_set_irq(drive, 0);
        hwif->OUTB(speed, io_ports->nsect_addr);
        hwif->OUTB(SETFEATURES_XFER, io_ports->feature_addr);
-       hwif->OUTBSYNC(hwif, WIN_SETFEATURES, io_ports->command_addr);
+       hwif->exec_command(hwif, WIN_SETFEATURES);
        if (drive->quirk_list == 2)
                ide_set_irq(drive, 1);
 
 
        spin_lock_irqsave(&ide_lock, flags);
        __ide_set_handler(drive, handler, timeout, expiry);
-       hwif->OUTBSYNC(hwif, cmd, hwif->io_ports.command_addr);
+       hwif->exec_command(hwif, cmd);
        /*
         * Drive takes 400nS to respond, we must avoid the IRQ being
         * serviced before that.
        unsigned long flags;
 
        spin_lock_irqsave(&ide_lock, flags);
-       hwif->OUTBSYNC(hwif, WIN_PACKETCMD, hwif->io_ports.command_addr);
+       hwif->exec_command(hwif, WIN_PACKETCMD);
        ndelay(400);
        spin_unlock_irqrestore(&ide_lock, flags);
 }
                pre_reset(drive);
                SELECT_DRIVE(drive);
                udelay (20);
-               hwif->OUTBSYNC(hwif, WIN_SRST, io_ports->command_addr);
+               hwif->exec_command(hwif, WIN_SRST);
                ndelay(400);
                hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
                hwgroup->polling = 1;
 
                hwif->OUTB(0, io_ports->feature_addr);
 
        /* ask drive for ID */
-       hwif->OUTBSYNC(hwif, cmd, hwif->io_ports.command_addr);
+       hwif->exec_command(hwif, cmd);
 
        timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
        timeout += jiffies;
                        msleep(50);
                        SELECT_DRIVE(drive);
                        msleep(50);
-                       hwif->OUTBSYNC(hwif, WIN_SRST, io_ports->command_addr);
+                       hwif->exec_command(hwif, WIN_SRST);
                        (void)ide_busy_sleep(hwif);
                        rc = try_to_identify(drive, cmd);
                }
        printk("%s: enabling %s -- ", hwif->name, drive->id->model);
        SELECT_DRIVE(drive);
        msleep(50);
-       hwif->OUTBSYNC(hwif, EXABYTE_ENABLE_NEST, hwif->io_ports.command_addr);
+       hwif->exec_command(hwif, EXABYTE_ENABLE_NEST);
 
        if (ide_busy_sleep(hwif)) {
                printk(KERN_CONT "failed (timeout)\n");
 
        switch (task->data_phase) {
        case TASKFILE_MULTI_OUT:
        case TASKFILE_OUT:
-               hwif->OUTBSYNC(hwif, tf->command, hwif->io_ports.command_addr);
+               hwif->exec_command(hwif, tf->command);
                ndelay(400);    /* FIXME */
                return pre_task_out_intr(drive, task->rq);
        case TASKFILE_MULTI_IN:
 
        return (u8)data;
 }
 
+static void scc_exec_command(ide_hwif_t *hwif, u8 cmd)
+{
+       out_be32((void *)hwif->io_ports.command_addr, cmd);
+       eieio();
+       in_be32((void *)(hwif->dma_base + 0x01c));
+       eieio();
+}
+
 static u8 scc_read_sff_dma_status(ide_hwif_t *hwif)
 {
        return (u8)in_be32((void *)(hwif->dma_base + 4));
 
        ide_set_hwifdata(hwif, ports);
 
+       hwif->exec_command        = scc_exec_command;
        hwif->read_sff_dma_status = scc_read_sff_dma_status;
 
        hwif->tf_load = scc_tf_load;
 
                                     + IDE_TIMING_CONFIG));
 }
 
+static void pmac_exec_command(ide_hwif_t *hwif, u8 cmd)
+{
+       writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
+       (void)readl((void __iomem *)(hwif->io_ports.data_addr
+                                    + IDE_TIMING_CONFIG));
+}
+
 /*
  * Old tuning functions (called on hdparm -p), sets up drive PIO timings
  */
        if (hwif == NULL)
                return -ENOENT;
 
+       hwif->exec_command = pmac_exec_command;
+
        /* Setup MMIO ops */
        default_hwif_mmiops(hwif);
                hwif->OUTBSYNC = pmac_outbsync;
 
 
        if (ide_read_status(drive) & (BUSY_STAT | DRQ_STAT))
                /* force an abort */
-               hwif->OUTBSYNC(hwif, WIN_IDLEIMMEDIATE,
-                              hwif->io_ports.command_addr);
+               hwif->exec_command(hwif, WIN_IDLEIMMEDIATE);
 
        rq->errors++;
 
 
        const struct ide_port_ops       *port_ops;
        const struct ide_dma_ops        *dma_ops;
 
-       u8 (*read_sff_dma_status)(struct hwif_s *);
+       void    (*exec_command)(struct hwif_s *, u8);
+       u8      (*read_sff_dma_status)(struct hwif_s *);
 
        void (*tf_load)(ide_drive_t *, struct ide_task_s *);
        void (*tf_read)(ide_drive_t *, struct ide_task_s *);