24 files changed, 1834 insertions, 523 deletions

diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index b3ae796eb624..2d21265e650b 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -256,7 +256,7 @@ config SCSI_DECNCR
 
 config SCSI_DECSII
         tristate "DEC SII Scsi Driver"
-        depends on MACH_DECSTATION && SCSI && MIPS32
+        depends on MACH_DECSTATION && SCSI && 32BIT
 
 config BLK_DEV_3W_XXXX_RAID
         tristate "3ware 5/6/7/8xxx ATA-RAID support"
@@ -465,6 +465,15 @@ config SCSI_ATA_PIIX
 
           If unsure, say N.
 
+config SCSI_SATA_MV
+        tristate "Marvell SATA support"
+        depends on SCSI_SATA && PCI && EXPERIMENTAL
+        help
+          This option enables support for the Marvell Serial ATA family.
+          Currently supports 88SX[56]0[48][01] chips.
+
+          If unsure, say N.
+
 config SCSI_SATA_NV
         tristate "NVIDIA SATA support"
         depends on SCSI_SATA && PCI && EXPERIMENTAL
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 85f9e6bb34b9..4b4fd94c2674 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -134,6 +134,7 @@ obj-$(CONFIG_SCSI_SATA_SIS)	+= libata.o sata_sis.o
 obj-$(CONFIG_SCSI_SATA_SX4)     += libata.o sata_sx4.o
 obj-$(CONFIG_SCSI_SATA_NV)      += libata.o sata_nv.o
 obj-$(CONFIG_SCSI_SATA_ULI)     += libata.o sata_uli.o
+obj-$(CONFIG_SCSI_SATA_MV)      += libata.o sata_mv.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index f8ec6fe7d858..d40ba0bd68a3 100644
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -88,6 +88,13 @@
  */
 #include <scsi/scsi_dbg.h>
 
+#ifndef NDEBUG
+#define NDEBUG 0
+#endif
+#ifndef NDEBUG
+#define NDEBUG_ABORT 0
+#endif
+
 #if (NDEBUG & NDEBUG_LISTS)
 #define LIST(x,y) {printk("LINE:%d   Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); }
 #define REMOVE(w,x,y,z) {printk("LINE:%d   Removing: %p->%p  %p->%p \n", __LINE__, (void*)(w), (void*)(x), (void*)(y), (void*)(z)); if ((x)==(y)) udelay(5); }
@@ -359,7 +366,7 @@ static struct {
         {PHASE_UNKNOWN, "UNKNOWN"}
 };
 
-#ifdef NDEBUG
+#if NDEBUG
 static struct {
         unsigned char mask;
         const char *name;
diff --git a/drivers/scsi/NCR53c406a.c b/drivers/scsi/NCR53c406a.c
index 79ae73b23680..e1f2246ee7cd 100644
--- a/drivers/scsi/NCR53c406a.c
+++ b/drivers/scsi/NCR53c406a.c
@@ -62,7 +62,7 @@
 
 #define SYNC_MODE 0             /* Synchronous transfer mode */
 
-#if DEBUG
+#ifdef DEBUG
 #undef NCR53C406A_DEBUG
 #define NCR53C406A_DEBUG 1
 #endif
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index e3b9692b9688..320df6cd3def 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -1,26 +1,34 @@
 /*
  *  ahci.c - AHCI SATA support
  *
- *  Copyright 2004 Red Hat, Inc.
+ *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                  Please ALWAYS copy linux-ide@vger.kernel.org
+ *                  on emails.
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
+ *  Copyright 2004-2005 Red Hat, Inc.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
  *
- * Version 1.0 of the AHCI specification:
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ * libata documentation is available via 'make {ps|pdf}docs',
+ * as Documentation/DocBook/libata.*
+ *
+ * AHCI hardware documentation:
  * http://www.intel.com/technology/serialata/pdf/rev1_0.pdf
+ * http://www.intel.com/technology/serialata/pdf/rev1_1.pdf
  *
  */
 
@@ -181,7 +189,6 @@ static void ahci_irq_clear(struct ata_port *ap);
 static void ahci_eng_timeout(struct ata_port *ap);
 static int ahci_port_start(struct ata_port *ap);
 static void ahci_port_stop(struct ata_port *ap);
-static void ahci_host_stop(struct ata_host_set *host_set);
 static void ahci_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 static void ahci_qc_prep(struct ata_queued_cmd *qc);
 static u8 ahci_check_status(struct ata_port *ap);
@@ -234,7 +241,6 @@ static struct ata_port_operations ahci_ops = {
 
         .port_start             = ahci_port_start,
         .port_stop              = ahci_port_stop,
-        .host_stop              = ahci_host_stop,
 };
 
 static struct ata_port_info ahci_port_info[] = {
@@ -244,7 +250,7 @@ static struct ata_port_info ahci_port_info[] = {
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
                                   ATA_FLAG_PIO_DMA,
-                .pio_mask       = 0x03, /* pio3-4 */
+                .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
                 .port_ops       = &ahci_ops,
         },
@@ -269,6 +275,8 @@ static struct pci_device_id ahci_pci_tbl[] = {
           board_ahci }, /* ESB2 */
         { PCI_VENDOR_ID_INTEL, 0x2683, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_ahci }, /* ESB2 */
+        { PCI_VENDOR_ID_INTEL, 0x27c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_ahci }, /* ICH7-M DH */
         { }     /* terminate list */
 };
 
@@ -286,17 +294,9 @@ static inline unsigned long ahci_port_base_ul (unsigned long base, unsigned int
         return base + 0x100 + (port * 0x80);
 }
 
-static inline void *ahci_port_base (void *base, unsigned int port)
+static inline void __iomem *ahci_port_base (void __iomem *base, unsigned int port)
 {
-        return (void *) ahci_port_base_ul((unsigned long)base, port);
-}
-
-static void ahci_host_stop(struct ata_host_set *host_set)
-{
-        struct ahci_host_priv *hpriv = host_set->private_data;
-        kfree(hpriv);
-
-        ata_host_stop(host_set);
+        return (void __iomem *) ahci_port_base_ul((unsigned long)base, port);
 }
 
 static int ahci_port_start(struct ata_port *ap)
@@ -304,8 +304,9 @@ static int ahci_port_start(struct ata_port *ap)
         struct device *dev = ap->host_set->dev;
         struct ahci_host_priv *hpriv = ap->host_set->private_data;
         struct ahci_port_priv *pp;
-        void *mem, *mmio = ap->host_set->mmio_base;
-        void *port_mmio = ahci_port_base(mmio, ap->port_no);
+        void __iomem *mmio = ap->host_set->mmio_base;
+        void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
+        void *mem;
         dma_addr_t mem_dma;
 
         pp = kmalloc(sizeof(*pp), GFP_KERNEL);
@@ -373,8 +374,8 @@ static void ahci_port_stop(struct ata_port *ap)
 {
         struct device *dev = ap->host_set->dev;
         struct ahci_port_priv *pp = ap->private_data;
-        void *mmio = ap->host_set->mmio_base;
-        void *port_mmio = ahci_port_base(mmio, ap->port_no);
+        void __iomem *mmio = ap->host_set->mmio_base;
+        void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
         u32 tmp;
 
         tmp = readl(port_mmio + PORT_CMD);
@@ -536,8 +537,8 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
 
 static void ahci_intr_error(struct ata_port *ap, u32 irq_stat)
 {
-        void *mmio = ap->host_set->mmio_base;
-        void *port_mmio = ahci_port_base(mmio, ap->port_no);
+        void __iomem *mmio = ap->host_set->mmio_base;
+        void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
         u32 tmp;
         int work;
 
@@ -584,12 +585,16 @@ static void ahci_intr_error(struct ata_port *ap, u32 irq_stat)
 
 static void ahci_eng_timeout(struct ata_port *ap)
 {
-        void *mmio = ap->host_set->mmio_base;
-        void *port_mmio = ahci_port_base(mmio, ap->port_no);
+        struct ata_host_set *host_set = ap->host_set;
+        void __iomem *mmio = host_set->mmio_base;
+        void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
         struct ata_queued_cmd *qc;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
+        spin_lock_irqsave(&host_set->lock, flags);
+
         ahci_intr_error(ap, readl(port_mmio + PORT_IRQ_STAT));
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -607,12 +612,13 @@ static void ahci_eng_timeout(struct ata_port *ap)
                 ata_qc_complete(qc, ATA_ERR);
         }
 
+        spin_unlock_irqrestore(&host_set->lock, flags);
 }
 
 static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
 {
-        void *mmio = ap->host_set->mmio_base;
-        void *port_mmio = ahci_port_base(mmio, ap->port_no);
+        void __iomem *mmio = ap->host_set->mmio_base;
+        void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
         u32 status, serr, ci;
 
         serr = readl(port_mmio + PORT_SCR_ERR);
@@ -648,7 +654,7 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
         struct ata_host_set *host_set = dev_instance;
         struct ahci_host_priv *hpriv;
         unsigned int i, handled = 0;
-        void *mmio;
+        void __iomem *mmio;
         u32 irq_stat, irq_ack = 0;
 
         VPRINTK("ENTER\n");
@@ -694,10 +700,7 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
 static int ahci_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
-        void *port_mmio = (void *) ap->ioaddr.cmd_addr;
-
-        writel(1, port_mmio + PORT_SCR_ACT);
-        readl(port_mmio + PORT_SCR_ACT);        /* flush */
+        void __iomem *port_mmio = (void __iomem *) ap->ioaddr.cmd_addr;
 
         writel(1, port_mmio + PORT_CMD_ISSUE);
         readl(port_mmio + PORT_CMD_ISSUE);      /* flush */
@@ -882,7 +885,7 @@ static void ahci_print_info(struct ata_probe_ent *probe_ent)
 {
         struct ahci_host_priv *hpriv = probe_ent->private_data;
         struct pci_dev *pdev = to_pci_dev(probe_ent->dev);
-        void *mmio = probe_ent->mmio_base;
+        void __iomem *mmio = probe_ent->mmio_base;
         u32 vers, cap, impl, speed;
         const char *speed_s;
         u16 cc;
@@ -955,7 +958,7 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         struct ata_probe_ent *probe_ent = NULL;
         struct ahci_host_priv *hpriv;
         unsigned long base;
-        void *mmio_base;
+        void __iomem *mmio_base;
         unsigned int board_idx = (unsigned int) ent->driver_data;
         int have_msi, pci_dev_busy = 0;
         int rc;
@@ -992,8 +995,7 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap(pci_resource_start(pdev, AHCI_PCI_BAR),
-                            pci_resource_len(pdev, AHCI_PCI_BAR));
+        mmio_base = pci_iomap(pdev, AHCI_PCI_BAR, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
@@ -1037,7 +1039,7 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 err_out_hpriv:
         kfree(hpriv);
 err_out_iounmap:
-        iounmap(mmio_base);
+        pci_iounmap(pdev, mmio_base);
 err_out_free_ent:
         kfree(probe_ent);
 err_out_msi:
@@ -1077,7 +1079,8 @@ static void ahci_remove_one (struct pci_dev *pdev)
                 scsi_host_put(ap->host);
         }
 
-        host_set->ops->host_stop(host_set);
+        kfree(hpriv);
+        pci_iounmap(pdev, host_set->mmio_base);
         kfree(host_set);
 
         if (have_msi)
@@ -1094,7 +1097,6 @@ static int __init ahci_init(void)
         return pci_module_init(&ahci_pci_driver);
 }
 
-
 static void __exit ahci_exit(void)
 {
         pci_unregister_driver(&ahci_pci_driver);
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index d96ebf9d2228..deec0cef88d9 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -1,24 +1,42 @@
 /*
-
-    ata_piix.c - Intel PATA/SATA controllers
-
-    Maintained by:  Jeff Garzik <jgarzik@pobox.com>
-                    Please ALWAYS copy linux-ide@vger.kernel.org
-                    on emails.
-
-
-        Copyright 2003-2004 Red Hat Inc
-        Copyright 2003-2004 Jeff Garzik
-
-
-        Copyright header from piix.c:
-
-    Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
-    Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
-    Copyright (C) 2003 Red Hat Inc <alan@redhat.com>
-
-    May be copied or modified under the terms of the GNU General Public License
-
+ *    ata_piix.c - Intel PATA/SATA controllers
+ *
+ *    Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                  Please ALWAYS copy linux-ide@vger.kernel.org
+ *                  on emails.
+ *
+ *
+ *      Copyright 2003-2005 Red Hat Inc
+ *      Copyright 2003-2005 Jeff Garzik
+ *
+ *
+ *      Copyright header from piix.c:
+ *
+ *  Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
+ *  Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
+ *  Copyright (C) 2003 Red Hat Inc <alan@redhat.com>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available at http://developer.intel.com/
+ *
  */
 
 #include <linux/kernel.h>
@@ -565,8 +583,7 @@ static void pci_enable_intx(struct pci_dev *pdev)
 #define AHCI_ENABLE (1 << 31)
 static int piix_disable_ahci(struct pci_dev *pdev)
 {
-        void *mmio;
-        unsigned long addr;
+        void __iomem *mmio;
         u32 tmp;
         int rc = 0;
 
@@ -574,11 +591,11 @@ static int piix_disable_ahci(struct pci_dev *pdev)
          * works because this device is usually set up by BIOS.
          */
 
-        addr = pci_resource_start(pdev, AHCI_PCI_BAR);
-        if (!addr || !pci_resource_len(pdev, AHCI_PCI_BAR))
+        if (!pci_resource_start(pdev, AHCI_PCI_BAR) ||
+            !pci_resource_len(pdev, AHCI_PCI_BAR))
                 return 0;
 
-        mmio = ioremap(addr, 64);
+        mmio = pci_iomap(pdev, AHCI_PCI_BAR, 64);
         if (!mmio)
                 return -ENOMEM;
 
@@ -592,7 +609,7 @@ static int piix_disable_ahci(struct pci_dev *pdev)
                         rc = -EIO;
         }
 
-        iounmap(mmio);
+        pci_iounmap(pdev, mmio);
         return rc;
 }
 
@@ -629,13 +646,13 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         port_info[1] = NULL;
 
         if (port_info[0]->host_flags & PIIX_FLAG_AHCI) {
-               u8 tmp;
-               pci_read_config_byte(pdev, PIIX_SCC, &tmp);
-               if (tmp == PIIX_AHCI_DEVICE) {
-                       int rc = piix_disable_ahci(pdev);
-                       if (rc)
-                           return rc;
-               }
+                u8 tmp;
+                pci_read_config_byte(pdev, PIIX_SCC, &tmp);
+                if (tmp == PIIX_AHCI_DEVICE) {
+                        int rc = piix_disable_ahci(pdev);
+                        if (rc)
+                                return rc;
+                }
         }
 
         if (port_info[0]->host_flags & PIIX_FLAG_COMBINED) {
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 1b911dadf64b..5b14934ba861 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1531,7 +1531,7 @@ static int ibmvscsi_remove(struct vio_dev *vdev)
  */
 static struct vio_device_id ibmvscsi_device_table[] __devinitdata = {
         {"vscsi", "IBM,v-scsi"},
-        {0,}
+        { "", "" }
 };
 
 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
diff --git a/drivers/scsi/ibmvscsi/rpa_vscsi.c b/drivers/scsi/ibmvscsi/rpa_vscsi.c
index 035f615817d7..8bf5652f1060 100644
--- a/drivers/scsi/ibmvscsi/rpa_vscsi.c
+++ b/drivers/scsi/ibmvscsi/rpa_vscsi.c
@@ -28,6 +28,7 @@
  */
 
 #include <asm/vio.h>
+#include <asm/prom.h>
 #include <asm/iommu.h>
 #include <asm/hvcall.h>
 #include <linux/dma-mapping.h>
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index f4e7dcb6492b..5cc53cd9323e 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -1,25 +1,35 @@
 /*
-   libata-core.c - helper library for ATA
-
-   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
-   Copyright 2003-2004 Jeff Garzik
-
-   The contents of this file are subject to the Open
-   Software License version 1.1 that can be found at
-   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
-   by reference.
-
-   Alternatively, the contents of this file may be used under the terms
-   of the GNU General Public License version 2 (the "GPL") as distributed
-   in the kernel source COPYING file, in which case the provisions of
-   the GPL are applicable instead of the above.  If you wish to allow
-   the use of your version of this file only under the terms of the
-   GPL and not to allow others to use your version of this file under
-   the OSL, indicate your decision by deleting the provisions above and
-   replace them with the notice and other provisions required by the GPL.
-   If you do not delete the provisions above, a recipient may use your
-   version of this file under either the OSL or the GPL.
-
+ *  libata-core.c - helper library for ATA
+ *
+ *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                  Please ALWAYS copy linux-ide@vger.kernel.org
+ *                  on emails.
+ *
+ *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+ *  Copyright 2003-2004 Jeff Garzik
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available from http://www.t13.org/ and
+ *  http://www.sata-io.org/
+ *
  */
 
 #include <linux/config.h>
@@ -65,6 +75,10 @@ static void __ata_qc_complete(struct ata_queued_cmd *qc);
 static unsigned int ata_unique_id = 1;
 static struct workqueue_struct *ata_wq;
 
+int atapi_enabled = 0;
+module_param(atapi_enabled, int, 0444);
+MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
+
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
 MODULE_LICENSE("GPL");
@@ -1304,12 +1318,12 @@ static inline u8 ata_dev_knobble(struct ata_port *ap)
 /**
  *      ata_dev_config - Run device specific handlers and check for
  *                       SATA->PATA bridges
- *      @ap: Bus 
+ *      @ap: Bus
  *      @i:  Device
  *
  *      LOCKING:
  */
- 
+
 void ata_dev_config(struct ata_port *ap, unsigned int i)
 {
         /* limit bridge transfers to udma5, 200 sectors */
@@ -2377,6 +2391,27 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
 }
 
 /**
+ *      ata_poll_qc_complete - turn irq back on and finish qc
+ *      @qc: Command to complete
+ *      @drv_stat: ATA status register content
+ *
+ *      LOCKING:
+ *      None.  (grabs host lock)
+ */
+
+void ata_poll_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+{
+        struct ata_port *ap = qc->ap;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ap->host_set->lock, flags);
+        ap->flags &= ~ATA_FLAG_NOINTR;
+        ata_irq_on(ap);
+        ata_qc_complete(qc, drv_stat);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+}
+
+/**
  *      ata_pio_poll -
  *      @ap:
  *
@@ -2438,11 +2473,10 @@ static void ata_pio_complete (struct ata_port *ap)
         u8 drv_stat;
 
         /*
-         * This is purely hueristic.  This is a fast path.
-         * Sometimes when we enter, BSY will be cleared in
-         * a chk-status or two.  If not, the drive is probably seeking
-         * or something.  Snooze for a couple msecs, then
-         * chk-status again.  If still busy, fall back to
+         * This is purely heuristic.  This is a fast path.  Sometimes when
+         * we enter, BSY will be cleared in a chk-status or two.  If not,
+         * the drive is probably seeking or something.  Snooze for a couple
+         * msecs, then chk-status again.  If still busy, fall back to
          * PIO_ST_POLL state.
          */
         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
@@ -2467,9 +2501,7 @@ static void ata_pio_complete (struct ata_port *ap)
 
         ap->pio_task_state = PIO_ST_IDLE;
 
-        ata_irq_on(ap);
-
-        ata_qc_complete(qc, drv_stat);
+        ata_poll_qc_complete(qc, drv_stat);
 }
 
 
@@ -2494,6 +2526,20 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words)
 #endif /* __BIG_ENDIAN */
 }
 
