12 files changed, 171 insertions, 131 deletions

diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 69ac373c72a..fdf27b9fce4 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -1117,6 +1117,13 @@ static int piix_broken_suspend(void)
                         },
                 },
                 {
+                        .ident = "Satellite Pro A120",
+                        .matches = {
+                                DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
+                                DMI_MATCH(DMI_PRODUCT_NAME, "Satellite Pro A120"),
+                        },
+                },
+                {
                         .ident = "Portege M500",
                         .matches = {
                                 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 11c9aea4f4f..e0bda9ff89c 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -4125,6 +4125,8 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
          * device and controller are SATA.
          */
         { "PIONEER DVD-RW  DVRTD08",    NULL,   ATA_HORKAGE_NOSETXFER },
+        { "PIONEER DVD-RW  DVRTD08A",   NULL,   ATA_HORKAGE_NOSETXFER },
+        { "PIONEER DVD-RW  DVR-215",    NULL,   ATA_HORKAGE_NOSETXFER },
         { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
         { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
 
@@ -5934,29 +5936,31 @@ void ata_host_init(struct ata_host *host, struct device *dev,
         host->ops = ops;
 }
 
-int ata_port_probe(struct ata_port *ap)
+void __ata_port_probe(struct ata_port *ap)
 {
-        int rc = 0;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        unsigned long flags;
 
-        /* probe */
-        if (ap->ops->error_handler) {
-                struct ata_eh_info *ehi = &ap->link.eh_info;
-                unsigned long flags;
+        /* kick EH for boot probing */
+        spin_lock_irqsave(ap->lock, flags);
 
-                /* kick EH for boot probing */
-                spin_lock_irqsave(ap->lock, flags);
+        ehi->probe_mask |= ATA_ALL_DEVICES;
+        ehi->action |= ATA_EH_RESET;
+        ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
 
-                ehi->probe_mask |= ATA_ALL_DEVICES;
-                ehi->action |= ATA_EH_RESET;
-                ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
+        ap->pflags &= ~ATA_PFLAG_INITIALIZING;
+        ap->pflags |= ATA_PFLAG_LOADING;
+        ata_port_schedule_eh(ap);
 
-                ap->pflags &= ~ATA_PFLAG_INITIALIZING;
-                ap->pflags |= ATA_PFLAG_LOADING;
-                ata_port_schedule_eh(ap);
+        spin_unlock_irqrestore(ap->lock, flags);
+}
 
-                spin_unlock_irqrestore(ap->lock, flags);
+int ata_port_probe(struct ata_port *ap)
+{
+        int rc = 0;
 
-                /* wait for EH to finish */
+        if (ap->ops->error_handler) {
+                __ata_port_probe(ap);
                 ata_port_wait_eh(ap);
         } else {
                 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index a9b28203800..c61316e9d2f 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -863,6 +863,7 @@ void ata_port_wait_eh(struct ata_port *ap)
                 goto retry;
         }
 }
+EXPORT_SYMBOL_GPL(ata_port_wait_eh);
 
 static int ata_eh_nr_in_flight(struct ata_port *ap)
 {
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 508a60bfe5c..1ee00c8b5b0 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -3838,6 +3838,19 @@ void ata_sas_port_stop(struct ata_port *ap)
 }
 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
 
+int ata_sas_async_port_init(struct ata_port *ap)
+{
+        int rc = ap->ops->port_start(ap);
+
+        if (!rc) {
+                ap->print_id = ata_print_id++;
+                __ata_port_probe(ap);
+        }
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(ata_sas_async_port_init);
+
 /**
  *      ata_sas_port_init - Initialize a SATA device
  *      @ap: SATA port to initialize
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 9691dd0966d..d8af325a6bd 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -720,13 +720,13 @@ static void ata_pio_sector(struct ata_queued_cmd *qc)
 
                 /* FIXME: use a bounce buffer */
                 local_irq_save(flags);
-                buf = kmap_atomic(page, KM_IRQ0);
+                buf = kmap_atomic(page);
 
                 /* do the actual data transfer */
                 ap->ops->sff_data_xfer(qc->dev, buf + offset, qc->sect_size,
                                        do_write);
 
-                kunmap_atomic(buf, KM_IRQ0);
+                kunmap_atomic(buf);
                 local_irq_restore(flags);
         } else {
                 buf = page_address(page);
@@ -865,13 +865,13 @@ next_sg:
 
                 /* FIXME: use bounce buffer */
                 local_irq_save(flags);
-                buf = kmap_atomic(page, KM_IRQ0);
+                buf = kmap_atomic(page);
 
                 /* do the actual data transfer */
                 consumed = ap->ops->sff_data_xfer(dev,  buf + offset,
                                                                 count, rw);
 
-                kunmap_atomic(buf, KM_IRQ0);
+                kunmap_atomic(buf);
                 local_irq_restore(flags);
         } else {
                 buf = page_address(page);
diff --git a/drivers/ata/libata-transport.c b/drivers/ata/libata-transport.c
index 9a7f0ea565d..74aaee30e26 100644
--- a/drivers/ata/libata-transport.c
+++ b/drivers/ata/libata-transport.c
@@ -291,6 +291,7 @@ int ata_tport_add(struct device *parent,
                 goto tport_err;
         }
 
+        device_enable_async_suspend(dev);
         pm_runtime_set_active(dev);
         pm_runtime_enable(dev);
 
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 814486d35c4..2e26fcaf635 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -105,6 +105,7 @@ extern int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg);
 extern struct ata_port *ata_port_alloc(struct ata_host *host);
 extern const char *sata_spd_string(unsigned int spd);
 extern int ata_port_probe(struct ata_port *ap);
+extern void __ata_port_probe(struct ata_port *ap);
 
 /* libata-acpi.c */
 #ifdef CONFIG_ATA_ACPI
@@ -151,7 +152,6 @@ extern void ata_eh_acquire(struct ata_port *ap);
 extern void ata_eh_release(struct ata_port *ap);
 extern enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern void ata_scsi_error(struct Scsi_Host *host);
-extern void ata_port_wait_eh(struct ata_port *ap);
 extern void ata_eh_fastdrain_timerfn(unsigned long arg);
 extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
 extern void ata_dev_disable(struct ata_device *dev);
diff --git a/drivers/ata/pata_at91.c b/drivers/ata/pata_at91.c
index a7d91a72ee3..53d3770a0b1 100644
--- a/drivers/ata/pata_at91.c
+++ b/drivers/ata/pata_at91.c
@@ -207,11 +207,11 @@ static void set_smc_timing(struct device *dev, struct ata_device *adev,
 {
         int ret = 0;
         int use_iordy;
+        struct sam9_smc_config smc;
         unsigned int t6z;         /* data tristate time in ns */
         unsigned int cycle;       /* SMC Cycle width in MCK ticks */
         unsigned int setup;       /* SMC Setup width in MCK ticks */
         unsigned int pulse;       /* CFIOR and CFIOW pulse width in MCK ticks */
-        unsigned int cs_setup = 0;/* CS4 or CS5 setup width in MCK ticks */
         unsigned int cs_pulse;    /* CS4 or CS5 pulse width in MCK ticks*/
         unsigned int tdf_cycles;  /* SMC TDF MCK ticks */
         unsigned long mck_hz;     /* MCK frequency in Hz */
@@ -244,26 +244,20 @@ static void set_smc_timing(struct device *dev, struct ata_device *adev,
         }
 
         dev_dbg(dev, "Use IORDY=%u, TDF Cycles=%u\n", use_iordy, tdf_cycles);
-        info->mode |= AT91_SMC_TDF_(tdf_cycles);
-
-        /* write SMC Setup Register */
-        at91_sys_write(AT91_SMC_SETUP(info->cs),
-                        AT91_SMC_NWESETUP_(setup) |
-                        AT91_SMC_NRDSETUP_(setup) |
-                        AT91_SMC_NCS_WRSETUP_(cs_setup) |
-                        AT91_SMC_NCS_RDSETUP_(cs_setup));
-        /* write SMC Pulse Register */
-        at91_sys_write(AT91_SMC_PULSE(info->cs),
-                        AT91_SMC_NWEPULSE_(pulse) |
-                        AT91_SMC_NRDPULSE_(pulse) |
-                        AT91_SMC_NCS_WRPULSE_(cs_pulse) |
-                        AT91_SMC_NCS_RDPULSE_(cs_pulse));
-        /* write SMC Cycle Register */
-        at91_sys_write(AT91_SMC_CYCLE(info->cs),
-                        AT91_SMC_NWECYCLE_(cycle) |
-                        AT91_SMC_NRDCYCLE_(cycle));
-        /* write SMC Mode Register*/
-        at91_sys_write(AT91_SMC_MODE(info->cs), info->mode);
+
+        /* SMC Setup Register */
+        smc.nwe_setup = smc.nrd_setup = setup;
+        smc.ncs_write_setup = smc.ncs_read_setup = 0;
+        /* SMC Pulse Register */
+        smc.nwe_pulse = smc.nrd_pulse = pulse;
+        smc.ncs_write_pulse = smc.ncs_read_pulse = cs_pulse;
+        /* SMC Cycle Register */
+        smc.write_cycle = smc.read_cycle = cycle;
+        /* SMC Mode Register*/
+        smc.tdf_cycles = tdf_cycles;
+        smc.mode = info->mode;
+
+        sam9_smc_configure(0, info->cs, &smc);
 }
 
 static void pata_at91_set_piomode(struct ata_port *ap, struct ata_device *adev)
@@ -288,20 +282,20 @@ static unsigned int pata_at91_data_xfer_noirq(struct ata_device *dev,
         struct at91_ide_info *info = dev->link->ap->host->private_data;
         unsigned int consumed;
         unsigned long flags;
-        unsigned int mode;
+        struct sam9_smc_config smc;
 
         local_irq_save(flags);
-        mode = at91_sys_read(AT91_SMC_MODE(info->cs));
+        sam9_smc_read_mode(0, info->cs, &smc);
 
         /* set 16bit mode before writing data */
-        at91_sys_write(AT91_SMC_MODE(info->cs),
-                        (mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_16);
+        smc.mode = (smc.mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_16;
+        sam9_smc_write_mode(0, info->cs, &smc);
 
         consumed = ata_sff_data_xfer(dev, buf, buflen, rw);
 
         /* restore 8bit mode after data is written */
-        at91_sys_write(AT91_SMC_MODE(info->cs),
-                        (mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_8);
+        smc.mode = (smc.mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_8;
+        sam9_smc_write_mode(0, info->cs, &smc);
 
         local_irq_restore(flags);
         return consumed;
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
index d6a4677fdf7..1e65842e2ca 100644
--- a/drivers/ata/pata_bf54x.c
+++ b/drivers/ata/pata_bf54x.c
@@ -251,6 +251,8 @@ static const u32 udma_tenvmin = 20;
 static const u32 udma_tackmin = 20;
 static const u32 udma_tssmin = 50;
 
+#define BFIN_MAX_SG_SEGMENTS 4
+
 /**
  *
  *      Function:       num_clocks_min
@@ -829,79 +831,61 @@ static void bfin_set_devctl(struct ata_port *ap, u8 ctl)
 
 static void bfin_bmdma_setup(struct ata_queued_cmd *qc)
 {
-        unsigned short config = WDSIZE_16;
+        struct ata_port *ap = qc->ap;
+        struct dma_desc_array *dma_desc_cpu = (struct dma_desc_array *)ap->bmdma_prd;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned short config = DMAFLOW_ARRAY | NDSIZE_5 | RESTART | WDSIZE_16 | DMAEN;
         struct scatterlist *sg;
         unsigned int si;
+        unsigned int channel;
+        unsigned int dir;
+        unsigned int size = 0;
 
         dev_dbg(qc->ap->dev, "in atapi dma setup\n");
         /* Program the ATA_CTRL register with dir */
         if (qc->tf.flags & ATA_TFLAG_WRITE) {
-                /* fill the ATAPI DMA controller */
-                set_dma_config(CH_ATAPI_TX, config);
-                set_dma_x_modify(CH_ATAPI_TX, 2);
-                for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                        set_dma_start_addr(CH_ATAPI_TX, sg_dma_address(sg));
-                        set_dma_x_count(CH_ATAPI_TX, sg_dma_len(sg) >> 1);
-                }
+                channel = CH_ATAPI_TX;
+                dir = DMA_TO_DEVICE;
         } else {
+                channel = CH_ATAPI_RX;
+                dir = DMA_FROM_DEVICE;
                 config |= WNR;
-                /* fill the ATAPI DMA controller */
-                set_dma_config(CH_ATAPI_RX, config);
-                set_dma_x_modify(CH_ATAPI_RX, 2);
-                for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                        set_dma_start_addr(CH_ATAPI_RX, sg_dma_address(sg));
-                        set_dma_x_count(CH_ATAPI_RX, sg_dma_len(sg) >> 1);
-                }
         }
-}
 
-/**
- *      bfin_bmdma_start - Start an IDE DMA transaction
- *      @qc: Info associated with this ATA transaction.
- *
- *      Note: Original code is ata_bmdma_start().
- */
+        dma_map_sg(ap->dev, qc->sg, qc->n_elem, dir);
 
-static void bfin_bmdma_start(struct ata_queued_cmd *qc)
-{
-        struct ata_port *ap = qc->ap;
-        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
-        struct scatterlist *sg;
-        unsigned int si;
+        /* fill the ATAPI DMA controller */
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                dma_desc_cpu[si].start_addr = sg_dma_address(sg);
+                dma_desc_cpu[si].cfg = config;
+                dma_desc_cpu[si].x_count = sg_dma_len(sg) >> 1;
+                dma_desc_cpu[si].x_modify = 2;
+                size += sg_dma_len(sg);
+        }
 
-        dev_dbg(qc->ap->dev, "in atapi dma start\n");
-        if (!(ap->udma_mask || ap->mwdma_mask))
-                return;
+        /* Set the last descriptor to stop mode */
+        dma_desc_cpu[qc->n_elem - 1].cfg &= ~(DMAFLOW | NDSIZE);
 
-        /* start ATAPI DMA controller*/
-        if (qc->tf.flags & ATA_TFLAG_WRITE) {
-                /*
-                 * On blackfin arch, uncacheable memory is not
-                 * allocated with flag GFP_DMA. DMA buffer from
-                 * common kenel code should be flushed if WB
-                 * data cache is enabled. Otherwise, this loop
-                 * is an empty loop and optimized out.
-                 */
-                for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                        flush_dcache_range(sg_dma_address(sg),
-                                sg_dma_address(sg) + sg_dma_len(sg));
-                }
-                enable_dma(CH_ATAPI_TX);
-                dev_dbg(qc->ap->dev, "enable udma write\n");
+        flush_dcache_range((unsigned int)dma_desc_cpu,
+                (unsigned int)dma_desc_cpu +
+                        qc->n_elem * sizeof(struct dma_desc_array));
 
-                /* Send ATA DMA write command */
-                bfin_exec_command(ap, &qc->tf);
+        /* Enable ATA DMA operation*/
+        set_dma_curr_desc_addr(channel, (unsigned long *)ap->bmdma_prd_dma);
+        set_dma_x_count(channel, 0);
+        set_dma_x_modify(channel, 0);
+        set_dma_config(channel, config);
+
+        SSYNC();
+
+        /* Send ATA DMA command */
+        bfin_exec_command(ap, &qc->tf);
 
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
                 /* set ATA DMA write direction */
                 ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
                         | XFER_DIR));
         } else {
-                enable_dma(CH_ATAPI_RX);
-                dev_dbg(qc->ap->dev, "enable udma read\n");
-
-                /* Send ATA DMA read command */
-                bfin_exec_command(ap, &qc->tf);
-
                 /* set ATA DMA read direction */
                 ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
                         & ~XFER_DIR));
@@ -913,12 +897,28 @@ static void bfin_bmdma_start(struct ata_queued_cmd *qc)
         /* Set ATAPI state machine contorl in terminate sequence */
         ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) | END_ON_TERM);
 
-        /* Set transfer length to buffer len */
-        for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                ATAPI_SET_XFER_LEN(base, (sg_dma_len(sg) >> 1));
-        }
+        /* Set transfer length to the total size of sg buffers */
+        ATAPI_SET_XFER_LEN(base, size >> 1);
+}
 
