config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / ata / ata_piix.c
index 8e37be1..cc431d6 100644 (file)
  *  Hardware documentation available at http://developer.intel.com/
  *
  * Documentation
- *     Publically available from Intel web site. Errata documentation
- * is also publically available. As an aide to anyone hacking on this
+ *     Publicly available from Intel web site. Errata documentation
+ * is also publicly available. As an aide to anyone hacking on this
  * driver the list of errata that are relevant is below, going back to
  * PIIX4. Older device documentation is now a bit tricky to find.
  *
- * The chipsets all follow very much the same design. The orginal Triton
- * series chipsets do _not_ support independant device timings, but this
+ * The chipsets all follow very much the same design. The original Triton
+ * series chipsets do _not_ support independent device timings, but this
  * is fixed in Triton II. With the odd mobile exception the chips then
  * change little except in gaining more modes until SATA arrives. This
- * driver supports only the chips with independant timing (that is those
+ * driver supports only the chips with independent timing (that is those
  * with SITRE and the 0x44 timing register). See pata_oldpiix and pata_mpiix
  * for the early chip drivers.
  *
@@ -72,6 +72,7 @@
  *     ICH2    spec c #20      - IDE PRD must not cross a 64K boundary
  *                               and must be dword aligned
  *     ICH2    spec c #24      - UDMA mode 4,5 t85/86 should be 6ns not 3.3
+ *     ICH7    errata #16      - MWDMA1 timings are incorrect
  *
  * Should have been BIOS fixed:
  *     450NX:  errata #19      - DMA hangs on old 450NX
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/device.h>
+#include <linux/gfp.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
 #include <linux/dmi.h>
 
 #define DRV_NAME       "ata_piix"
-#define DRV_VERSION    "2.12"
+#define DRV_VERSION    "2.13"
 
 enum {
        PIIX_IOCFG              = 0x54, /* IDE I/O configuration register */
@@ -111,6 +113,8 @@ enum {
        PIIX_PATA_FLAGS         = ATA_FLAG_SLAVE_POSS,
        PIIX_SATA_FLAGS         = ATA_FLAG_SATA | PIIX_FLAG_CHECKINTR,
 
+       PIIX_FLAG_PIO16         = (1 << 30), /*support 16bit PIO only*/
+
        PIIX_80C_PRI            = (1 << 5) | (1 << 4),
        PIIX_80C_SEC            = (1 << 7) | (1 << 6),
 
@@ -120,7 +124,7 @@ enum {
        P2                      = 2,  /* port 2 */
        P3                      = 3,  /* port 3 */
        IDE                     = -1, /* IDE */
-       NA                      = -2, /* not avaliable */
+       NA                      = -2, /* not available */
        RV                      = -3, /* reserved */
 
        PIIX_AHCI_DEVICE        = 6,
@@ -136,6 +140,7 @@ enum piix_controller_ids {
        ich_pata_33,            /* ICH up to UDMA 33 only */
        ich_pata_66,            /* ICH up to 66 Mhz */
        ich_pata_100,           /* ICH up to UDMA 100 */
+       ich_pata_100_nomwdma1,  /* ICH up to UDMA 100 but with no MWDMA1*/
        ich5_sata,
        ich6_sata,
        ich6m_sata,
@@ -144,6 +149,7 @@ enum piix_controller_ids {
        ich8m_apple_sata,       /* locks up on second port enable */
        tolapai_sata,
        piix_pata_vmw,                  /* PIIX4 for VMware, spurious DMA_ERR */
+       ich8_sata_snb,
 };
 
 struct piix_map_db {
@@ -154,11 +160,13 @@ struct piix_map_db {
 
 struct piix_host_priv {
        const int *map;
+       u32 saved_iocfg;
        void __iomem *sidpr;
 };
 
 static int piix_init_one(struct pci_dev *pdev,
                         const struct pci_device_id *ent);
+static void piix_remove_one(struct pci_dev *pdev);
 static int piix_pata_prereset(struct ata_link *link, unsigned long deadline);
 static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev);
 static void piix_set_dmamode(struct ata_port *ap, struct ata_device *adev);
@@ -169,6 +177,10 @@ static int piix_sidpr_scr_read(struct ata_link *link,
                               unsigned int reg, u32 *val);
 static int piix_sidpr_scr_write(struct ata_link *link,
                                unsigned int reg, u32 val);
+static int piix_sidpr_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                             unsigned hints);
+static bool piix_irq_check(struct ata_port *ap);
+static int piix_port_start(struct ata_port *ap);
 #ifdef CONFIG_PM
 static int piix_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
 static int piix_pci_device_resume(struct pci_dev *pdev);
@@ -202,6 +214,8 @@ static const struct pci_device_id piix_pci_tbl[] = {
        { 0x8086, 0x248A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
        /* Intel ICH3 (E7500/1) UDMA 100 */
        { 0x8086, 0x248B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
+       /* Intel ICH4-L */
+       { 0x8086, 0x24C1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
        /* Intel ICH4 (i845GV, i845E, i852, i855) UDMA 100 */
        { 0x8086, 0x24CA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
        { 0x8086, 0x24CB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
@@ -214,14 +228,12 @@ static const struct pci_device_id piix_pci_tbl[] = {
        /* ICH6 (and 6) (i915) UDMA 100 */
        { 0x8086, 0x266F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
        /* ICH7/7-R (i945, i975) UDMA 100*/
-       { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
-       { 0x8086, 0x269E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
+       { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100_nomwdma1 },
+       { 0x8086, 0x269E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100_nomwdma1 },
        /* ICH8 Mobile PATA Controller */
        { 0x8086, 0x2850, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
 
-       /* NOTE: The following PCI ids must be kept in sync with the
-        * list in drivers/pci/quirks.c.
-        */
+       /* SATA ports */
 
        /* 82801EB (ICH5) */
        { 0x8086, 0x24d1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_sata },
@@ -289,6 +301,26 @@ static const struct pci_device_id piix_pci_tbl[] = {
        { 0x8086, 0x3b2d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
        /* SATA Controller IDE (PCH) */
        { 0x8086, 0x3b2e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata },
+       /* SATA Controller IDE (CPT) */
+       { 0x8086, 0x1c00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_snb },
+       /* SATA Controller IDE (CPT) */
+       { 0x8086, 0x1c01, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_snb },
+       /* SATA Controller IDE (CPT) */
+       { 0x8086, 0x1c08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+       /* SATA Controller IDE (CPT) */
+       { 0x8086, 0x1c09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+       /* SATA Controller IDE (PBG) */
+       { 0x8086, 0x1d00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_snb },
+       /* SATA Controller IDE (PBG) */
+       { 0x8086, 0x1d08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+       /* SATA Controller IDE (Panther Point) */
+       { 0x8086, 0x1e00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_snb },
+       /* SATA Controller IDE (Panther Point) */
+       { 0x8086, 0x1e01, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_snb },
+       /* SATA Controller IDE (Panther Point) */
+       { 0x8086, 0x1e08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+       /* SATA Controller IDE (Panther Point) */
+       { 0x8086, 0x1e09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
        { }     /* terminate list */
 };
 
@@ -296,7 +328,7 @@ static struct pci_driver piix_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = piix_pci_tbl,
        .probe                  = piix_init_one,
-       .remove                 = ata_pci_remove_one,
+       .remove                 = piix_remove_one,
 #ifdef CONFIG_PM
        .suspend                = piix_pci_device_suspend,
        .resume                 = piix_pci_device_resume,
@@ -307,8 +339,14 @@ static struct scsi_host_template piix_sht = {
        ATA_BMDMA_SHT(DRV_NAME),
 };
 
+static struct ata_port_operations piix_sata_ops = {
+       .inherits               = &ata_bmdma32_port_ops,
+       .sff_irq_check          = piix_irq_check,
+       .port_start             = piix_port_start,
+};
+
 static struct ata_port_operations piix_pata_ops = {
-       .inherits               = &ata_bmdma_port_ops,
+       .inherits               = &piix_sata_ops,
        .cable_detect           = ata_cable_40wire,
        .set_piomode            = piix_set_piomode,
        .set_dmamode            = piix_set_dmamode,
@@ -326,8 +364,14 @@ static struct ata_port_operations ich_pata_ops = {
        .set_dmamode            = ich_set_dmamode,
 };
 
-static struct ata_port_operations piix_sata_ops = {
-       .inherits               = &ata_bmdma_port_ops,
+static struct device_attribute *piix_sidpr_shost_attrs[] = {
+       &dev_attr_link_power_management_policy,
+       NULL
+};
+
+static struct scsi_host_template piix_sidpr_sht = {
+       ATA_BMDMA_SHT(DRV_NAME),
+       .shost_attrs            = piix_sidpr_shost_attrs,
 };
 
 static struct ata_port_operations piix_sidpr_sata_ops = {
@@ -335,6 +379,7 @@ static struct ata_port_operations piix_sidpr_sata_ops = {
        .hardreset              = sata_std_hardreset,
        .scr_read               = piix_sidpr_scr_read,
        .scr_write              = piix_sidpr_scr_write,
+       .set_lpm                = piix_sidpr_set_lpm,
 };
 
 static const struct piix_map_db ich5_map_db = {
@@ -438,40 +483,41 @@ static const struct piix_map_db *piix_map_db_table[] = {
        [ich8_2port_sata]       = &ich8_2port_map_db,
        [ich8m_apple_sata]      = &ich8m_apple_map_db,
        [tolapai_sata]          = &tolapai_map_db,
+       [ich8_sata_snb]         = &ich8_map_db,
 };
 
 static struct ata_port_info piix_port_info[] = {
        [piix_pata_mwdma] =     /* PIIX3 MWDMA only */
        {
                .flags          = PIIX_PATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
                .port_ops       = &piix_pata_ops,
        },
 
        [piix_pata_33] =        /* PIIX4 at 33MHz */
        {
                .flags          = PIIX_PATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
-               .udma_mask      = ATA_UDMA_MASK_40C,
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+               .udma_mask      = ATA_UDMA2,
                .port_ops       = &piix_pata_ops,
        },
 
        [ich_pata_33] =         /* ICH0 - ICH at 33Mhz*/
        {
                .flags          = PIIX_PATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio 0-4 */
-               .mwdma_mask     = 0x06, /* Check: maybe 0x07  */
-               .udma_mask      = ATA_UDMA2, /* UDMA33 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY, /* Check: maybe MWDMA0 is ok  */
+               .udma_mask      = ATA_UDMA2,
                .port_ops       = &ich_pata_ops,
        },
 
        [ich_pata_66] =         /* ICH controllers up to 66MHz */
        {
                .flags          = PIIX_PATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio 0-4 */
-               .mwdma_mask     = 0x06, /* MWDMA0 is broken on chip */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY, /* MWDMA0 is broken on chip */
                .udma_mask      = ATA_UDMA4,
                .port_ops       = &ich_pata_ops,
        },
@@ -479,17 +525,26 @@ static struct ata_port_info piix_port_info[] = {
        [ich_pata_100] =
        {
                .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x06, /* mwdma1-2 */
-               .udma_mask      = ATA_UDMA5, /* udma0-5 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY,
+               .udma_mask      = ATA_UDMA5,
+               .port_ops       = &ich_pata_ops,
+       },
+
+       [ich_pata_100_nomwdma1] =
+       {
+               .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2_ONLY,
+               .udma_mask      = ATA_UDMA5,
                .port_ops       = &ich_pata_ops,
        },
 
        [ich5_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -497,8 +552,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich6_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -506,8 +561,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich6m_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -515,8 +570,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8_sata] =
        {
                .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -524,8 +579,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8_2port_sata] =
        {
                .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -533,8 +588,8 @@ static struct ata_port_info piix_port_info[] = {
        [tolapai_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -542,8 +597,8 @@ static struct ata_port_info piix_port_info[] = {
        [ich8m_apple_sata] =
        {
                .flags          = PIIX_SATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x07, /* mwdma0-2 */
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
                .udma_mask      = ATA_UDMA6,
                .port_ops       = &piix_sata_ops,
        },
@@ -551,12 +606,25 @@ static struct ata_port_info piix_port_info[] = {
        [piix_pata_vmw] =
        {
                .flags          = PIIX_PATA_FLAGS,
-               .pio_mask       = 0x1f, /* pio0-4 */
-               .mwdma_mask     = 0x06, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
-               .udma_mask      = ATA_UDMA_MASK_40C,
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA12_ONLY, /* mwdma1-2 ?? CHECK 0 should be ok but slow */
+               .udma_mask      = ATA_UDMA2,
                .port_ops       = &piix_vmw_ops,
        },
 
+       /*
+        * some Sandybridge chipsets have broken 32 mode up to now,
+        * see https://bugzilla.kernel.org/show_bug.cgi?id=40592
+        */
+       [ich8_sata_snb] =
+       {
+               .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SIDPR | PIIX_FLAG_PIO16,
+               .pio_mask       = ATA_PIO4,
+               .mwdma_mask     = ATA_MWDMA2,
+               .udma_mask      = ATA_UDMA6,
+               .port_ops       = &piix_sata_ops,
+       },
+
 };
 
 static struct pci_bits piix_enable_bits[] = {
@@ -585,17 +653,29 @@ static const struct ich_laptop ich_laptop[] = {
        { 0x27DF, 0x0005, 0x0280 },     /* ICH7 on Acer 5602WLMi */
        { 0x27DF, 0x1025, 0x0102 },     /* ICH7 on Acer 5602aWLMi */
        { 0x27DF, 0x1025, 0x0110 },     /* ICH7 on Acer 3682WLMi */
+       { 0x27DF, 0x1028, 0x02b0 },     /* ICH7 on unknown Dell */
        { 0x27DF, 0x1043, 0x1267 },     /* ICH7 on Asus W5F */
        { 0x27DF, 0x103C, 0x30A1 },     /* ICH7 on HP Compaq nc2400 */
+       { 0x27DF, 0x103C, 0x361a },     /* ICH7 on unknown HP  */
        { 0x27DF, 0x1071, 0xD221 },     /* ICH7 on Hercules EC-900 */
+       { 0x27DF, 0x152D, 0x0778 },     /* ICH7 on unknown Intel */
        { 0x24CA, 0x1025, 0x0061 },     /* ICH4 on ACER Aspire 2023WLMi */
        { 0x24CA, 0x1025, 0x003d },     /* ICH4 on ACER TM290 */
        { 0x266F, 0x1025, 0x0066 },     /* ICH6 on ACER Aspire 1694WLMi */
        { 0x2653, 0x1043, 0x82D8 },     /* ICH6M on Asus Eee 701 */
+       { 0x27df, 0x104d, 0x900e },     /* ICH7 on Sony TZ-90 */
        /* end marker */
        { 0, }
 };
 
+static int piix_port_start(struct ata_port *ap)
+{
+       if (!(ap->flags & PIIX_FLAG_PIO16))
+               ap->pflags |= ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE;
+
+       return ata_bmdma_port_start(ap);
+}
+
 /**
  *     ich_pata_cable_detect - Probe host controller cable detect info
  *     @ap: Port for which cable detect info is desired
@@ -610,8 +690,9 @@ static const struct ich_laptop ich_laptop[] = {
 static int ich_pata_cable_detect(struct ata_port *ap)
 {
        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+       struct piix_host_priv *hpriv = ap->host->private_data;
        const struct ich_laptop *lap = &ich_laptop[0];
-       u8 tmp, mask;
+       u8 mask;
 
        /* Check for specials - Acer Aspire 5602WLMi */
        while (lap->device) {
@@ -625,8 +706,7 @@ static int ich_pata_cable_detect(struct ata_port *ap)
 
        /* check BIOS cable detect results */
        mask = ap->port_no == 0 ? PIIX_80C_PRI : PIIX_80C_SEC;
-       pci_read_config_byte(pdev, PIIX_IOCFG, &tmp);
-       if ((tmp & mask) == 0)
+       if ((hpriv->saved_iocfg & mask) == 0)
                return ATA_CBL_PATA40;
        return ATA_CBL_PATA80;
 }
@@ -649,6 +729,8 @@ static int piix_pata_prereset(struct ata_link *link, unsigned long deadline)
        return ata_sff_prereset(link, deadline);
 }
 
+static DEFINE_SPINLOCK(piix_lock);
+
 /**
  *     piix_set_piomode - Initialize host controller PATA PIO timings
  *     @ap: Port whose timings we are configuring
@@ -662,8 +744,9 @@ static int piix_pata_prereset(struct ata_link *link, unsigned long deadline)
 
 static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
-       unsigned int pio        = adev->pio_mode - XFER_PIO_0;
        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+       unsigned long flags;
+       unsigned int pio        = adev->pio_mode - XFER_PIO_0;
        unsigned int is_slave   = (adev->devno != 0);
        unsigned int master_port= ap->port_no ? 0x42 : 0x40;
        unsigned int slave_port = 0x44;
@@ -693,6 +776,8 @@ static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
        if (adev->class == ATA_DEV_ATA)
                control |= 4;   /* PPE enable */
 
+       spin_lock_irqsave(&piix_lock, flags);
+
        /* PIO configuration clears DTE unconditionally.  It will be
         * programmed in set_dmamode which is guaranteed to be called
         * after set_piomode if any DMA mode is available.
@@ -732,6 +817,8 @@ static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
                udma_enable &= ~(1 << (2 * ap->port_no + adev->devno));
                pci_write_config_byte(dev, 0x48, udma_enable);
        }
+
+       spin_unlock_irqrestore(&piix_lock, flags);
 }
 
 /**
@@ -749,6 +836,7 @@ static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, int isich)
 {
        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+       unsigned long flags;
        u8 master_port          = ap->port_no ? 0x42 : 0x40;
        u16 master_data;
        u8 speed                = adev->dma_mode;
@@ -762,6 +850,8 @@ static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, in
                            { 2, 1 },
                            { 2, 3 }, };
 
+       spin_lock_irqsave(&piix_lock, flags);
+
        pci_read_config_word(dev, master_port, &master_data);
        if (ap->udma_mask)
                pci_read_config_byte(dev, 0x48, &udma_enable);
@@ -844,14 +934,16 @@ static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, in
                                (timings[pio][1] << 8);
                }
 
-               if (ap->udma_mask) {
+               if (ap->udma_mask)
                        udma_enable &= ~(1 << devid);
-                       pci_write_config_word(dev, master_port, master_data);
-               }
+
+               pci_write_config_word(dev, master_port, master_data);
        }
        /* Don't scribble on 0x48 if the controller does not support UDMA */
        if (ap->udma_mask)
                pci_write_config_byte(dev, 0x48, udma_enable);
+
+       spin_unlock_irqrestore(&piix_lock, flags);
 }
 
 /**
@@ -935,6 +1027,20 @@ static int piix_sidpr_scr_write(struct ata_link *link,
        return 0;
 }
 
+static int piix_sidpr_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                             unsigned hints)
+{
+       return sata_link_scr_lpm(link, policy, false);
+}
+
+static bool piix_irq_check(struct ata_port *ap)
+{
+       if (unlikely(!ap->ioaddr.bmdma_addr))
+               return false;
+
+       return ap->ops->bmdma_status(ap) & ATA_DMA_INTR;
+}
+
 #ifdef CONFIG_PM
 static int piix_broken_suspend(void)
 {
@@ -1051,6 +1157,13 @@ static int piix_broken_suspend(void)
                                DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M500"),
                        },
                },
+               {
+                       .ident = "VGN-BX297XP",
+                       .matches = {
+                               DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                               DMI_MATCH(DMI_PRODUCT_NAME, "VGN-BX297XP"),
+                       },
+               },
 
                { }     /* terminate list */
        };
@@ -1066,6 +1179,21 @@ static int piix_broken_suspend(void)
                if (dmi_find_device(DMI_DEV_TYPE_OEM_STRING, oemstrs[i], NULL))
                        return 1;
 
+       /* TECRA M4 sometimes forgets its identify and reports bogus
+        * DMI information.  As the bogus information is a bit
+        * generic, match as many entries as possible.  This manual
+        * matching is necessary because dmi_system_id.matches is
+        * limited to four entries.
+        */
+       if (dmi_match(DMI_SYS_VENDOR, "TOSHIBA") &&
+           dmi_match(DMI_PRODUCT_NAME, "000000") &&
+           dmi_match(DMI_PRODUCT_VERSION, "000000") &&
+           dmi_match(DMI_PRODUCT_SERIAL, "000000") &&
+           dmi_match(DMI_BOARD_VENDOR, "TOSHIBA") &&
+           dmi_match(DMI_BOARD_NAME, "Portable PC") &&
+           dmi_match(DMI_BOARD_VERSION, "Version A0"))
+               return 1;
+
        return 0;
 }
 
@@ -1124,8 +1252,9 @@ static int piix_pci_device_resume(struct pci_dev *pdev)
                 */
                rc = pci_reenable_device(pdev);
                if (rc)
-                       dev_printk(KERN_ERR, &pdev->dev, "failed to enable "
-                                  "device after resume (%d)\n", rc);
+                       dev_err(&pdev->dev,
+                               "failed to enable device after resume (%d)\n",
+                               rc);
        } else
                rc = ata_pci_device_do_resume(pdev);
 
@@ -1202,9 +1331,11 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
                        no_piix_dma = 2;
        }
        if (no_piix_dma)
-               dev_printk(KERN_WARNING, &ata_dev->dev, "450NX errata present, disabling IDE DMA.\n");
-       if (no_piix_dma == 2)
-               dev_printk(KERN_WARNING, &ata_dev->dev, "A BIOS update may resolve this.\n");
+               dev_warn(&ata_dev->dev,
+                        "450NX errata present, disabling IDE DMA%s\n",
+                        no_piix_dma == 2 ? " - a BIOS update may resolve this"
+                        : "");
+
        return no_piix_dma;
 }
 
@@ -1237,41 +1368,73 @@ static const int *__devinit piix_init_sata_map(struct pci_dev *pdev,
 
        map = map_db->map[map_value & map_db->mask];
 
-       dev_printk(KERN_INFO, &pdev->dev, "MAP [");
+       dev_info(&pdev->dev, "MAP [");
        for (i = 0; i < 4; i++) {
                switch (map[i]) {
                case RV:
                        invalid_map = 1;
-                       printk(" XX");
+                       pr_cont(" XX");
                        break;
 
                case NA:
-                       printk(" --");
+                       pr_cont(" --");
                        break;
 
                case IDE:
                        WARN_ON((i & 1) || map[i + 1] != IDE);
                        pinfo[i / 2] = piix_port_info[ich_pata_100];
                        i++;
-                       printk(" IDE IDE");
+                       pr_cont(" IDE IDE");
                        break;
 
                default:
-                       printk(" P%d", map[i]);
+                       pr_cont(" P%d", map[i]);
                        if (i & 1)
                                pinfo[i / 2].flags |= ATA_FLAG_SLAVE_POSS;
                        break;
                }
        }
-       printk(" ]\n");
+       pr_cont(" ]\n");
 
        if (invalid_map)
-               dev_printk(KERN_ERR, &pdev->dev,
-                          "invalid MAP value %u\n", map_value);
+               dev_err(&pdev->dev, "invalid MAP value %u\n", map_value);
 
        return map;
 }
 
+static bool piix_no_sidpr(struct ata_host *host)
+{
+       struct pci_dev *pdev = to_pci_dev(host->dev);
+
+       /*
+        * Samsung DB-P70 only has three ATA ports exposed and
+        * curiously the unconnected first port reports link online
+        * while not responding to SRST protocol causing excessive
+        * detection delay.
+        *
+        * Unfortunately, the system doesn't carry enough DMI
+        * information to identify the machine but does have subsystem
+        * vendor and device set.  As it's unclear whether the
+        * subsystem vendor/device is used only for this specific
+        * board, the port can't be disabled solely with the
+        * information; however, turning off SIDPR access works around
+        * the problem.  Turn it off.
+        *
+        * This problem is reported in bnc#441240.
+        *
+        * https://bugzilla.novell.com/show_bug.cgi?id=441420
+        */
+       if (pdev->vendor == PCI_VENDOR_ID_INTEL && pdev->device == 0x2920 &&
+           pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG &&
+           pdev->subsystem_device == 0xb049) {
+               dev_warn(host->dev,
+                        "Samsung DB-P70 detected, disabling SIDPR\n");
+               return true;
+       }
+
+       return false;
+}
+
 static int __devinit piix_init_sidpr(struct ata_host *host)
 {
        struct pci_dev *pdev = to_pci_dev(host->dev);
@@ -1285,6 +1448,10 @@ static int __devinit piix_init_sidpr(struct ata_host *host)
                if (hpriv->map[i] == IDE)
                        return 0;
 
+       /* is it blacklisted? */
+       if (piix_no_sidpr(host))
+               return 0;
+
        if (!(host->ports[0]->flags & PIIX_FLAG_SIDPR))
                return 0;
 
@@ -1313,8 +1480,8 @@ static int __devinit piix_init_sidpr(struct ata_host *host)
                piix_sidpr_scr_read(link0, SCR_CONTROL, &scontrol);
 
                if ((scontrol & 0xf00) != 0x300) {
-                       dev_printk(KERN_INFO, host->dev, "SCR access via "
-                                  "SIDPR is available but doesn't work\n");
+                       dev_info(host->dev,
+                                "SCR access via SIDPR is available but doesn't work\n");
                        return 0;
                }
        }
@@ -1335,7 +1502,7 @@ static int __devinit piix_init_sidpr(struct ata_host *host)
        return 0;
 }
 
-static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
+static void piix_iocfg_bit18_quirk(struct ata_host *host)
 {
        static const struct dmi_system_id sysids[] = {
                {
@@ -1352,7 +1519,8 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
 
                { }     /* terminate list */
        };
-       u32 iocfg;
+       struct pci_dev *pdev = to_pci_dev(host->dev);
+       struct piix_host_priv *hpriv = host->private_data;
 
        if (!dmi_check_system(sysids))
                return;
@@ -1361,15 +1529,48 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
         * seem to use it to disable a channel.  Clear the bit on the
         * affected systems.
         */
-       pci_read_config_dword(pdev, PIIX_IOCFG, &iocfg);
-       if (iocfg & (1 << 18)) {
-               dev_printk(KERN_INFO, &pdev->dev,
-                          "applying IOCFG bit18 quirk\n");
-               iocfg &= ~(1 << 18);
-               pci_write_config_dword(pdev, PIIX_IOCFG, iocfg);
+       if (hpriv->saved_iocfg & (1 << 18)) {
+               dev_info(&pdev->dev, "applying IOCFG bit18 quirk\n");
+               pci_write_config_dword(pdev, PIIX_IOCFG,
+                                      hpriv->saved_iocfg & ~(1 << 18));
        }
 }
 
+static bool piix_broken_system_poweroff(struct pci_dev *pdev)
+{
+       static const struct dmi_system_id broken_systems[] = {
+               {
+                       .ident = "HP Compaq 2510p",
+                       .matches = {
+                               DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                               DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 2510p"),
+                       },
+                       /* PCI slot number of the controller */
+                       .driver_data = (void *)0x1FUL,
+               },
+               {
+                       .ident = "HP Compaq nc6000",
+                       .matches = {
+                               DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                               DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nc6000"),
+                       },
+                       /* PCI slot number of the controller */
+                       .driver_data = (void *)0x1FUL,
+               },
+
+               { }     /* terminate list */
+       };
+       const struct dmi_system_id *dmi = dmi_first_match(broken_systems);
+
+       if (dmi) {
+               unsigned long slot = (unsigned long)dmi->driver_data;
+               /* apply the quirk only to on-board controllers */
+               return slot == PCI_SLOT(pdev->devfn);
+       }
+
+       return false;
+}
+
 /**
  *     piix_init_one - Register PIIX ATA PCI device with kernel services
  *     @pdev: PCI device to register
@@ -1388,23 +1589,29 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
 static int __devinit piix_init_one(struct pci_dev *pdev,
                                   const struct pci_device_id *ent)
 {
-       static int printed_version;
        struct device *dev = &pdev->dev;
        struct ata_port_info port_info[2];
        const struct ata_port_info *ppi[] = { &port_info[0], &port_info[1] };
+       struct scsi_host_template *sht = &piix_sht;
        unsigned long port_flags;
        struct ata_host *host;
        struct piix_host_priv *hpriv;
        int rc;
 
-       if (!printed_version++)
-               dev_printk(KERN_DEBUG, &pdev->dev,
-                          "version " DRV_VERSION "\n");
+       ata_print_version_once(&pdev->dev, DRV_VERSION);
 
-       /* no hotplugging support (FIXME) */
-       if (!in_module_init)
+       /* no hotplugging support for later devices (FIXME) */
+       if (!in_module_init && ent->driver_data >= ich5_sata)
                return -ENODEV;
 
+       if (piix_broken_system_poweroff(pdev)) {
+               piix_port_info[ent->driver_data].flags |=
+                               ATA_FLAG_NO_POWEROFF_SPINDOWN |
+                                       ATA_FLAG_NO_HIBERNATE_SPINDOWN;
+               dev_info(&pdev->dev, "quirky BIOS, skipping spindown "
+                               "on poweroff and hibernation\n");
+       }
+
        port_info[0] = piix_port_info[ent->driver_data];
        port_info[1] = piix_port_info[ent->driver_data];
 
@@ -1415,6 +1622,17 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
        if (rc)
                return rc;
 
+       hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
+       if (!hpriv)
+               return -ENOMEM;
+
+       /* Save IOCFG, this will be used for cable detection, quirk
+        * detection and restoration on detach.  This is necessary
+        * because some ACPI implementations mess up cable related
+        * bits on _STM.  Reported on kernel bz#11879.
+        */
+       pci_read_config_dword(pdev, PIIX_IOCFG, &hpriv->saved_iocfg);
+
        /* ICH6R may be driven by either ata_piix or ahci driver
         * regardless of BIOS configuration.  Make sure AHCI mode is
         * off.
@@ -1426,15 +1644,11 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
        }
 
        /* SATA map init can change port_info, do it before prepping host */
-       hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
-       if (!hpriv)
-               return -ENOMEM;
-
        if (port_flags & ATA_FLAG_SATA)
                hpriv->map = piix_init_sata_map(pdev, port_info,
                                        piix_map_db_table[ent->driver_data]);
 
-       rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+       rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
        if (rc)
                return rc;
        host->private_data = hpriv;
@@ -1445,10 +1659,12 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                rc = piix_init_sidpr(host);
                if (rc)
                        return rc;
+               if (host->ports[0]->ops == &piix_sidpr_sata_ops)
+                       sht = &piix_sidpr_sht;
        }
 
        /* apply IOCFG bit18 quirk */
-       piix_iocfg_bit18_quirk(pdev);
+       piix_iocfg_bit18_quirk(host);
 
        /* On ICH5, some BIOSen disable the interrupt using the
         * PCI_COMMAND_INTX_DISABLE bit added in PCI 2.3.
@@ -1468,9 +1684,20 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                host->ports[1]->mwdma_mask = 0;
                host->ports[1]->udma_mask = 0;
        }
+       host->flags |= ATA_HOST_PARALLEL_SCAN;
 
        pci_set_master(pdev);
-       return ata_pci_sff_activate_host(host, ata_sff_interrupt, &piix_sht);
+       return ata_pci_sff_activate_host(host, ata_bmdma_interrupt, sht);
+}
+
+static void piix_remove_one(struct pci_dev *pdev)
+{
+       struct ata_host *host = dev_get_drvdata(&pdev->dev);
+       struct piix_host_priv *hpriv = host->private_data;
+
+       pci_write_config_dword(pdev, PIIX_IOCFG, hpriv->saved_iocfg);
+
+       ata_pci_remove_one(pdev);
 }
 
 static int __init piix_init(void)