+/**
+ *      ata_mmio_data_xfer - Transfer data by MMIO
+ *      @ap: port to read/write
+ *      @buf: data buffer
+ *      @buflen: buffer length
+ *      @write_data: read/write
+ *
+ *      Transfer data from/to the device data register by MMIO.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ *
+ */
+
 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
                                unsigned int buflen, int write_data)
 {
@@ -2502,6 +2548,7 @@ static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
         u16 *buf16 = (u16 *) buf;
         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
 
+        /* Transfer multiple of 2 bytes */
         if (write_data) {
                 for (i = 0; i < words; i++)
                         writew(le16_to_cpu(buf16[i]), mmio);
@@ -2509,19 +2556,76 @@ static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
                 for (i = 0; i < words; i++)
                         buf16[i] = cpu_to_le16(readw(mmio));
         }
+
+        /* Transfer trailing 1 byte, if any. */
+        if (unlikely(buflen & 0x01)) {
+                u16 align_buf[1] = { 0 };
+                unsigned char *trailing_buf = buf + buflen - 1;
+
+                if (write_data) {
+                        memcpy(align_buf, trailing_buf, 1);
+                        writew(le16_to_cpu(align_buf[0]), mmio);
+                } else {
+                        align_buf[0] = cpu_to_le16(readw(mmio));
+                        memcpy(trailing_buf, align_buf, 1);
+                }
+        }
 }
 
+/**
+ *      ata_pio_data_xfer - Transfer data by PIO
+ *      @ap: port to read/write
+ *      @buf: data buffer
+ *      @buflen: buffer length
+ *      @write_data: read/write
+ *
+ *      Transfer data from/to the device data register by PIO.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ *
+ */
+
 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
                               unsigned int buflen, int write_data)
 {
-        unsigned int dwords = buflen >> 1;
+        unsigned int words = buflen >> 1;
 
+        /* Transfer multiple of 2 bytes */
         if (write_data)
-                outsw(ap->ioaddr.data_addr, buf, dwords);
+                outsw(ap->ioaddr.data_addr, buf, words);
         else
-                insw(ap->ioaddr.data_addr, buf, dwords);
+                insw(ap->ioaddr.data_addr, buf, words);
+
+        /* Transfer trailing 1 byte, if any. */
+        if (unlikely(buflen & 0x01)) {
+                u16 align_buf[1] = { 0 };
+                unsigned char *trailing_buf = buf + buflen - 1;
+
+                if (write_data) {
+                        memcpy(align_buf, trailing_buf, 1);
+                        outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
+                } else {
+                        align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
+                        memcpy(trailing_buf, align_buf, 1);
+                }
+        }
 }
 
+/**
+ *      ata_data_xfer - Transfer data from/to the data register.
+ *      @ap: port to read/write
+ *      @buf: data buffer
+ *      @buflen: buffer length
+ *      @do_write: read/write
+ *
+ *      Transfer data from/to the device data register.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ *
+ */
+
 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
                           unsigned int buflen, int do_write)
 {
@@ -2531,6 +2635,16 @@ static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
                 ata_pio_data_xfer(ap, buf, buflen, do_write);
 }
 
+/**
+ *      ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
+ *      @qc: Command on going
+ *
+ *      Transfer ATA_SECT_SIZE of data from/to the ATA device.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+
 static void ata_pio_sector(struct ata_queued_cmd *qc)
 {
         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
@@ -2569,6 +2683,18 @@ static void ata_pio_sector(struct ata_queued_cmd *qc)
         kunmap(page);
 }
 
+/**
+ *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
+ *      @qc: Command on going
+ *      @bytes: number of bytes
+ *
+ *      Transfer Transfer data from/to the ATAPI device.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ *
+ */
+
 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
 {
         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
@@ -2578,10 +2704,33 @@ static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
         unsigned char *buf;
         unsigned int offset, count;
 
-        if (qc->curbytes == qc->nbytes - bytes)
+        if (qc->curbytes + bytes >= qc->nbytes)
                 ap->pio_task_state = PIO_ST_LAST;
 
 next_sg:
+        if (unlikely(qc->cursg >= qc->n_elem)) {
+                /* 
+                 * The end of qc->sg is reached and the device expects
+                 * more data to transfer. In order not to overrun qc->sg
+                 * and fulfill length specified in the byte count register,
+                 *    - for read case, discard trailing data from the device
+                 *    - for write case, padding zero data to the device
+                 */
+                u16 pad_buf[1] = { 0 };
+                unsigned int words = bytes >> 1;
+                unsigned int i;
+
+                if (words) /* warning if bytes > 1 */
+                        printk(KERN_WARNING "ata%u: %u bytes trailing data\n", 
+                               ap->id, bytes);
+
+                for (i = 0; i < words; i++)
+                        ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
+
+                ap->pio_task_state = PIO_ST_LAST;
+                return;
+        }
+
         sg = &qc->sg[qc->cursg];
 
         page = sg->page;
@@ -2615,11 +2764,21 @@ next_sg:
 
         kunmap(page);
 
-        if (bytes) {
+        if (bytes)
                 goto next_sg;
-        }
 }
 
+/**
+ *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
+ *      @qc: Command on going
+ *
+ *      Transfer Transfer data from/to the ATAPI device.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ *
+ */
+
 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
@@ -2692,9 +2851,7 @@ static void ata_pio_block(struct ata_port *ap)
                 if ((status & ATA_DRQ) == 0) {
                         ap->pio_task_state = PIO_ST_IDLE;
 
-                        ata_irq_on(ap);
-
-                        ata_qc_complete(qc, status);
+                        ata_poll_qc_complete(qc, status);
                         return;
                 }
 
@@ -2724,9 +2881,7 @@ static void ata_pio_error(struct ata_port *ap)
 
         ap->pio_task_state = PIO_ST_IDLE;
 
-        ata_irq_on(ap);
-
-        ata_qc_complete(qc, drv_stat | ATA_ERR);
+        ata_poll_qc_complete(qc, drv_stat | ATA_ERR);
 }
 
 static void ata_pio_task(void *_data)
@@ -2832,8 +2987,10 @@ static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
 static void ata_qc_timeout(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        struct ata_host_set *host_set = ap->host_set;
         struct ata_device *dev = qc->dev;
         u8 host_stat = 0, drv_stat;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
@@ -2844,7 +3001,9 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc)
                 if (!(cmd->eh_eflags & SCSI_EH_CANCEL_CMD)) {
 
                         /* finish completing original command */
+                        spin_lock_irqsave(&host_set->lock, flags);
                         __ata_qc_complete(qc);
+                        spin_unlock_irqrestore(&host_set->lock, flags);
 
                         atapi_request_sense(ap, dev, cmd);
 
@@ -2855,6 +3014,8 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc)
                 }
         }
 
+        spin_lock_irqsave(&host_set->lock, flags);
+
         /* hack alert!  We cannot use the supplied completion
          * function from inside the ->eh_strategy_handler() thread.
          * libata is the only user of ->eh_strategy_handler() in
@@ -2870,7 +3031,7 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc)
                 host_stat = ap->ops->bmdma_status(ap);
 
                 /* before we do anything else, clear DMA-Start bit */
-                ap->ops->bmdma_stop(ap);
+                ap->ops->bmdma_stop(qc);
 
                 /* fall through */
 
@@ -2888,6 +3049,9 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc)
                 ata_qc_complete(qc, drv_stat);
                 break;
         }
+
+        spin_unlock_irqrestore(&host_set->lock, flags);
+
 out:
         DPRINTK("EXIT\n");
 }
@@ -3061,9 +3225,14 @@ void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
                 ata_sg_clean(qc);
 
+        /* atapi: mark qc as inactive to prevent the interrupt handler
+         * from completing the command twice later, before the error handler
+         * is called. (when rc != 0 and atapi request sense is needed)
+         */
+        qc->flags &= ~ATA_QCFLAG_ACTIVE;
+
         /* call completion callback */
         rc = qc->complete_fn(qc, drv_stat);
-        qc->flags &= ~ATA_QCFLAG_ACTIVE;
 
         /* if callback indicates not to complete command (non-zero),
          * return immediately
@@ -3193,11 +3362,13 @@ int ata_qc_issue_prot(struct ata_queued_cmd *qc)
                 break;
 
         case ATA_PROT_ATAPI_NODATA:
+                ap->flags |= ATA_FLAG_NOINTR;
                 ata_tf_to_host_nolock(ap, &qc->tf);
                 queue_work(ata_wq, &ap->packet_task);
                 break;
 
         case ATA_PROT_ATAPI_DMA:
+                ap->flags |= ATA_FLAG_NOINTR;
                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
                 queue_work(ata_wq, &ap->packet_task);
@@ -3242,7 +3413,7 @@ static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
 }
 
 /**
- *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
+ *      ata_bmdma_start_mmio - Start a PCI IDE BMDMA transaction
  *      @qc: Info associated with this ATA transaction.
  *
  *      LOCKING:
@@ -3413,7 +3584,7 @@ u8 ata_bmdma_status(struct ata_port *ap)
 
 /**
  *      ata_bmdma_stop - Stop PCI IDE BMDMA transfer
- *      @ap: Port associated with this ATA transaction.
+ *      @qc: Command we are ending DMA for
  *
  *      Clears the ATA_DMA_START flag in the dma control register
  *
@@ -3423,8 +3594,9 @@ u8 ata_bmdma_status(struct ata_port *ap)
  *      spin_lock_irqsave(host_set lock)
  */
 