-        /* Enable ATA DMA operation*/
+/**
+ *      bfin_bmdma_start - Start an IDE DMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_start().
+ */
+
+static void bfin_bmdma_start(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        dev_dbg(qc->ap->dev, "in atapi dma start\n");
+
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return;
+
+        /* start ATAPI transfer*/
         if (ap->udma_mask)
                 ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base)
                         | ULTRA_START);
@@ -935,34 +935,23 @@ static void bfin_bmdma_start(struct ata_queued_cmd *qc)
 static void bfin_bmdma_stop(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
-        struct scatterlist *sg;
-        unsigned int si;
+        unsigned int dir;
 
         dev_dbg(qc->ap->dev, "in atapi dma stop\n");
+
         if (!(ap->udma_mask || ap->mwdma_mask))
                 return;
 
         /* stop ATAPI DMA controller*/
-        if (qc->tf.flags & ATA_TFLAG_WRITE)
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                dir = DMA_TO_DEVICE;
                 disable_dma(CH_ATAPI_TX);
-        else {
+        } else {
+                dir = DMA_FROM_DEVICE;
                 disable_dma(CH_ATAPI_RX);
-                if (ap->hsm_task_state & HSM_ST_LAST) {
-                        /*
-                         * On blackfin arch, uncacheable memory is not
-                         * allocated with flag GFP_DMA. DMA buffer from
-                         * common kenel code should be invalidated if
-                         * data cache is enabled. Otherwise, this loop
-                         * is an empty loop and optimized out.
-                         */
-                        for_each_sg(qc->sg, sg, qc->n_elem, si) {
-                                invalidate_dcache_range(
-                                        sg_dma_address(sg),
-                                        sg_dma_address(sg)
-                                        + sg_dma_len(sg));
-                        }
-                }
         }
+
+        dma_unmap_sg(ap->dev, qc->sg, qc->n_elem, dir);
 }
 
 /**
@@ -1260,6 +1249,11 @@ static void bfin_port_stop(struct ata_port *ap)
 {
         dev_dbg(ap->dev, "in atapi port stop\n");
         if (ap->udma_mask != 0 || ap->mwdma_mask != 0) {
+                dma_free_coherent(ap->dev,
+                        BFIN_MAX_SG_SEGMENTS * sizeof(struct dma_desc_array),
+                        ap->bmdma_prd,
+                        ap->bmdma_prd_dma);
+
                 free_dma(CH_ATAPI_RX);
                 free_dma(CH_ATAPI_TX);
         }
@@ -1271,14 +1265,29 @@ static int bfin_port_start(struct ata_port *ap)
         if (!(ap->udma_mask || ap->mwdma_mask))
                 return 0;
 
+        ap->bmdma_prd = dma_alloc_coherent(ap->dev,
+                                BFIN_MAX_SG_SEGMENTS * sizeof(struct dma_desc_array),
+                                &ap->bmdma_prd_dma,
+                                GFP_KERNEL);
+
+        if (ap->bmdma_prd == NULL) {
+                dev_info(ap->dev, "Unable to allocate DMA descriptor array.\n");
+                goto out;
+        }
+
         if (request_dma(CH_ATAPI_RX, "BFIN ATAPI RX DMA") >= 0) {
                 if (request_dma(CH_ATAPI_TX,
                         "BFIN ATAPI TX DMA") >= 0)
                         return 0;
 
                 free_dma(CH_ATAPI_RX);
+                dma_free_coherent(ap->dev,
+                        BFIN_MAX_SG_SEGMENTS * sizeof(struct dma_desc_array),
+                        ap->bmdma_prd,
+                        ap->bmdma_prd_dma);
         }
 
+out:
         ap->udma_mask = 0;
         ap->mwdma_mask = 0;
         dev_err(ap->dev, "Unable to request ATAPI DMA!"
@@ -1400,7 +1409,7 @@ static irqreturn_t bfin_ata_interrupt(int irq, void *dev_instance)
 
 static struct scsi_host_template bfin_sht = {
         ATA_BASE_SHT(DRV_NAME),
-        .sg_tablesize           = SG_NONE,
+        .sg_tablesize           = BFIN_MAX_SG_SEGMENTS,
         .dma_boundary           = ATA_DMA_BOUNDARY,
 };
 
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 5a2c95ba050..0120b0d1e9a 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -140,6 +140,7 @@ enum {
          */
         HCONTROL_ONLINE_PHY_RST = (1 << 31),
         HCONTROL_FORCE_OFFLINE = (1 << 30),