-void ata_bmdma_stop(struct ata_port *ap)
+void ata_bmdma_stop(struct ata_queued_cmd *qc)
 {
+        struct ata_port *ap = qc->ap;
         if (ap->flags & ATA_FLAG_MMIO) {
                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 
@@ -3476,7 +3648,7 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
                         goto idle_irq;
 
                 /* before we do anything else, clear DMA-Start bit */
-                ap->ops->bmdma_stop(ap);
+                ap->ops->bmdma_stop(qc);
 
                 /* fall through */
 
@@ -3551,7 +3723,8 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
                 struct ata_port *ap;
 
                 ap = host_set->ports[i];
-                if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                if (ap &&
+                    !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
                         struct ata_queued_cmd *qc;
 
                         qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -3603,19 +3776,27 @@ static void atapi_packet_task(void *_data)
         /* send SCSI cdb */
         DPRINTK("send cdb\n");
         assert(ap->cdb_len >= 12);
-        ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 
-        /* if we are DMA'ing, irq handler takes over from here */
-        if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
-                ap->ops->bmdma_start(qc);           /* initiate bmdma */
+        if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
+            qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
+                unsigned long flags;
 
-        /* non-data commands are also handled via irq */
-        else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
-                /* do nothing */
-        }
+                /* Once we're done issuing command and kicking bmdma,
+                 * irq handler takes over.  To not lose irq, we need
+                 * to clear NOINTR flag before sending cdb, but
+                 * interrupt handler shouldn't be invoked before we're
+                 * finished.  Hence, the following locking.
+                 */
+                spin_lock_irqsave(&ap->host_set->lock, flags);
+                ap->flags &= ~ATA_FLAG_NOINTR;
+                ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
+                if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
+                        ap->ops->bmdma_start(qc);       /* initiate bmdma */
+                spin_unlock_irqrestore(&ap->host_set->lock, flags);
+        } else {
+                ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 
-        /* PIO commands are handled by polling */
-        else {
+                /* PIO commands are handled by polling */
                 ap->pio_task_state = PIO_ST;
                 queue_work(ata_wq, &ap->pio_task);
         }
@@ -3623,7 +3804,7 @@ static void atapi_packet_task(void *_data)
         return;
 
 err_out:
-        ata_qc_complete(qc, ATA_ERR);
+        ata_poll_qc_complete(qc, ATA_ERR);
 }
 
 
@@ -4023,6 +4204,15 @@ ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
 
 
 
+#ifdef CONFIG_PCI
+
+void ata_pci_host_stop (struct ata_host_set *host_set)
+{
+        struct pci_dev *pdev = to_pci_dev(host_set->dev);
+
+        pci_iounmap(pdev, host_set->mmio_base);
+}
+
 /**
  *      ata_pci_init_native_mode - Initialize native-mode driver
  *      @pdev:  pci device to be initialized
@@ -4035,7 +4225,6 @@ ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
  *      ata_probe_ent structure should then be freed with kfree().
  */
 
-#ifdef CONFIG_PCI
 struct ata_probe_ent *
 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
 {
@@ -4418,6 +4607,7 @@ EXPORT_SYMBOL_GPL(ata_scsi_simulate);
 
 #ifdef CONFIG_PCI
 EXPORT_SYMBOL_GPL(pci_test_config_bits);
+EXPORT_SYMBOL_GPL(ata_pci_host_stop);
 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
 EXPORT_SYMBOL_GPL(ata_pci_init_one);
 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 6a75ec2187fd..104fd9a63e73 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -1,25 +1,36 @@
 /*
-   libata-scsi.c - helper library for ATA
-
-   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
-   Copyright 2003-2004 Jeff Garzik
-
-   The contents of this file are subject to the Open
-   Software License version 1.1 that can be found at
-   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
-   by reference.
-
-   Alternatively, the contents of this file may be used under the terms
-   of the GNU General Public License version 2 (the "GPL") as distributed
-   in the kernel source COPYING file, in which case the provisions of
-   the GPL are applicable instead of the above.  If you wish to allow
-   the use of your version of this file only under the terms of the
-   GPL and not to allow others to use your version of this file under
-   the OSL, indicate your decision by deleting the provisions above and
-   replace them with the notice and other provisions required by the GPL.
-   If you do not delete the provisions above, a recipient may use your
-   version of this file under either the OSL or the GPL.
-
+ *  libata-scsi.c - helper library for ATA
+ *
+ *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                  Please ALWAYS copy linux-ide@vger.kernel.org
+ *                  on emails.
+ *
+ *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+ *  Copyright 2003-2004 Jeff Garzik
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available from
+ *  - http://www.t10.org/
+ *  - http://www.t13.org/
+ *
  */
 
 #include <linux/kernel.h>
@@ -392,6 +403,60 @@ int ata_scsi_error(struct Scsi_Host *host)
 }
 
 /**
+ *      ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
+ *      @qc: Storage for translated ATA taskfile
+ *      @scsicmd: SCSI command to translate
+ *
+ *      Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
+ *      (to start). Perhaps these commands should be preceded by
+ *      CHECK POWER MODE to see what power mode the device is already in.
+ *      [See SAT revision 5 at www.t10.org]
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ *
+ *      RETURNS:
+ *      Zero on success, non-zero on error.
+ */
+
+static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
+                                             u8 *scsicmd)
+{
+        struct ata_taskfile *tf = &qc->tf;
+
+        tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
+        tf->protocol = ATA_PROT_NODATA;
+        if (scsicmd[1] & 0x1) {
+                ;       /* ignore IMMED bit, violates sat-r05 */
+        }
+        if (scsicmd[4] & 0x2)
+                return 1;       /* LOEJ bit set not supported */
+        if (((scsicmd[4] >> 4) & 0xf) != 0)
+                return 1;       /* power conditions not supported */
+        if (scsicmd[4] & 0x1) {
+                tf->nsect = 1;  /* 1 sector, lba=0 */
+                tf->lbah = 0x0;
+                tf->lbam = 0x0;
+                tf->lbal = 0x0;
+                tf->device |= ATA_LBA;
+                tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
+        } else {
+                tf->nsect = 0;  /* time period value (0 implies now) */
+                tf->command = ATA_CMD_STANDBY;
+                /* Consider: ATA STANDBY IMMEDIATE command */
+        }
+        /*
+         * Standby and Idle condition timers could be implemented but that
+         * would require libata to implement the Power condition mode page
+         * and allow the user to change it. Changing mode pages requires
+         * MODE SELECT to be implemented.
+         */
+
+        return 0;
+}
+
+
+/**
  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
  *      @qc: Storage for translated ATA taskfile
  *      @scsicmd: SCSI command to translate (ignored)
@@ -576,11 +641,19 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
                 tf->lbah = scsicmd[3];
 
                 VPRINTK("ten-byte command\n");
+                if (qc->nsect == 0) /* we don't support length==0 cmds */
+                        return 1;
                 return 0;
         }
 
         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
                 qc->nsect = tf->nsect = scsicmd[4];
+                if (!qc->nsect) {
+                        qc->nsect = 256;
+                        if (lba48)
+                                tf->hob_nsect = 1;
+                }
+
                 tf->lbal = scsicmd[3];
                 tf->lbam = scsicmd[2];
                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
@@ -620,6 +693,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
                 tf->lbah = scsicmd[7];
 
                 VPRINTK("sixteen-byte command\n");
+                if (qc->nsect == 0) /* we don't support length==0 cmds */
+                        return 1;
                 return 0;
         }
 
@@ -1395,10 +1470,10 @@ ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
         if (unlikely(!ata_dev_present(dev)))
                 return NULL;
 
-#ifndef ATA_ENABLE_ATAPI
-        if (unlikely(dev->class == ATA_DEV_ATAPI))
-                return NULL;
-#endif
+        if (!atapi_enabled) {
+                if (unlikely(dev->class == ATA_DEV_ATAPI))
+                        return NULL;
+        }
 
         return dev;
 }
@@ -1435,6 +1510,8 @@ static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
         case VERIFY:
         case VERIFY_16:
                 return ata_scsi_verify_xlat;
+        case START_STOP:
+                return ata_scsi_start_stop_xlat;
         }
 
         return NULL;
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index 3e7f4843020f..d608b3a0f6fe 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -1,25 +1,28 @@
 /*
-   libata.h - helper library for ATA
-
-   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
-   Copyright 2003-2004 Jeff Garzik
-
-   The contents of this file are subject to the Open
-   Software License version 1.1 that can be found at
-   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
-   by reference.
-
-   Alternatively, the contents of this file may be used under the terms
-   of the GNU General Public License version 2 (the "GPL") as distributed
-   in the kernel source COPYING file, in which case the provisions of
-   the GPL are applicable instead of the above.  If you wish to allow
-   the use of your version of this file only under the terms of the
-   GPL and not to allow others to use your version of this file under
-   the OSL, indicate your decision by deleting the provisions above and
-   replace them with the notice and other provisions required by the GPL.
-   If you do not delete the provisions above, a recipient may use your
-   version of this file under either the OSL or the GPL.
-
+ *  libata.h - helper library for ATA
+ *
+ *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+ *  Copyright 2003-2004 Jeff Garzik
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
  */
 
 #ifndef __LIBATA_H__
@@ -35,6 +38,7 @@ struct ata_scsi_args {
 };
 
 /* libata-core.c */
+extern int atapi_enabled;
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
                                       struct ata_device *dev);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
@@ -72,7 +76,7 @@ extern unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
 extern void ata_scsi_badcmd(struct scsi_cmnd *cmd,
                             void (*done)(struct scsi_cmnd *),
                             u8 asc, u8 ascq);
-extern void ata_scsi_rbuf_fill(struct ata_scsi_args *args, 
+extern void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
                         unsigned int (*actor) (struct ata_scsi_args *args,
                                            u8 *rbuf, unsigned int buflen));
 
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index ff1933298da6..a4857db4f9b8 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1766,7 +1766,7 @@ static int mesh_suspend(struct macio_dev *mdev, pm_message_t state)
         struct mesh_state *ms = (struct mesh_state *)macio_get_drvdata(mdev);
         unsigned long flags;
 
-        if (state == mdev->ofdev.dev.power.power_state || state < 2)
+        if (state.event == mdev->ofdev.dev.power.power_state.event || state.event < 2)
                 return 0;
 
         scsi_block_requests(ms->host);
@@ -1791,7 +1791,7 @@ static int mesh_resume(struct macio_dev *mdev)
         struct mesh_state *ms = (struct mesh_state *)macio_get_drvdata(mdev);
         unsigned long flags;
 
-        if (mdev->ofdev.dev.power.power_state == 0)
+        if (mdev->ofdev.dev.power.power_state.event == PM_EVENT_ON)
                 return 0;
 
         set_mesh_power(ms, 1);
@@ -1802,7 +1802,7 @@ static int mesh_resume(struct macio_dev *mdev)
         enable_irq(ms->meshintr);
         scsi_unblock_requests(ms->host);
 
-        mdev->ofdev.dev.power.power_state = 0;
+        mdev->ofdev.dev.power.power_state.event = PM_EVENT_ON;
 
         return 0;
 }
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
new file mode 100644
index 000000000000..f97e3afa97d9
--- /dev/null
+++ b/drivers/scsi/sata_mv.c
@@ -0,0 +1,843 @@
+/*
+ * sata_mv.c - Marvell SATA support
+ *
+ * Copyright 2005: EMC Corporation, all rights reserved. 
+ *
+ * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/dma-mapping.h>
+#include "scsi.h"
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <asm/io.h>
+
+#define DRV_NAME        "sata_mv"
+#define DRV_VERSION     "0.12"
+
+enum {
+        /* BAR's are enumerated in terms of pci_resource_start() terms */
+        MV_PRIMARY_BAR          = 0,    /* offset 0x10: memory space */
+        MV_IO_BAR               = 2,    /* offset 0x18: IO space */
+        MV_MISC_BAR             = 3,    /* offset 0x1c: FLASH, NVRAM, SRAM */
+
+        MV_MAJOR_REG_AREA_SZ    = 0x10000,      /* 64KB */
+        MV_MINOR_REG_AREA_SZ    = 0x2000,       /* 8KB */
+
+        MV_PCI_REG_BASE         = 0,
+        MV_IRQ_COAL_REG_BASE    = 0x18000,      /* 6xxx part only */
+        MV_SATAHC0_REG_BASE     = 0x20000,
+
+        MV_PCI_REG_SZ           = MV_MAJOR_REG_AREA_SZ,
+        MV_SATAHC_REG_SZ        = MV_MAJOR_REG_AREA_SZ,
+        MV_SATAHC_ARBTR_REG_SZ  = MV_MINOR_REG_AREA_SZ,         /* arbiter */
+        MV_PORT_REG_SZ          = MV_MINOR_REG_AREA_SZ,
+
+        MV_Q_CT                 = 32,
+        MV_CRQB_SZ              = 32,
+        MV_CRPB_SZ              = 8,
+
+        MV_DMA_BOUNDARY         = 0xffffffffU,
+        SATAHC_MASK             = (~(MV_SATAHC_REG_SZ - 1)),
+
+        MV_PORTS_PER_HC         = 4,
+        /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
+        MV_PORT_HC_SHIFT        = 2,
+        /* == (port % MV_PORTS_PER_HC) to determine port from 0-7 port */
+        MV_PORT_MASK            = 3,
+
+        /* Host Flags */
+        MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
+        MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
+        MV_FLAG_BDMA            = (1 << 28),  /* Basic DMA */
+
+        chip_504x               = 0,
+        chip_508x               = 1,
+        chip_604x               = 2,
+        chip_608x               = 3,
+
+        /* PCI interface registers */
+
+        PCI_MAIN_CMD_STS_OFS    = 0xd30,
+        STOP_PCI_MASTER         = (1 << 2),
+        PCI_MASTER_EMPTY        = (1 << 3),
+        GLOB_SFT_RST            = (1 << 4),
+
+        PCI_IRQ_CAUSE_OFS       = 0x1d58,
+        PCI_IRQ_MASK_OFS        = 0x1d5c,
+        PCI_UNMASK_ALL_IRQS     = 0x7fffff,     /* bits 22-0 */
+
+        HC_MAIN_IRQ_CAUSE_OFS   = 0x1d60,
+        HC_MAIN_IRQ_MASK_OFS    = 0x1d64,
+        PORT0_ERR               = (1 << 0),     /* shift by port # */
+        PORT0_DONE              = (1 << 1),     /* shift by port # */
+        HC0_IRQ_PEND            = 0x1ff,        /* bits 0-8 = HC0's ports */
+        HC_SHIFT                = 9,            /* bits 9-17 = HC1's ports */
+        PCI_ERR                 = (1 << 18),
+        TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
+        TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
+        PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
+        GPIO_INT                = (1 << 22),
+        SELF_INT                = (1 << 23),
+        TWSI_INT                = (1 << 24),
+        HC_MAIN_RSVD            = (0x7f << 25), /* bits 31-25 */
+        HC_MAIN_MASKED_IRQS     = (TRAN_LO_DONE | TRAN_HI_DONE | 
+                                   PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
+                                   HC_MAIN_RSVD),
+
+        /* SATAHC registers */
+        HC_CFG_OFS              = 0,
+
+        HC_IRQ_CAUSE_OFS        = 0x14,
+        CRBP_DMA_DONE           = (1 << 0),     /* shift by port # */
+        HC_IRQ_COAL             = (1 << 4),     /* IRQ coalescing */
+        DEV_IRQ                 = (1 << 8),     /* shift by port # */
+
+        /* Shadow block registers */
+        SHD_PIO_DATA_OFS        = 0x100,
+        SHD_FEA_ERR_OFS         = 0x104,
+        SHD_SECT_CNT_OFS        = 0x108,
+        SHD_LBA_L_OFS           = 0x10C,
+        SHD_LBA_M_OFS           = 0x110,
+        SHD_LBA_H_OFS           = 0x114,
+        SHD_DEV_HD_OFS          = 0x118,
+        SHD_CMD_STA_OFS         = 0x11C,
+        SHD_CTL_AST_OFS         = 0x120,
+
+        /* SATA registers */
+        SATA_STATUS_OFS         = 0x300,  /* ctrl, err regs follow status */
+        SATA_ACTIVE_OFS         = 0x350,
+
+        /* Port registers */
+        EDMA_CFG_OFS            = 0,
+
+        EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
+        EDMA_ERR_IRQ_MASK_OFS   = 0xc,
+        EDMA_ERR_D_PAR          = (1 << 0),
+        EDMA_ERR_PRD_PAR        = (1 << 1),
+        EDMA_ERR_DEV            = (1 << 2),
+        EDMA_ERR_DEV_DCON       = (1 << 3),
+        EDMA_ERR_DEV_CON        = (1 << 4),
+        EDMA_ERR_SERR           = (1 << 5),
+        EDMA_ERR_SELF_DIS       = (1 << 7),
+        EDMA_ERR_BIST_ASYNC     = (1 << 8),
+        EDMA_ERR_CRBQ_PAR       = (1 << 9),
+        EDMA_ERR_CRPB_PAR       = (1 << 10),
+        EDMA_ERR_INTRL_PAR      = (1 << 11),
+        EDMA_ERR_IORDY          = (1 << 12),
+        EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),
+        EDMA_ERR_LNK_CTRL_RX_2  = (1 << 15),
+        EDMA_ERR_LNK_DATA_RX    = (0xf << 17),
+        EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21),
+        EDMA_ERR_LNK_DATA_TX    = (0x1f << 26),
+        EDMA_ERR_TRANS_PROTO    = (1 << 31),
+        EDMA_ERR_FATAL          = (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR | 
+                                   EDMA_ERR_DEV_DCON | EDMA_ERR_CRBQ_PAR |
+                                   EDMA_ERR_CRPB_PAR | EDMA_ERR_INTRL_PAR |
+                                   EDMA_ERR_IORDY | EDMA_ERR_LNK_CTRL_RX_2 | 
+                                   EDMA_ERR_LNK_DATA_RX |
+                                   EDMA_ERR_LNK_DATA_TX | 
+                                   EDMA_ERR_TRANS_PROTO),
+
+        EDMA_CMD_OFS            = 0x28,
+        EDMA_EN                 = (1 << 0),
+        EDMA_DS                 = (1 << 1),
+        ATA_RST                 = (1 << 2),
+
+        /* BDMA is 6xxx part only */
+        BDMA_CMD_OFS            = 0x224,
+        BDMA_START              = (1 << 0),
+
+        MV_UNDEF                = 0,
+};
+
+struct mv_port_priv {
+
+};
+
+struct mv_host_priv {
+
+};
+
+static void mv_irq_clear(struct ata_port *ap);
+static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
+static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
+static void mv_phy_reset(struct ata_port *ap);
+static int mv_master_reset(void __iomem *mmio_base);
+static irqreturn_t mv_interrupt(int irq, void *dev_instance,
+                                struct pt_regs *regs);
+static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
+
+static Scsi_Host_Template mv_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .eh_strategy_handler    = ata_scsi_error,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = MV_UNDEF,
+        .max_sectors            = ATA_MAX_SECTORS,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = MV_UNDEF,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = MV_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .bios_param             = ata_std_bios_param,
+        .ordered_flush          = 1,
+};
+
+static struct ata_port_operations mv_ops = {
+        .port_disable           = ata_port_disable,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .phy_reset              = mv_phy_reset,
+
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .eng_timeout            = ata_eng_timeout,
+
+        .irq_handler            = mv_interrupt,
+        .irq_clear              = mv_irq_clear,
+
+        .scr_read               = mv_scr_read,
+        .scr_write              = mv_scr_write,
+
+        .port_start             = ata_port_start,
+        .port_stop              = ata_port_stop,
+        .host_stop              = ata_host_stop,
+};
+
+static struct ata_port_info mv_port_info[] = {
+        {  /* chip_504x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_508x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
+                                   MV_FLAG_DUAL_HC),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_604x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
+                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_BDMA),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_608x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
+                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_DUAL_HC |
+                                   MV_FLAG_BDMA),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+};
+
+static struct pci_device_id mv_pci_tbl[] = {
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5040), 0, 0, chip_504x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5041), 0, 0, chip_504x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5080), 0, 0, chip_508x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5081), 0, 0, chip_508x},
+
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6040), 0, 0, chip_604x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6041), 0, 0, chip_604x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6080), 0, 0, chip_608x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6081), 0, 0, chip_608x},
+        {}                      /* terminate list */
+};
+
+static struct pci_driver mv_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = mv_pci_tbl,
+        .probe                  = mv_init_one,
+        .remove                 = ata_pci_remove_one,
+};
+
+/*
+ * Functions
+ */
+
+static inline void writelfl(unsigned long data, void __iomem *addr)
+{
+        writel(data, addr);
+        (void) readl(addr);     /* flush to avoid PCI posted write */
+}
+
+static inline void __iomem *mv_port_addr_to_hc_base(void __iomem *port_mmio)
+{
+        return ((void __iomem *)((unsigned long)port_mmio & 
+                                 (unsigned long)SATAHC_MASK));
+}
+
+static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
+{
+        return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
+}
+
+static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
+{
+        return (mv_hc_base(base, port >> MV_PORT_HC_SHIFT) +
+                MV_SATAHC_ARBTR_REG_SZ + 
+                ((port & MV_PORT_MASK) * MV_PORT_REG_SZ));
+}
+
+static inline void __iomem *mv_ap_base(struct ata_port *ap)
+{
+        return mv_port_base(ap->host_set->mmio_base, ap->port_no);
+}
+
+static inline int mv_get_hc_count(unsigned long flags)
+{
+        return ((flags & MV_FLAG_DUAL_HC) ? 2 : 1);
+}
+
+static inline int mv_is_edma_active(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        return (EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
+}
+
+static inline int mv_port_bdma_capable(struct ata_port *ap)
+{
+        return (ap->flags & MV_FLAG_BDMA);
+}
+
+static void mv_irq_clear(struct ata_port *ap)
+{
+}
+
+static unsigned int mv_scr_offset(unsigned int sc_reg_in)
+{
+        unsigned int ofs;
+
+        switch (sc_reg_in) {
+        case SCR_STATUS:
+        case SCR_CONTROL:
+        case SCR_ERROR:
+                ofs = SATA_STATUS_OFS + (sc_reg_in * sizeof(u32));
+                break;
+        case SCR_ACTIVE:
+                ofs = SATA_ACTIVE_OFS;   /* active is not with the others */
+                break;
+        default:
+                ofs = 0xffffffffU;
+                break;
+        }
+        return ofs;
+}
+
+static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
+{
+        unsigned int ofs = mv_scr_offset(sc_reg_in);
+
+        if (0xffffffffU != ofs) {
+                return readl(mv_ap_base(ap) + ofs);
+        } else {
+                return (u32) ofs;
+        }
+}
+
+static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
+{
+        unsigned int ofs = mv_scr_offset(sc_reg_in);
+
+        if (0xffffffffU != ofs) {
+                writelfl(val, mv_ap_base(ap) + ofs);
+        }
+}
+
+static int mv_master_reset(void __iomem *mmio_base)
+{
+        void __iomem *reg = mmio_base + PCI_MAIN_CMD_STS_OFS;
+        int i, rc = 0;
+        u32 t;
+
+        VPRINTK("ENTER\n");
+
+        /* Following procedure defined in PCI "main command and status
+         * register" table.
+         */
+        t = readl(reg);
+        writel(t | STOP_PCI_MASTER, reg);
+
+        for (i = 0; i < 100; i++) {
+                msleep(10);
+                t = readl(reg);
+                if (PCI_MASTER_EMPTY & t) {
+                        break;
+                }
+        }
+        if (!(PCI_MASTER_EMPTY & t)) {
+                printk(KERN_ERR DRV_NAME "PCI master won't flush\n");
+                rc = 1;         /* broken HW? */
+                goto done;
+        }
+
+        /* set reset */
+        i = 5;
+        do {
+                writel(t | GLOB_SFT_RST, reg);
+                t = readl(reg);
+                udelay(1);
+        } while (!(GLOB_SFT_RST & t) && (i-- > 0));
+
+        if (!(GLOB_SFT_RST & t)) {
+                printk(KERN_ERR DRV_NAME "can't set global reset\n");
+                rc = 1;         /* broken HW? */
+                goto done;
+        }
+
+        /* clear reset */
+        i = 5;
+        do {
+                writel(t & ~GLOB_SFT_RST, reg);
+                t = readl(reg);
+                udelay(1);
+        } while ((GLOB_SFT_RST & t) && (i-- > 0));
+
+        if (GLOB_SFT_RST & t) {
+                printk(KERN_ERR DRV_NAME "can't clear global reset\n");
+                rc = 1;         /* broken HW? */
+        }
+
+ done:
+        VPRINTK("EXIT, rc = %i\n", rc);
+        return rc;
+}
+
+static void mv_err_intr(struct ata_port *ap)
+{
+        void __iomem *port_mmio;
+        u32 edma_err_cause, serr = 0;
+
+        /* bug here b/c we got an err int on a port we don't know about,
+         * so there's no way to clear it
+         */
+        BUG_ON(NULL == ap);
+        port_mmio = mv_ap_base(ap);
+
+        edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+
+        if (EDMA_ERR_SERR & edma_err_cause) {
+                serr = scr_read(ap, SCR_ERROR);
+                scr_write_flush(ap, SCR_ERROR, serr);
+        }
+        DPRINTK("port %u error; EDMA err cause: 0x%08x SERR: 0x%08x\n", 
+                ap->port_no, edma_err_cause, serr);
+
+        /* Clear EDMA now that SERR cleanup done */
+        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+
+        /* check for fatal here and recover if needed */
+        if (EDMA_ERR_FATAL & edma_err_cause) {
+                mv_phy_reset(ap);
+        }
+}
+
+/* Handle any outstanding interrupts in a single SATAHC 
+ */
+static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
+                         unsigned int hc)
+{
+        void __iomem *mmio = host_set->mmio_base;
+        void __iomem *hc_mmio = mv_hc_base(mmio, hc);
+        struct ata_port *ap;
+        struct ata_queued_cmd *qc;
+        u32 hc_irq_cause;
+        int shift, port, port0, hard_port;
+        u8 ata_status;
+
+        if (hc == 0) {
+                port0 = 0;
+        } else {
+                port0 = MV_PORTS_PER_HC;
+        }
+
+        /* we'll need the HC success int register in most cases */
+        hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
+        if (hc_irq_cause) {
+                writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
+        }
+
+        VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
+                hc,relevant,hc_irq_cause);
+
+        for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
+                ap = host_set->ports[port];
+                hard_port = port & MV_PORT_MASK;        /* range 0-3 */
+                ata_status = 0xffU;
+
+                if (((CRBP_DMA_DONE | DEV_IRQ) << hard_port) & hc_irq_cause) {
+                        BUG_ON(NULL == ap);
+                        /* rcv'd new resp, basic DMA complete, or ATA IRQ */
+                        /* This is needed to clear the ATA INTRQ.
+                         * FIXME: don't read the status reg in EDMA mode!
+                         */
+                        ata_status = readb((void __iomem *)
+                                           ap->ioaddr.status_addr);
+                }
+
+                shift = port * 2;
+                if (port >= MV_PORTS_PER_HC) {
+                        shift++;        /* skip bit 8 in the HC Main IRQ reg */
+                }
+                if ((PORT0_ERR << shift) & relevant) {
+                        mv_err_intr(ap);
+                        /* FIXME: smart to OR in ATA_ERR? */
+                        ata_status = readb((void __iomem *)
+                                           ap->ioaddr.status_addr) | ATA_ERR;
+                }
+                
+                if (ap) {
+                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        if (NULL != qc) {
+                                VPRINTK("port %u IRQ found for qc, "
+                                        "ata_status 0x%x\n", port,ata_status);
+                                BUG_ON(0xffU == ata_status);
+                                /* mark qc status appropriately */
+                                ata_qc_complete(qc, ata_status);
+                        }
+                }
+        }
+        VPRINTK("EXIT\n");
+}
+
+static irqreturn_t mv_interrupt(int irq, void *dev_instance,
+                                struct pt_regs *regs)
+{
+        struct ata_host_set *host_set = dev_instance;
+        unsigned int hc, handled = 0, n_hcs;
+        void __iomem *mmio;
+        u32 irq_stat;
+
+        mmio = host_set->mmio_base;
+        irq_stat = readl(mmio + HC_MAIN_IRQ_CAUSE_OFS);
+        n_hcs = mv_get_hc_count(host_set->ports[0]->flags);
+
+        /* check the cases where we either have nothing pending or have read
+         * a bogus register value which can indicate HW removal or PCI fault
+         */
+        if (!irq_stat || (0xffffffffU == irq_stat)) {
+                return IRQ_NONE;
+        }
+
+        spin_lock(&host_set->lock);
+
+        for (hc = 0; hc < n_hcs; hc++) {
+                u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
+                if (relevant) {
+                        mv_host_intr(host_set, relevant, hc);
+                        handled = 1;
+                }
+        }
+        if (PCI_ERR & irq_stat) {
+                /* FIXME: these are all masked by default, but still need
+                 * to recover from them properly.
+                 */
+        }
+
+        spin_unlock(&host_set->lock);
+
+        return IRQ_RETVAL(handled);
+}
+
+static void mv_phy_reset(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        struct ata_taskfile tf;
+        struct ata_device *dev = &ap->device[0];
+        u32 edma = 0, bdma;
+
+        VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
+
+        edma = readl(port_mmio + EDMA_CMD_OFS);
+        if (EDMA_EN & edma) {
+                /* disable EDMA if active */
+                edma &= ~EDMA_EN;
+                writelfl(edma | EDMA_DS, port_mmio + EDMA_CMD_OFS);
+                udelay(1);
+        } else if (mv_port_bdma_capable(ap) &&
+                   (bdma = readl(port_mmio + BDMA_CMD_OFS)) & BDMA_START) {
+                /* disable BDMA if active */
+                writelfl(bdma & ~BDMA_START, port_mmio + BDMA_CMD_OFS);
+        }
+
+        writelfl(edma | ATA_RST, port_mmio + EDMA_CMD_OFS);
+        udelay(25);             /* allow reset propagation */
+
+        /* Spec never mentions clearing the bit.  Marvell's driver does
+         * clear the bit, however.
+         */
+        writelfl(edma & ~ATA_RST, port_mmio + EDMA_CMD_OFS);
+
+        VPRINTK("Done.  Now calling __sata_phy_reset()\n");
+
+        /* proceed to init communications via the scr_control reg */
+        __sata_phy_reset(ap);
+
+        if (ap->flags & ATA_FLAG_PORT_DISABLED) {
+                VPRINTK("Port disabled pre-sig.  Exiting.\n");
+                return;
+        }
+
+        tf.lbah = readb((void __iomem *) ap->ioaddr.lbah_addr);
+        tf.lbam = readb((void __iomem *) ap->ioaddr.lbam_addr);
+        tf.lbal = readb((void __iomem *) ap->ioaddr.lbal_addr);
+        tf.nsect = readb((void __iomem *) ap->ioaddr.nsect_addr);
+
+        dev->class = ata_dev_classify(&tf);
+        if (!ata_dev_present(dev)) {
+                VPRINTK("Port disabled post-sig: No device present.\n");
+                ata_port_disable(ap);
+        }
+        VPRINTK("EXIT\n");
+}
+
+static void mv_port_init(struct ata_ioports *port, unsigned long base)
+{
+        /* PIO related setup */
+        port->data_addr = base + SHD_PIO_DATA_OFS;
+        port->error_addr = port->feature_addr = base + SHD_FEA_ERR_OFS;
+        port->nsect_addr = base + SHD_SECT_CNT_OFS;
+        port->lbal_addr = base + SHD_LBA_L_OFS;
+        port->lbam_addr = base + SHD_LBA_M_OFS;
+        port->lbah_addr = base + SHD_LBA_H_OFS;
+        port->device_addr = base + SHD_DEV_HD_OFS;
+        port->status_addr = port->command_addr = base + SHD_CMD_STA_OFS;
+        port->altstatus_addr = port->ctl_addr = base + SHD_CTL_AST_OFS;
+        /* unused */
+        port->cmd_addr = port->bmdma_addr = port->scr_addr = 0;
+
+        /* unmask all EDMA error interrupts */
+        writel(~0, (void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS);
+
+        VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n", 
+                readl((void __iomem *)base + EDMA_CFG_OFS),
+                readl((void __iomem *)base + EDMA_ERR_IRQ_CAUSE_OFS),
+                readl((void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS));
+}
+
+static int mv_host_init(struct ata_probe_ent *probe_ent)
+{
+        int rc = 0, n_hc, port, hc;
+        void __iomem *mmio = probe_ent->mmio_base;
+        void __iomem *port_mmio;
+
+        if (mv_master_reset(probe_ent->mmio_base)) {
+                rc = 1;
+                goto done;
+        }
+
+        n_hc = mv_get_hc_count(probe_ent->host_flags);
+        probe_ent->n_ports = MV_PORTS_PER_HC * n_hc;
+
+        for (port = 0; port < probe_ent->n_ports; port++) {
+                port_mmio = mv_port_base(mmio, port);
+                mv_port_init(&probe_ent->port[port], (unsigned long)port_mmio);
+        }
+
+        for (hc = 0; hc < n_hc; hc++) {
+                VPRINTK("HC%i: HC config=0x%08x HC IRQ cause=0x%08x\n", hc,
+                        readl(mv_hc_base(mmio, hc) + HC_CFG_OFS),
+                        readl(mv_hc_base(mmio, hc) + HC_IRQ_CAUSE_OFS));
+        }
+
+        writel(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
+        writel(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
+
+        VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
+                "PCI int cause/mask=0x%08x/0x%08x\n", 
+                readl(mmio + HC_MAIN_IRQ_CAUSE_OFS),
+                readl(mmio + HC_MAIN_IRQ_MASK_OFS),
+                readl(mmio + PCI_IRQ_CAUSE_OFS),
+                readl(mmio + PCI_IRQ_MASK_OFS));
+
+ done:
+        return rc;
+}
+
+/* move to PCI layer, integrate w/ MSI stuff */
+static void pci_intx(struct pci_dev *pdev, int enable)
+{
+        u16 pci_command, new;
+
+        pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
+
+        if (enable)
+                new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
+        else
+                new = pci_command | PCI_COMMAND_INTX_DISABLE;
+
+        if (new != pci_command)
+                pci_write_config_word(pdev, PCI_COMMAND, pci_command);
+}
+
+static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version = 0;
+        struct ata_probe_ent *probe_ent = NULL;
+        struct mv_host_priv *hpriv;
+        unsigned int board_idx = (unsigned int)ent->driver_data;
+        void __iomem *mmio_base;
+        int pci_dev_busy = 0;
+        int rc;
+
+        if (!printed_version++) {
+                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+        }
+
+        VPRINTK("ENTER for PCI Bus:Slot.Func=%u:%u.%u\n", pdev->bus->number,
+                PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
+
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                return rc;
+        }
+
+        rc = pci_request_regions(pdev, DRV_NAME);
+        if (rc) {
+                pci_dev_busy = 1;
+                goto err_out;
+        }
+
+        pci_intx(pdev, 1);
+
+        probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
+        if (probe_ent == NULL) {
+                rc = -ENOMEM;
+                goto err_out_regions;
+        }
+
+        memset(probe_ent, 0, sizeof(*probe_ent));
+        probe_ent->dev = pci_dev_to_dev(pdev);
+        INIT_LIST_HEAD(&probe_ent->node);
+
+        mmio_base = ioremap_nocache(pci_resource_start(pdev, MV_PRIMARY_BAR),
+                                    pci_resource_len(pdev, MV_PRIMARY_BAR));
+        if (mmio_base == NULL) {
+                rc = -ENOMEM;
+                goto err_out_free_ent;
+        }
+
+        hpriv = kmalloc(sizeof(*hpriv), GFP_KERNEL);
+        if (!hpriv) {
+                rc = -ENOMEM;
+                goto err_out_iounmap;
+        }
+        memset(hpriv, 0, sizeof(*hpriv));
+
+        probe_ent->sht = mv_port_info[board_idx].sht;
+        probe_ent->host_flags = mv_port_info[board_idx].host_flags;
+        probe_ent->pio_mask = mv_port_info[board_idx].pio_mask;
+        probe_ent->udma_mask = mv_port_info[board_idx].udma_mask;
+        probe_ent->port_ops = mv_port_info[board_idx].port_ops;
+
+        probe_ent->irq = pdev->irq;
+        probe_ent->irq_flags = SA_SHIRQ;
+        probe_ent->mmio_base = mmio_base;
+        probe_ent->private_data = hpriv;
+
+        /* initialize adapter */
+        rc = mv_host_init(probe_ent);
+        if (rc) {
+                goto err_out_hpriv;
+        }
+/*      mv_print_info(probe_ent); */
+
+        {
+                int b, w;
+                u32 dw[4];      /* hold a line of 16b */
+                VPRINTK("PCI config space:\n");
+                for (b = 0; b < 0x40; ) {
+                        for (w = 0; w < 4; w++) {
+                                (void) pci_read_config_dword(pdev,b,&dw[w]);
+                                b += sizeof(*dw);
+                        }
+                        VPRINTK("%08x %08x %08x %08x\n",
+                                dw[0],dw[1],dw[2],dw[3]);
+                }
+        }
+
+        /* FIXME: check ata_device_add return value */
+        ata_device_add(probe_ent);
+        kfree(probe_ent);
+
+        return 0;
+
+ err_out_hpriv:
+        kfree(hpriv);
+ err_out_iounmap:
+        iounmap(mmio_base);
+ err_out_free_ent:
+        kfree(probe_ent);
+ err_out_regions:
+        pci_release_regions(pdev);
+ err_out:
+        if (!pci_dev_busy) {
+                pci_disable_device(pdev);
+        }
+
+        return rc;
+}
+
+static int __init mv_init(void)
+{
+        return pci_module_init(&mv_pci_driver);
+}
+
+static void __exit mv_exit(void)
+{
+        pci_unregister_driver(&mv_pci_driver);
+}
+
+MODULE_AUTHOR("Brett Russ");
+MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
+module_init(mv_init);
+module_exit(mv_exit);
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index b0403ccd8a25..a1d62dee3be6 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -4,21 +4,37 @@
  *  Copyright 2004 NVIDIA Corp.  All rights reserved.
  *  Copyright 2004 Andrew Chew
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  No hardware documentation available outside of NVIDIA.
+ *  This driver programs the NVIDIA SATA controller in a similar
+ *  fashion as with other PCI IDE BMDMA controllers, with a few
+ *  NV-specific details such as register offsets, SATA phy location,
+ *  hotplug info, etc.
+ *
+ *
+ *  0.08
+ *     - Added support for MCP51 and MCP55.
+ *
+ *  0.07
+ *     - Added support for RAID class code.
  *
  *  0.06
  *     - Added generic SATA support by using a pci_device_id that filters on
@@ -48,7 +64,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME                        "sata_nv"
-#define DRV_VERSION                     "0.6"
+#define DRV_VERSION                     "0.8"
 
 #define NV_PORTS                        2
 #define NV_PIO_MASK                     0x1f
@@ -116,7 +132,9 @@ enum nv_host_type
         GENERIC,
         NFORCE2,
         NFORCE3,
-        CK804
+        CK804,
+        MCP51,
+        MCP55
 };
 
 static struct pci_device_id nv_pci_tbl[] = {
@@ -134,9 +152,18 @@ static struct pci_device_id nv_pci_tbl[] = {
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP51 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP51 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP55 },
         { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
                 PCI_ANY_ID, PCI_ANY_ID,
                 PCI_CLASS_STORAGE_IDE<<8, 0xffff00, GENERIC },
+        { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
+                PCI_ANY_ID, PCI_ANY_ID,
+                PCI_CLASS_STORAGE_RAID<<8, 0xffff00, GENERIC },
         { 0, } /* terminate list */
 };
 