+        HCONTROL_LEGACY = (1 << 28),
         HCONTROL_PARITY_PROT_MOD = (1 << 14),
         HCONTROL_DPATH_PARITY = (1 << 12),
         HCONTROL_SNOOP_ENABLE = (1 << 10),
@@ -1223,6 +1224,10 @@ static int sata_fsl_init_controller(struct ata_host *host)
          * part of the port_start() callback
          */
 
+        /* sata controller to operate in enterprise mode */
+        temp = ioread32(hcr_base + HCONTROL);
+        iowrite32(temp & ~HCONTROL_LEGACY, hcr_base + HCONTROL);
+
         /* ack. any pending IRQs for this controller/port */
         temp = ioread32(hcr_base + HSTATUS);
         if (temp & 0x3F)
@@ -1421,6 +1426,12 @@ static int sata_fsl_resume(struct platform_device *op)
         /* Recovery the CHBA register in host controller cmd register set */
         iowrite32(pp->cmdslot_paddr & 0xffffffff, hcr_base + CHBA);
 
+        iowrite32((ioread32(hcr_base + HCONTROL)
+                                | HCONTROL_ONLINE_PHY_RST
+                                | HCONTROL_SNOOP_ENABLE
+                                | HCONTROL_PMP_ATTACHED),
+                        hcr_base + HCONTROL);
+
         ata_host_resume(host);
         return 0;
 }
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index e0bc9646a38..55d6179dde5 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -599,9 +599,9 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 
-static int adma_enabled;
-static int swncq_enabled = 1;
-static int msi_enabled;
+static bool adma_enabled;
+static bool swncq_enabled = 1;
+static bool msi_enabled;
 
 static void nv_adma_register_mode(struct ata_port *ap)
 {
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 1e9140626a8..e7e610aa9a7 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -417,7 +417,7 @@ static struct ata_port_operations sil24_ops = {
 #endif
 };
 
-static int sata_sil24_msi;    /* Disable MSI */
+static bool sata_sil24_msi;    /* Disable MSI */
 module_param_named(msi, sata_sil24_msi, bool, S_IRUGO);
 MODULE_PARM_DESC(msi, "Enable MSI (Default: false)");