@@ -274,7 +301,8 @@ static irqreturn_t nv_interrupt (int irq, void *dev_instance,
                 struct ata_port *ap;
 
                 ap = host_set->ports[i];
-                if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                if (ap &&
+                    !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
                         struct ata_queued_cmd *qc;
 
                         qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -323,6 +351,7 @@ static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 static void nv_host_stop (struct ata_host_set *host_set)
 {
         struct nv_host *host = host_set->private_data;
+        struct pci_dev *pdev = to_pci_dev(host_set->dev);
 
         // Disable hotplug event interrupts.
         if (host->host_desc->disable_hotplug)
@@ -330,7 +359,8 @@ static void nv_host_stop (struct ata_host_set *host_set)
 
         kfree(host);
 
-        ata_host_stop(host_set);
+        if (host_set->mmio_base)
+                pci_iounmap(pdev, host_set->mmio_base);
 }
 
 static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
@@ -392,8 +422,7 @@ static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (host->host_flags & NV_HOST_FLAGS_SCR_MMIO) {
                 unsigned long base;
 
-                probe_ent->mmio_base = ioremap(pci_resource_start(pdev, 5),
-                                pci_resource_len(pdev, 5));
+                probe_ent->mmio_base = pci_iomap(pdev, 5, 0);
                 if (probe_ent->mmio_base == NULL) {
                         rc = -EIO;
                         goto err_out_free_host;
@@ -429,7 +458,7 @@ static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 
 err_out_iounmap:
         if (host->host_flags & NV_HOST_FLAGS_SCR_MMIO)
-                iounmap(probe_ent->mmio_base);
+                pci_iounmap(pdev, probe_ent->mmio_base);
 err_out_free_host:
         kfree(host);
 err_out_free_ent:
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index 919fb314ad10..538ad727bd2e 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -7,21 +7,26 @@
  *
  *  Copyright 2003-2004 Red Hat, Inc.
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware information only available under NDA.
  *
  */
 
@@ -79,13 +84,15 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *r
 static void pdc_eng_timeout(struct ata_port *ap);
 static int pdc_port_start(struct ata_port *ap);
 static void pdc_port_stop(struct ata_port *ap);
-static void pdc_phy_reset(struct ata_port *ap);
+static void pdc_pata_phy_reset(struct ata_port *ap);
+static void pdc_sata_phy_reset(struct ata_port *ap);
 static void pdc_qc_prep(struct ata_queued_cmd *qc);
 static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 static void pdc_irq_clear(struct ata_port *ap);
 static int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
 
+
 static Scsi_Host_Template pdc_ata_sht = {
         .module                 = THIS_MODULE,
         .name                   = DRV_NAME,
@@ -106,24 +113,48 @@ static Scsi_Host_Template pdc_ata_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations pdc_ata_ops = {
+static struct ata_port_operations pdc_sata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
         .exec_command           = pdc_exec_command_mmio,
         .dev_select             = ata_std_dev_select,
-        .phy_reset              = pdc_phy_reset,
+
+        .phy_reset              = pdc_sata_phy_reset,
+
         .qc_prep                = pdc_qc_prep,
         .qc_issue               = pdc_qc_issue_prot,
         .eng_timeout            = pdc_eng_timeout,
         .irq_handler            = pdc_interrupt,
         .irq_clear              = pdc_irq_clear,
+
         .scr_read               = pdc_sata_scr_read,
         .scr_write              = pdc_sata_scr_write,
         .port_start             = pdc_port_start,
         .port_stop              = pdc_port_stop,
-        .host_stop              = ata_host_stop,
+        .host_stop              = ata_pci_host_stop,
+};
+
+static struct ata_port_operations pdc_pata_ops = {
+        .port_disable           = ata_port_disable,
+        .tf_load                = pdc_tf_load_mmio,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .exec_command           = pdc_exec_command_mmio,
+        .dev_select             = ata_std_dev_select,
+
+        .phy_reset              = pdc_pata_phy_reset,
+
+        .qc_prep                = pdc_qc_prep,
+        .qc_issue               = pdc_qc_issue_prot,
+        .eng_timeout            = pdc_eng_timeout,
+        .irq_handler            = pdc_interrupt,
+        .irq_clear              = pdc_irq_clear,
+
+        .port_start             = pdc_port_start,
+        .port_stop              = pdc_port_stop,
+        .host_stop              = ata_pci_host_stop,
 };
 
 static struct ata_port_info pdc_port_info[] = {
@@ -135,7 +166,7 @@ static struct ata_port_info pdc_port_info[] = {
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .mwdma_mask     = 0x07, /* mwdma0-2 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
-                .port_ops       = &pdc_ata_ops,
+                .port_ops       = &pdc_sata_ops,
         },
 
         /* board_20319 */
@@ -146,7 +177,7 @@ static struct ata_port_info pdc_port_info[] = {
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .mwdma_mask     = 0x07, /* mwdma0-2 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
-                .port_ops       = &pdc_ata_ops,
+                .port_ops       = &pdc_sata_ops,
         },
 
         /* board_20619 */
@@ -157,7 +188,7 @@ static struct ata_port_info pdc_port_info[] = {
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .mwdma_mask     = 0x07, /* mwdma0-2 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
-                .port_ops       = &pdc_ata_ops,
+                .port_ops       = &pdc_pata_ops,
         },
 };
 
@@ -181,6 +212,10 @@ static struct pci_device_id pdc_ata_pci_tbl[] = {
           board_20319 },
         { PCI_VENDOR_ID_PROMISE, 0x3319, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_20319 },
+        { PCI_VENDOR_ID_PROMISE, 0x3519, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_20319 },
+        { PCI_VENDOR_ID_PROMISE, 0x3d17, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_20319 },
         { PCI_VENDOR_ID_PROMISE, 0x3d18, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_20319 },
 
@@ -248,7 +283,7 @@ static void pdc_port_stop(struct ata_port *ap)
 
 static void pdc_reset_port(struct ata_port *ap)
 {
-        void *mmio = (void *) ap->ioaddr.cmd_addr + PDC_CTLSTAT;
+        void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_CTLSTAT;
         unsigned int i;
         u32 tmp;
 
@@ -268,12 +303,23 @@ static void pdc_reset_port(struct ata_port *ap)
         readl(mmio);    /* flush */
 }
 
-static void pdc_phy_reset(struct ata_port *ap)
+static void pdc_sata_phy_reset(struct ata_port *ap)
 {
         pdc_reset_port(ap);
         sata_phy_reset(ap);
 }
 
+static void pdc_pata_phy_reset(struct ata_port *ap)
+{
+        /* FIXME: add cable detect.  Don't assume 40-pin cable */
+        ap->cbl = ATA_CBL_PATA40;
+        ap->udma_mask &= ATA_UDMA_MASK_40C;
+
+        pdc_reset_port(ap);
+        ata_port_probe(ap);
+        ata_bus_reset(ap);
+}
+
 static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
         if (sc_reg > SCR_CONTROL)
@@ -321,11 +367,15 @@ static void pdc_qc_prep(struct ata_queued_cmd *qc)
 
 static void pdc_eng_timeout(struct ata_port *ap)
 {
+        struct ata_host_set *host_set = ap->host_set;
         u8 drv_stat;
         struct ata_queued_cmd *qc;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
+        spin_lock_irqsave(&host_set->lock, flags);
+
         qc = ata_qc_from_tag(ap, ap->active_tag);
         if (!qc) {
                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
@@ -359,6 +409,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
         }
 
 out:
+        spin_unlock_irqrestore(&host_set->lock, flags);
         DPRINTK("EXIT\n");
 }
 
@@ -368,7 +419,7 @@ static inline unsigned int pdc_host_intr( struct ata_port *ap,
         u8 status;
         unsigned int handled = 0, have_err = 0;
         u32 tmp;
-        void *mmio = (void *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;
+        void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;
 
         tmp = readl(mmio);
         if (tmp & PDC_ERR_MASK) {
@@ -397,7 +448,7 @@ static inline unsigned int pdc_host_intr( struct ata_port *ap,
 static void pdc_irq_clear(struct ata_port *ap)
 {
         struct ata_host_set *host_set = ap->host_set;
-        void *mmio = host_set->mmio_base;
+        void __iomem *mmio = host_set->mmio_base;
 
         readl(mmio + PDC_INT_SEQMASK);
 }
@@ -409,7 +460,7 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *r
         u32 mask = 0;
         unsigned int i, tmp;
         unsigned int handled = 0;
-        void *mmio_base;
+        void __iomem *mmio_base;
 
         VPRINTK("ENTER\n");
 
@@ -441,7 +492,8 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *r
                 VPRINTK("port %u\n", i);
                 ap = host_set->ports[i];
                 tmp = mask & (1 << (i + 1));
-                if (tmp && ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                if (tmp && ap &&
+                    !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
                         struct ata_queued_cmd *qc;
 
                         qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -530,7 +582,7 @@ static void pdc_ata_setup_port(struct ata_ioports *port, unsigned long base)
 
 static void pdc_host_init(unsigned int chip_id, struct ata_probe_ent *pe)
 {
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
         u32 tmp;
 
         /*
@@ -573,7 +625,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
-        void *mmio_base;
+        void __iomem *mmio_base;
         unsigned int board_idx = (unsigned int) ent->driver_data;
         int pci_dev_busy = 0;
         int rc;
@@ -612,8 +664,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap(pci_resource_start(pdev, 3),
-                            pci_resource_len(pdev, 3));
+        mmio_base = pci_iomap(pdev, 3, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
diff --git a/drivers/scsi/sata_promise.h b/drivers/scsi/sata_promise.h
index 6e7e96b9ee13..6ee5e190262d 100644
--- a/drivers/scsi/sata_promise.h
+++ b/drivers/scsi/sata_promise.h
@@ -3,21 +3,24 @@
  *
  *  Copyright 2003-2004 Red Hat, Inc.
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
  *
  */
 
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 1383e8a28d72..ffcdeb68641c 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -6,21 +6,24 @@
  *  Copyright 2005 Pacific Digital Corporation.
  *  (OSL/GPL code release authorized by Jalil Fadavi).
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
  *
  */
 
@@ -117,7 +120,7 @@ static void qs_phy_reset(struct ata_port *ap);
 static void qs_qc_prep(struct ata_queued_cmd *qc);
 static int qs_qc_issue(struct ata_queued_cmd *qc);
 static int qs_check_atapi_dma(struct ata_queued_cmd *qc);
-static void qs_bmdma_stop(struct ata_port *ap);
+static void qs_bmdma_stop(struct ata_queued_cmd *qc);
 static u8 qs_bmdma_status(struct ata_port *ap);
 static void qs_irq_clear(struct ata_port *ap);
 static void qs_eng_timeout(struct ata_port *ap);
@@ -198,7 +201,7 @@ static int qs_check_atapi_dma(struct ata_queued_cmd *qc)
         return 1;       /* ATAPI DMA not supported */
 }
 
-static void qs_bmdma_stop(struct ata_port *ap)
+static void qs_bmdma_stop(struct ata_queued_cmd *qc)
 {
         /* nothing */
 }
@@ -386,7 +389,8 @@ static inline unsigned int qs_intr_pkt(struct ata_host_set *host_set)
                         DPRINTK("SFF=%08x%08x: sCHAN=%u sHST=%d sDST=%02x\n",
                                         sff1, sff0, port_no, sHST, sDST);
                         handled = 1;
-                        if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                        if (ap && !(ap->flags &
+                                    (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
                                 struct ata_queued_cmd *qc;
                                 struct qs_port_priv *pp = ap->private_data;
                                 if (!pp || pp->state != qs_state_pkt)
@@ -417,7 +421,8 @@ static inline unsigned int qs_intr_mmio(struct ata_host_set *host_set)
         for (port_no = 0; port_no < host_set->n_ports; ++port_no) {
                 struct ata_port *ap;
                 ap = host_set->ports[port_no];
-                if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                if (ap &&
+                    !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
                         struct ata_queued_cmd *qc;
                         struct qs_port_priv *pp = ap->private_data;
                         if (!pp || pp->state != qs_state_mmio)
@@ -431,7 +436,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host_set *host_set)
                                         continue;
                                 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
                                         ap->id, qc->tf.protocol, status);
-                
+
                                 /* complete taskfile transaction */
                                 pp->state = qs_state_idle;
                                 ata_qc_complete(qc, status);
@@ -489,7 +494,7 @@ static int qs_port_start(struct ata_port *ap)
         if (rc)
                 return rc;
         qs_enter_reg_mode(ap);
-        pp = kcalloc(1, sizeof(*pp), GFP_KERNEL);
+        pp = kzalloc(sizeof(*pp), GFP_KERNEL);
         if (!pp) {
                 rc = -ENOMEM;
                 goto err_out;
@@ -533,11 +538,12 @@ static void qs_port_stop(struct ata_port *ap)
 static void qs_host_stop(struct ata_host_set *host_set)
 {
         void __iomem *mmio_base = host_set->mmio_base;
+        struct pci_dev *pdev = to_pci_dev(host_set->dev);
 
         writeb(0, mmio_base + QS_HCT_CTRL); /* disable host interrupts */
         writeb(QS_CNFG3_GSRST, mmio_base + QS_HCF_CNFG3); /* global reset */
 
-        ata_host_stop(host_set);
+        pci_iounmap(pdev, mmio_base);
 }
 
 static void qs_host_init(unsigned int chip_id, struct ata_probe_ent *pe)
@@ -641,8 +647,7 @@ static int qs_ata_init_one(struct pci_dev *pdev,
                 goto err_out_regions;
         }
 
-        mmio_base = ioremap(pci_resource_start(pdev, 4),
-                            pci_resource_len(pdev, 4));
+        mmio_base = pci_iomap(pdev, 4, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_regions;
@@ -692,7 +697,7 @@ static int qs_ata_init_one(struct pci_dev *pdev,
         return 0;
 
 err_out_iounmap:
-        iounmap(mmio_base);
+        pci_iounmap(pdev, mmio_base);
 err_out_regions:
         pci_release_regions(pdev);
 err_out:
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 49ed557a4b66..ba98a175ee3a 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -5,24 +5,32 @@
  *                  Please ALWAYS copy linux-ide@vger.kernel.org
  *                  on emails.
  *
- *  Copyright 2003 Red Hat, Inc.
+ *  Copyright 2003-2005 Red Hat, Inc.
  *  Copyright 2003 Benjamin Herrenschmidt
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Documentation for SiI 3112:
+ *  http://gkernel.sourceforge.net/specs/sii/3112A_SiI-DS-0095-B2.pdf.bz2
+ *
+ *  Other errata and documentation available under NDA.
  *
  */
 
@@ -41,8 +49,11 @@
 #define DRV_VERSION     "0.9"
 
 enum {
+        SIL_FLAG_MOD15WRITE     = (1 << 30),
+
         sil_3112                = 0,
-        sil_3114                = 1,
+        sil_3112_m15w           = 1,
+        sil_3114                = 2,
 
         SIL_FIFO_R0             = 0x40,
         SIL_FIFO_W0             = 0x41,
@@ -75,14 +86,15 @@ static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg);
 static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 static void sil_post_set_mode (struct ata_port *ap);
 
+
 static struct pci_device_id sil_pci_tbl[] = {
-        { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
-        { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
+        { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
         { 0x1095, 0x3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3114 },
-        { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
-        { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
-        { 0x1002, 0x437a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
+        { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
+        { 0x1002, 0x437a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { }     /* terminate list */
 };
 
@@ -161,7 +173,7 @@ static struct ata_port_operations sil_ops = {
         .scr_write              = sil_scr_write,
         .port_start             = ata_port_start,
         .port_stop              = ata_port_stop,
-        .host_stop              = ata_host_stop,
+        .host_stop              = ata_pci_host_stop,
 };
 
 static struct ata_port_info sil_port_info[] = {
@@ -174,6 +186,16 @@ static struct ata_port_info sil_port_info[] = {
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil_ops,
+        }, /* sil_3112_15w - keep it sync'd w/ sil_3112 */
+        {
+                .sht            = &sil_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_MOD15WRITE,
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil_ops,
         }, /* sil_3114 */
         {
                 .sht            = &sil_sht,
@@ -210,6 +232,7 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, sil_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 
+
 static unsigned char sil_get_device_cache_line(struct pci_dev *pdev)
 {
         u8 cache_line = 0;
@@ -221,7 +244,8 @@ static void sil_post_set_mode (struct ata_port *ap)
 {
         struct ata_host_set *host_set = ap->host_set;
         struct ata_device *dev;
-        void *addr = host_set->mmio_base + sil_port[ap->port_no].xfer_mode;
+        void __iomem *addr =
+                host_set->mmio_base + sil_port[ap->port_no].xfer_mode;
         u32 tmp, dev_mode[2];
         unsigned int i;
 
@@ -323,15 +347,15 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
         while ((len > 0) && (s[len - 1] == ' '))
                 len--;
 
-        for (n = 0; sil_blacklist[n].product; n++) 
+        for (n = 0; sil_blacklist[n].product; n++)
                 if (!memcmp(sil_blacklist[n].product, s,
                             strlen(sil_blacklist[n].product))) {
                         quirks = sil_blacklist[n].quirk;
                         break;
                 }
-        
+
         /* limit requests to 15 sectors */
-        if (quirks & SIL_QUIRK_MOD15WRITE) {
+        if ((ap->flags & SIL_FLAG_MOD15WRITE) && (quirks & SIL_QUIRK_MOD15WRITE)) {
                 printk(KERN_INFO "ata%u(%u): applying Seagate errata fix\n",
                        ap->id, dev->devno);
                 ap->host->max_sectors = 15;
@@ -354,7 +378,7 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
-        void *mmio_base;
+        void __iomem *mmio_base;
         int rc;
         unsigned int i;
         int pci_dev_busy = 0;
@@ -404,8 +428,7 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         probe_ent->irq_flags = SA_SHIRQ;
         probe_ent->host_flags = sil_port_info[ent->driver_data].host_flags;
 
-        mmio_base = ioremap(pci_resource_start(pdev, 5),
-                            pci_resource_len(pdev, 5));
+        mmio_base = pci_iomap(pdev, 5, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index e418b89c6b9d..43af445b3ad2 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -7,21 +7,26 @@
  *
  *  Copyright 2004 Uwe Koziolek
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available under NDA.
  *
  */
 
@@ -234,7 +239,7 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         pci_read_config_dword(pdev, SIS_GENCTL, &genctl);
         if ((genctl & GENCTL_IOMAPPED_SCR) == 0)
                 probe_ent->host_flags |= SIS_FLAG_CFGSCR;
-        
+
         /* if hardware thinks SCRs are in IO space, but there are
          * no IO resources assigned, change to PCI cfg space.
          */
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index 858e07185dbd..d89d968bedac 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -13,21 +13,26 @@
  *  This driver probably works with non-Apple versions of the
  *  Broadcom chipset...
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available under NDA.
  *
  */
 
@@ -195,18 +200,18 @@ static void k2_bmdma_start_mmio (struct ata_queued_cmd *qc)
         /* start host DMA transaction */
         dmactl = readb(mmio + ATA_DMA_CMD);
         writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
-        /* There is a race condition in certain SATA controllers that can 
-           be seen when the r/w command is given to the controller before the 
+        /* There is a race condition in certain SATA controllers that can
+           be seen when the r/w command is given to the controller before the
            host DMA is started. On a Read command, the controller would initiate
            the command to the drive even before it sees the DMA start. When there
-           are very fast drives connected to the controller, or when the data request 
+           are very fast drives connected to the controller, or when the data request
            hits in the drive cache, there is the possibility that the drive returns a part
            or all of the requested data to the controller before the DMA start is issued.
            In this case, the controller would become confused as to what to do with the data.
            In the worst case when all the data is returned back to the controller, the
            controller could hang. In other cases it could return partial data returning
            in data corruption. This problem has been seen in PPC systems and can also appear
-           on an system with very fast disks, where the SATA controller is sitting behind a 
+           on an system with very fast disks, where the SATA controller is sitting behind a
            number of bridges, and hence there is significant latency between the r/w command
            and the start command. */
         /* issue r/w command if the access is to ATA*/
@@ -214,7 +219,7 @@ static void k2_bmdma_start_mmio (struct ata_queued_cmd *qc)
                 ap->ops->exec_command(ap, &qc->tf);
 }
 
-                                                                              
+
 static u8 k2_stat_check_status(struct ata_port *ap)
 {
         return readl((void *) ap->ioaddr.status_addr);
@@ -313,7 +318,7 @@ static struct ata_port_operations k2_sata_ops = {
         .scr_write              = k2_sata_scr_write,
         .port_start             = ata_port_start,
         .port_stop              = ata_port_stop,
-        .host_stop              = ata_host_stop,
+        .host_stop              = ata_pci_host_stop,
 };
 
 static void k2_sata_setup_port(struct ata_ioports *port, unsigned long base)
@@ -341,7 +346,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
-        void *mmio_base;
+        void __iomem *mmio_base;
         int pci_dev_busy = 0;
         int rc;
         int i;
@@ -387,8 +392,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap(pci_resource_start(pdev, 5),
-                            pci_resource_len(pdev, 5));
+        mmio_base = pci_iomap(pdev, 5, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index efd7d7a61135..540a85191172 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -7,21 +7,26 @@
  *
  *  Copyright 2003-2004 Red Hat, Inc.
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available under NDA.
  *
  */
 
@@ -94,7 +99,7 @@ enum {
         PDC_DIMM1_CONTROL_OFFSET      = 0x84,
         PDC_SDRAM_CONTROL_OFFSET      = 0x88,
         PDC_I2C_WRITE                 = 0x00000000,
-        PDC_I2C_READ                  = 0x00000040,     
+        PDC_I2C_READ                  = 0x00000040,
         PDC_I2C_START                 = 0x00000080,
         PDC_I2C_MASK_INT              = 0x00000020,
         PDC_I2C_COMPLETE              = 0x00010000,
@@ -105,16 +110,16 @@ enum {
         PDC_DIMM_SPD_COLUMN_NUM       = 4,
         PDC_DIMM_SPD_MODULE_ROW       = 5,
         PDC_DIMM_SPD_TYPE             = 11,
-        PDC_DIMM_SPD_FRESH_RATE       = 12,         
-        PDC_DIMM_SPD_BANK_NUM         = 17,     
+        PDC_DIMM_SPD_FRESH_RATE       = 12,
+        PDC_DIMM_SPD_BANK_NUM         = 17,
         PDC_DIMM_SPD_CAS_LATENCY      = 18,
-        PDC_DIMM_SPD_ATTRIBUTE        = 21,    
+        PDC_DIMM_SPD_ATTRIBUTE        = 21,
         PDC_DIMM_SPD_ROW_PRE_CHARGE   = 27,
-        PDC_DIMM_SPD_ROW_ACTIVE_DELAY = 28,      
+        PDC_DIMM_SPD_ROW_ACTIVE_DELAY = 28,
         PDC_DIMM_SPD_RAS_CAS_DELAY    = 29,
         PDC_DIMM_SPD_ACTIVE_PRECHARGE = 30,
         PDC_DIMM_SPD_SYSTEM_FREQ      = 126,
-        PDC_CTL_STATUS                = 0x08,   
+        PDC_CTL_STATUS                = 0x08,
         PDC_DIMM_WINDOW_CTLR          = 0x0C,
         PDC_TIME_CONTROL              = 0x3C,
         PDC_TIME_PERIOD               = 0x40,
@@ -157,15 +162,15 @@ static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 static void pdc20621_host_stop(struct ata_host_set *host_set);
 static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe);
 static int pdc20621_detect_dimm(struct ata_probe_ent *pe);
-static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, 
+static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe,
                                       u32 device, u32 subaddr, u32 *pdata);
 static int pdc20621_prog_dimm0(struct ata_probe_ent *pe);
 static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe);
 #ifdef ATA_VERBOSE_DEBUG
-static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, 
+static void pdc20621_get_from_dimm(struct ata_probe_ent *pe,
                                    void *psource, u32 offset, u32 size);
 #endif
-static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, 
+static void pdc20621_put_to_dimm(struct ata_probe_ent *pe,
                                  void *psource, u32 offset, u32 size);
 static void pdc20621_irq_clear(struct ata_port *ap);
 static int pdc20621_qc_issue_prot(struct ata_queued_cmd *qc);
@@ -240,13 +245,14 @@ static struct pci_driver pdc_sata_pci_driver = {
 
 static void pdc20621_host_stop(struct ata_host_set *host_set)
 {
+        struct pci_dev *pdev = to_pci_dev(host_set->dev);
         struct pdc_host_priv *hpriv = host_set->private_data;
         void *dimm_mmio = hpriv->dimm_mmio;
 
-        iounmap(dimm_mmio);
+        pci_iounmap(pdev, dimm_mmio);
         kfree(hpriv);
 
-        ata_host_stop(host_set);
+        pci_iounmap(pdev, host_set->mmio_base);
 }
 
 static int pdc_port_start(struct ata_port *ap)
@@ -446,9 +452,9 @@ static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
         struct scatterlist *sg = qc->sg;
         struct ata_port *ap = qc->ap;
         struct pdc_port_priv *pp = ap->private_data;
-        void *mmio = ap->host_set->mmio_base;
+        void __iomem *mmio = ap->host_set->mmio_base;
         struct pdc_host_priv *hpriv = ap->host_set->private_data;
-        void *dimm_mmio = hpriv->dimm_mmio;
+        void __iomem *dimm_mmio = hpriv->dimm_mmio;
         unsigned int portno = ap->port_no;
         unsigned int i, last, idx, total_len = 0, sgt_len;
         u32 *buf = (u32 *) &pp->dimm_buf[PDC_DIMM_HEADER_SZ];
@@ -508,9 +514,9 @@ static void pdc20621_nodata_prep(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
         struct pdc_port_priv *pp = ap->private_data;
-        void *mmio = ap->host_set->mmio_base;
+        void __iomem *mmio = ap->host_set->mmio_base;
         struct pdc_host_priv *hpriv = ap->host_set->private_data;
-        void *dimm_mmio = hpriv->dimm_mmio;
+        void __iomem *dimm_mmio = hpriv->dimm_mmio;
         unsigned int portno = ap->port_no;
         unsigned int i;
 
@@ -560,7 +566,7 @@ static void __pdc20621_push_hdma(struct ata_queued_cmd *qc,
 {
         struct ata_port *ap = qc->ap;
         struct ata_host_set *host_set = ap->host_set;
-        void *mmio = host_set->mmio_base;
+        void __iomem *mmio = host_set->mmio_base;
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -634,7 +640,7 @@ static void pdc20621_packet_start(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
         struct ata_host_set *host_set = ap->host_set;
         unsigned int port_no = ap->port_no;
-        void *mmio = host_set->mmio_base;
+        void __iomem *mmio = host_set->mmio_base;
         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
         u8 seq = (u8) (port_no + 1);
         unsigned int port_ofs;
@@ -694,7 +700,7 @@ static int pdc20621_qc_issue_prot(struct ata_queued_cmd *qc)
 static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                                           struct ata_queued_cmd *qc,
                                           unsigned int doing_hdma,
-                                          void *mmio)
+                                          void __iomem *mmio)
 {
         unsigned int port_no = ap->port_no;
         unsigned int port_ofs =
@@ -773,7 +779,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
 static void pdc20621_irq_clear(struct ata_port *ap)
 {
         struct ata_host_set *host_set = ap->host_set;
-        void *mmio = host_set->mmio_base;
+        void __iomem *mmio = host_set->mmio_base;
 
         mmio += PDC_CHIP0_OFS;
 
@@ -787,7 +793,7 @@ static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance, struct pt_re
         u32 mask = 0;
         unsigned int i, tmp, port_no;
         unsigned int handled = 0;
-        void *mmio_base;
+        void __iomem *mmio_base;
 
         VPRINTK("ENTER\n");
 
@@ -825,7 +831,8 @@ static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance, struct pt_re
                         ap = host_set->ports[port_no];
                 tmp = mask & (1 << i);
                 VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp);
-                if (tmp && ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                if (tmp && ap &&
+                    !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
                         struct ata_queued_cmd *qc;
 
                         qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -847,10 +854,14 @@ static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance, struct pt_re
 static void pdc_eng_timeout(struct ata_port *ap)
 {
         u8 drv_stat;
+        struct ata_host_set *host_set = ap->host_set;
         struct ata_queued_cmd *qc;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
+        spin_lock_irqsave(&host_set->lock, flags);
+
         qc = ata_qc_from_tag(ap, ap->active_tag);
         if (!qc) {
                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
@@ -884,6 +895,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
         }
 
 out:
+        spin_unlock_irqrestore(&host_set->lock, flags);
         DPRINTK("EXIT\n");
 }
 
@@ -922,23 +934,23 @@ static void pdc_sata_setup_port(struct ata_ioports *port, unsigned long base)
 
 
 #ifdef ATA_VERBOSE_DEBUG
-static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource, 
+static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource,
                                    u32 offset, u32 size)
 {
         u32 window_size;
         u16 idx;
         u8 page_mask;
         long dist;
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
         struct pdc_host_priv *hpriv = pe->private_data;
-        void *dimm_mmio = hpriv->dimm_mmio;
+        void __iomem *dimm_mmio = hpriv->dimm_mmio;
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
 
-        page_mask = 0x00;       
-        window_size = 0x2000 * 4; /* 32K byte uchar size */  
-        idx = (u16) (offset / window_size); 
+        page_mask = 0x00;
+        window_size = 0x2000 * 4; /* 32K byte uchar size */
+        idx = (u16) (offset / window_size);
 
         writel(0x01, mmio + PDC_GENERAL_CTLR);
         readl(mmio + PDC_GENERAL_CTLR);
@@ -947,19 +959,19 @@ static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource,
 
         offset -= (idx * window_size);
         idx++;
-        dist = ((long) (window_size - (offset + size))) >= 0 ? size : 
+        dist = ((long) (window_size - (offset + size))) >= 0 ? size :
                 (long) (window_size - offset);
-        memcpy_fromio((char *) psource, (char *) (dimm_mmio + offset / 4), 
+        memcpy_fromio((char *) psource, (char *) (dimm_mmio + offset / 4),
                       dist);
 
-        psource += dist;    
+        psource += dist;
         size -= dist;
         for (; (long) size >= (long) window_size ;) {
                 writel(0x01, mmio + PDC_GENERAL_CTLR);
                 readl(mmio + PDC_GENERAL_CTLR);
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
-                memcpy_fromio((char *) psource, (char *) (dimm_mmio), 
+                memcpy_fromio((char *) psource, (char *) (dimm_mmio),
                               window_size / 4);
                 psource += window_size;
                 size -= window_size;
@@ -971,34 +983,34 @@ static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource,
                 readl(mmio + PDC_GENERAL_CTLR);
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
-                memcpy_fromio((char *) psource, (char *) (dimm_mmio), 
+                memcpy_fromio((char *) psource, (char *) (dimm_mmio),
                               size / 4);
         }
 }
 #endif
 
 
-static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource, 
+static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
                                  u32 offset, u32 size)
 {
         u32 window_size;
         u16 idx;
         u8 page_mask;
         long dist;
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
         struct pdc_host_priv *hpriv = pe->private_data;
-        void *dimm_mmio = hpriv->dimm_mmio;
+        void __iomem *dimm_mmio = hpriv->dimm_mmio;
 
-        /* hard-code chip #0 */   
+        /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
 
-        page_mask = 0x00;       
-        window_size = 0x2000 * 4;       /* 32K byte uchar size */  
+        page_mask = 0x00;
+        window_size = 0x2000 * 4;       /* 32K byte uchar size */
         idx = (u16) (offset / window_size);
 
         writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
         readl(mmio + PDC_DIMM_WINDOW_CTLR);
-        offset -= (idx * window_size); 
+        offset -= (idx * window_size);
         idx++;
         dist = ((long)(s32)(window_size - (offset + size))) >= 0 ? size :
                 (long) (window_size - offset);
@@ -1006,12 +1018,12 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
         writel(0x01, mmio + PDC_GENERAL_CTLR);
         readl(mmio + PDC_GENERAL_CTLR);
 
-        psource += dist;    
+        psource += dist;
         size -= dist;
         for (; (long) size >= (long) window_size ;) {
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
-                memcpy_toio((char *) (dimm_mmio), (char *) psource, 
+                memcpy_toio((char *) (dimm_mmio), (char *) psource,
                             window_size / 4);
                 writel(0x01, mmio + PDC_GENERAL_CTLR);
                 readl(mmio + PDC_GENERAL_CTLR);
@@ -1019,7 +1031,7 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
                 size -= window_size;
                 idx ++;
         }
-    
+
         if (size) {
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
@@ -1030,12 +1042,12 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
 }
 
 
-static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device, 
+static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device,
                                       u32 subaddr, u32 *pdata)
 {
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
         u32 i2creg  = 0;
-        u32 status;     
+        u32 status;
         u32 count =0;
 
         /* hard-code chip #0 */
@@ -1049,7 +1061,7 @@ static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device,
         readl(mmio + PDC_I2C_ADDR_DATA_OFFSET);
 
         /* Write Control to perform read operation, mask int */
-        writel(PDC_I2C_READ | PDC_I2C_START | PDC_I2C_MASK_INT, 
+        writel(PDC_I2C_READ | PDC_I2C_START | PDC_I2C_MASK_INT,
                mmio + PDC_I2C_CONTROL_OFFSET);
 
         for (count = 0; count <= 1000; count ++) {
@@ -1062,26 +1074,26 @@ static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device,
         }
 
         *pdata = (status >> 8) & 0x000000ff;
-        return 1;           
+        return 1;
 }
 
 
 static int pdc20621_detect_dimm(struct ata_probe_ent *pe)
 {
         u32 data=0 ;
-        if (pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS, 
+        if (pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
                              PDC_DIMM_SPD_SYSTEM_FREQ, &data)) {
                 if (data == 100)
                         return 100;
         } else
                 return 0;
-        
+
         if (pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS, 9, &data)) {
-                if(data <= 0x75) 
+                if(data <= 0x75)
                         return 133;
         } else
                 return 0;
-        
+
         return 0;
 }
 
@@ -1091,15 +1103,15 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
         u32 spd0[50];
         u32 data = 0;
         int size, i;
-        u8 bdimmsize; 
-        void *mmio = pe->mmio_base;
+        u8 bdimmsize;
+        void __iomem *mmio = pe->mmio_base;
         static const struct {
                 unsigned int reg;
                 unsigned int ofs;
         } pdc_i2c_read_data [] = {
-                { PDC_DIMM_SPD_TYPE, 11 },              
+                { PDC_DIMM_SPD_TYPE, 11 },
                 { PDC_DIMM_SPD_FRESH_RATE, 12 },
-                { PDC_DIMM_SPD_COLUMN_NUM, 4 }, 
+                { PDC_DIMM_SPD_COLUMN_NUM, 4 },
                 { PDC_DIMM_SPD_ATTRIBUTE, 21 },
                 { PDC_DIMM_SPD_ROW_NUM, 3 },
                 { PDC_DIMM_SPD_BANK_NUM, 17 },
@@ -1108,7 +1120,7 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
                 { PDC_DIMM_SPD_ROW_ACTIVE_DELAY, 28 },
                 { PDC_DIMM_SPD_RAS_CAS_DELAY, 29 },
                 { PDC_DIMM_SPD_ACTIVE_PRECHARGE, 30 },
-                { PDC_DIMM_SPD_CAS_LATENCY, 18 },       
+                { PDC_DIMM_SPD_CAS_LATENCY, 18 },
         };
 
         /* hard-code chip #0 */
@@ -1116,17 +1128,17 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
 
         for(i=0; i<ARRAY_SIZE(pdc_i2c_read_data); i++)
                 pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
-                                  pdc_i2c_read_data[i].reg, 
+                                  pdc_i2c_read_data[i].reg,
                                   &spd0[pdc_i2c_read_data[i].ofs]);
-  
+
         data |= (spd0[4] - 8) | ((spd0[21] != 0) << 3) | ((spd0[3]-11) << 4);
-        data |= ((spd0[17] / 4) << 6) | ((spd0[5] / 2) << 7) | 
+        data |= ((spd0[17] / 4) << 6) | ((spd0[5] / 2) << 7) |
                 ((((spd0[27] + 9) / 10) - 1) << 8) ;
-        data |= (((((spd0[29] > spd0[28]) 
-                    ? spd0[29] : spd0[28]) + 9) / 10) - 1) << 10; 
+        data |= (((((spd0[29] > spd0[28])
+                    ? spd0[29] : spd0[28]) + 9) / 10) - 1) << 10;
         data |= ((spd0[30] - spd0[29] + 9) / 10 - 2) << 12;
-   
-        if (spd0[18] & 0x08) 
+
+        if (spd0[18] & 0x08)
                 data |= ((0x03) << 14);
         else if (spd0[18] & 0x04)
                 data |= ((0x02) << 14);
@@ -1135,7 +1147,7 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
         else
                 data |= (0 << 14);
 
-        /* 
+        /*
            Calculate the size of bDIMMSize (power of 2) and
            merge the DIMM size by program start/end address.
         */
@@ -1145,9 +1157,9 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
         data |= (((size / 16) - 1) << 16);
         data |= (0 << 23);
         data |= 8;
-        writel(data, mmio + PDC_DIMM0_CONTROL_OFFSET); 
+        writel(data, mmio + PDC_DIMM0_CONTROL_OFFSET);
         readl(mmio + PDC_DIMM0_CONTROL_OFFSET);
-        return size;                          
+        return size;
 }
 
 
@@ -1155,7 +1167,7 @@ static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
 {
         u32 data, spd0;
         int error, i;
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1167,12 +1179,12 @@ static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
           Refresh Enable (bit 17)
         */
 
-        data = 0x022259F1;   
+        data = 0x022259F1;
         writel(data, mmio + PDC_SDRAM_CONTROL_OFFSET);
         readl(mmio + PDC_SDRAM_CONTROL_OFFSET);
 
         /* Turn on for ECC */
-        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS, 
+        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
                           PDC_DIMM_SPD_TYPE, &spd0);
         if (spd0 == 0x02) {
                 data |= (0x01 << 16);
@@ -1186,22 +1198,22 @@ static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
         data |= (1<<19);
         writel(data, mmio + PDC_SDRAM_CONTROL_OFFSET);
 
-        error = 1;                     
+        error = 1;
         for (i = 1; i <= 10; i++) {   /* polling ~5 secs */
                 data = readl(mmio + PDC_SDRAM_CONTROL_OFFSET);
                 if (!(data & (1<<19))) {
                         error = 0;
-                        break;     
+                        break;
                 }
                 msleep(i*100);
         }
         return error;
 }
-        
+
 
 static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
 {
-        int speed, size, length; 
+        int speed, size, length;
         u32 addr,spd0,pci_status;
         u32 tmp=0;
         u32 time_period=0;
@@ -1209,7 +1221,7 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
         u32 ticks=0;
         u32 clock=0;
         u32 fparam=0;
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1228,7 +1240,7 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
         /* Wait 3 seconds */
         msleep(3000);
 
-        /* 
+        /*
            When timer is enabled, counter is decreased every internal
            clock cycle.
         */
@@ -1236,24 +1248,24 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
         tcount = readl(mmio + PDC_TIME_COUNTER);
         VPRINTK("Time Counter Register (0x44): 0x%x\n", tcount);
 
-        /* 
+        /*
            If SX4 is on PCI-X bus, after 3 seconds, the timer counter
            register should be >= (0xffffffff - 3x10^8).
         */
         if(tcount >= PCI_X_TCOUNT) {
                 ticks = (time_period - tcount);
                 VPRINTK("Num counters 0x%x (%d)\n", ticks, ticks);
-        
+
                 clock = (ticks / 300000);
                 VPRINTK("10 * Internal clk = 0x%x (%d)\n", clock, clock);
-                
+
                 clock = (clock * 33);
                 VPRINTK("10 * Internal clk * 33 = 0x%x (%d)\n", clock, clock);
 
                 /* PLL F Param (bit 22:16) */
                 fparam = (1400000 / clock) - 2;
                 VPRINTK("PLL F Param: 0x%x (%d)\n", fparam, fparam);
-                
+
                 /* OD param = 0x2 (bit 31:30), R param = 0x5 (bit 29:25) */
                 pci_status = (0x8a001824 | (fparam << 16));
         } else
@@ -1264,21 +1276,21 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
         writel(pci_status, mmio + PDC_CTL_STATUS);
         readl(mmio + PDC_CTL_STATUS);
 
-        /* 
+        /*
            Read SPD of DIMM by I2C interface,
            and program the DIMM Module Controller.
         */
         if (!(speed = pdc20621_detect_dimm(pe))) {
-                printk(KERN_ERR "Detect Local DIMM Fail\n");  
+                printk(KERN_ERR "Detect Local DIMM Fail\n");
                 return 1;       /* DIMM error */
         }
         VPRINTK("Local DIMM Speed = %d\n", speed);
 
-        /* Programming DIMM0 Module Control Register (index_CID0:80h) */ 
+        /* Programming DIMM0 Module Control Register (index_CID0:80h) */
         size = pdc20621_prog_dimm0(pe);
         VPRINTK("Local DIMM Size = %dMB\n",size);
 
-        /* Programming DIMM Module Global Control Register (index_CID0:88h) */ 
+        /* Programming DIMM Module Global Control Register (index_CID0:88h) */
         if (pdc20621_prog_dimm_global(pe)) {
                 printk(KERN_ERR "Programming DIMM Module Global Control Register Fail\n");
                 return 1;
@@ -1297,30 +1309,30 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
 
                 pdc20621_put_to_dimm(pe, (void *) test_parttern1, 0x10040, 40);
                 pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x40, 40);
-                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0], 
+                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
-                pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x10040, 
+                pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x10040,
                                        40);
-                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0], 
+                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
 
                 pdc20621_put_to_dimm(pe, (void *) test_parttern1, 0x40, 40);
                 pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x40, 40);
-                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0], 
+                printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
         }
 #endif
 
         /* ECC initiliazation. */
 
-        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS, 
+        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
                           PDC_DIMM_SPD_TYPE, &spd0);
         if (spd0 == 0x02) {
                 VPRINTK("Start ECC initialization\n");
                 addr = 0;
                 length = size * 1024 * 1024;
                 while (addr < length) {
-                        pdc20621_put_to_dimm(pe, (void *) &tmp, addr, 
+                        pdc20621_put_to_dimm(pe, (void *) &tmp, addr,
                                              sizeof(u32));
                         addr += sizeof(u32);
                 }
@@ -1333,7 +1345,7 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
 static void pdc_20621_init(struct ata_probe_ent *pe)
 {
         u32 tmp;
-        void *mmio = pe->mmio_base;
+        void __iomem *mmio = pe->mmio_base;
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1366,7 +1378,8 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
-        void *mmio_base, *dimm_mmio = NULL;
+        void __iomem *mmio_base;
+        void __iomem *dimm_mmio = NULL;
         struct pdc_host_priv *hpriv = NULL;
         unsigned int board_idx = (unsigned int) ent->driver_data;
         int pci_dev_busy = 0;
@@ -1406,8 +1419,7 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap(pci_resource_start(pdev, 3),
-                            pci_resource_len(pdev, 3));
+        mmio_base = pci_iomap(pdev, 3, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
@@ -1421,8 +1433,7 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         }
         memset(hpriv, 0, sizeof(*hpriv));
 
-        dimm_mmio = ioremap(pci_resource_start(pdev, 4),
-                            pci_resource_len(pdev, 4));
+        dimm_mmio = pci_iomap(pdev, 4, 0);
         if (!dimm_mmio) {
                 kfree(hpriv);
                 rc = -ENOMEM;
@@ -1469,9 +1480,9 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
 
 err_out_iounmap_dimm:           /* only get to this label if 20621 */
         kfree(hpriv);
-        iounmap(dimm_mmio);
+        pci_iounmap(pdev, dimm_mmio);
 err_out_iounmap:
-        iounmap(mmio_base);
+        pci_iounmap(pdev, mmio_base);
 err_out_free_ent:
         kfree(probe_ent);
 err_out_regions:
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index a71fb54eebd3..42e13ed8eb5b 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -1,21 +1,26 @@
 /*
  *  sata_uli.c - ULi Electronics SATA
  *
- *  The contents of this file are subject to the Open
- *  Software License version 1.1 that can be found at
- *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
- *  by reference.
  *
- *  Alternatively, the contents of this file may be used under the terms
- *  of the GNU General Public License version 2 (the "GPL") as distributed
- *  in the kernel source COPYING file, in which case the provisions of
- *  the GPL are applicable instead of the above.  If you wish to allow
- *  the use of your version of this file only under the terms of the
- *  GPL and not to allow others to use your version of this file under
- *  the OSL, indicate your decision by deleting the provisions above and
- *  replace them with the notice and other provisions required by the GPL.
- *  If you do not delete the provisions above, a recipient may use your
- *  version of this file under either the OSL or the GPL.
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available under NDA.
  *
  */
 
@@ -120,8 +125,8 @@ static struct ata_port_info uli_port_info = {
         .sht            = &uli_sht,
         .host_flags     = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
                           ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x03,         //support pio mode 4 (FIXME)
-        .udma_mask      = 0x7f,         //support udma mode 6
+        .pio_mask       = 0x1f,         /* pio0-4 */
+        .udma_mask      = 0x7f,         /* udma0-6 */
         .port_ops       = &uli_ops,
 };
 
@@ -214,7 +219,7 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 rc = -ENOMEM;
                 goto err_out_regions;
         }
-        
+
         switch (board_idx) {
         case uli_5287:
                 probe_ent->port[0].scr_addr = ULI5287_BASE;
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index f43183c19a12..128b996b07b7 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -1,34 +1,38 @@
 /*
-   sata_via.c - VIA Serial ATA controllers
-
-   Maintained by:  Jeff Garzik <jgarzik@pobox.com>
-                   Please ALWAYS copy linux-ide@vger.kernel.org
+ *  sata_via.c - VIA Serial ATA controllers
+ *
+ *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                 Please ALWAYS copy linux-ide@vger.kernel.org
                    on emails.
-
-   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
-   Copyright 2003-2004 Jeff Garzik
-
-   The contents of this file are subject to the Open
-   Software License version 1.1 that can be found at
-   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
-   by reference.
-
-   Alternatively, the contents of this file may be used under the terms
-   of the GNU General Public License version 2 (the "GPL") as distributed
-   in the kernel source COPYING file, in which case the provisions of
-   the GPL are applicable instead of the above.  If you wish to allow
-   the use of your version of this file only under the terms of the
-   GPL and not to allow others to use your version of this file under
-   the OSL, indicate your decision by deleting the provisions above and
-   replace them with the notice and other provisions required by the GPL.
-   If you do not delete the provisions above, a recipient may use your
-   version of this file under either the OSL or the GPL.
-
-   ----------------------------------------------------------------------
-
-   To-do list:
-   * VT6421 PATA support
-
+ *
+ *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+ *  Copyright 2003-2004 Jeff Garzik
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available under NDA.
+ *
+ *
+ *  To-do list:
+ *  - VT6421 PATA support
+ *
  */
 
 #include <linux/kernel.h>
@@ -347,7 +351,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 probe_ent = vt6420_init_probe_ent(pdev);
         else
                 probe_ent = vt6421_init_probe_ent(pdev);
-        
+
         if (!probe_ent) {
                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
                        pci_name(pdev));
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index c5e09dc6f3de..cf94e0158a8d 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -9,9 +9,29 @@
  *
  *  Bits from Jeff Garzik, Copyright RedHat, Inc.
  *
- *  This file is subject to the terms and conditions of the GNU General Public
- *  License.  See the file "COPYING" in the main directory of this archive
- *  for more details.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Vitesse hardware documentation presumably available under NDA.
+ *  Intel 31244 (same hardware interface) documentation presumably
+ *  available from http://developer.intel.com/
+ *
  */
 
 #include <linux/kernel.h>
@@ -173,7 +193,8 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
                         struct ata_port *ap;
 
                         ap = host_set->ports[i];
-                        if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
+                        if (ap && !(ap->flags &
+                                    (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
                                 struct ata_queued_cmd *qc;
 
                                 qc = ata_qc_from_tag(ap, ap->active_tag);
@@ -231,7 +252,7 @@ static struct ata_port_operations vsc_sata_ops = {
         .scr_write              = vsc_sata_scr_write,
         .port_start             = ata_port_start,
         .port_stop              = ata_port_stop,
-        .host_stop              = ata_host_stop,
+        .host_stop              = ata_pci_host_stop,
 };
 
 static void __devinit vsc_sata_setup_port(struct ata_ioports *port, unsigned long base)
@@ -305,8 +326,7 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap(pci_resource_start(pdev, 0),
-                            pci_resource_len(pdev, 0));
+        mmio_base = pci_iomap(pdev, 0, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
@@ -342,7 +362,7 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
 
         pci_set_master(pdev);
 
-        /* 
+        /*
          * Config offset 0x98 is "Extended Control and Status Register 0"
          * Default value is (1 << 28).  All bits except bit 28 are reserved in
          * DPA mode.  If bit 28 is set, LED 0 reflects all ports' activity.