config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / ata / libata-acpi.c
index 5932ae2..bb7c5f1 100644 (file)
@@ -6,6 +6,7 @@
  * Copyright (C) 2006 Randy Dunlap
  */
 
+#include <linux/module.h>
 #include <linux/ata.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/acpi.h>
 #include <linux/libata.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <scsi/scsi_device.h>
 #include "libata.h"
 
 #include <acpi/acpi_bus.h>
-#include <acpi/acnames.h>
-#include <acpi/acnamesp.h>
-#include <acpi/acparser.h>
-#include <acpi/acexcep.h>
-#include <acpi/acmacros.h>
-#include <acpi/actypes.h>
+
+unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
+module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
+MODULE_PARM_DESC(acpi_gtf_filter, "filter mask for ACPI _GTF commands, set to filter out (0x1=set xfermode, 0x2=lock/freeze lock, 0x4=DIPM, 0x8=FPDMA non-zero offset, 0x10=FPDMA DMA Setup FIS auto-activate)");
 
 #define NO_PORT_MULT           0xffff
 #define SATA_ADR(root, pmp)    (((root) << 16) | (pmp))
@@ -64,8 +64,8 @@ void ata_acpi_associate_sata_port(struct ata_port *ap)
 {
        WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
 
-       if (!ap->nr_pmp_links) {
-               acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
+       if (!sata_pmp_attached(ap)) {
+               u64 adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
 
                ap->link.device->acpi_handle =
                        acpi_get_child(ap->host->acpi_handle, adr);
@@ -74,8 +74,8 @@ void ata_acpi_associate_sata_port(struct ata_port *ap)
 
                ap->link.device->acpi_handle = NULL;
 
-               ata_port_for_each_link(link, ap) {
-                       acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
+               ata_for_each_link(link, ap, EDGE) {
+                       u64 adr = SATA_ADR(ap->port_no, link->pmp);
 
                        link->device->acpi_handle =
                                acpi_get_child(ap->host->acpi_handle, adr);
@@ -105,47 +105,129 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
                ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
 }
 
-static void ata_acpi_handle_hotplug(struct ata_port *ap, struct kobject *kobj,
+/* @ap and @dev are the same as ata_acpi_handle_hotplug() */
+static void ata_acpi_detach_device(struct ata_port *ap, struct ata_device *dev)
+{
+       if (dev)
+               dev->flags |= ATA_DFLAG_DETACH;
+       else {
+               struct ata_link *tlink;
+               struct ata_device *tdev;
+
+               ata_for_each_link(tlink, ap, EDGE)
+                       ata_for_each_dev(tdev, tlink, ALL)
+                               tdev->flags |= ATA_DFLAG_DETACH;
+       }
+
+       ata_port_schedule_eh(ap);
+}
+
+/**
+ * ata_acpi_handle_hotplug - ACPI event handler backend
+ * @ap: ATA port ACPI event occurred
+ * @dev: ATA device ACPI event occurred (can be NULL)
+ * @event: ACPI event which occurred
+ *
+ * All ACPI bay / device realted events end up in this function.  If
+ * the event is port-wide @dev is NULL.  If the event is specific to a
+ * device, @dev points to it.
+ *
+ * Hotplug (as opposed to unplug) notification is always handled as
+ * port-wide while unplug only kills the target device on device-wide
+ * event.
+ *
+ * LOCKING:
+ * ACPI notify handler context.  May sleep.
+ */
+static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
                                    u32 event)
 {
-       char event_string[12];
-       char *envp[] = { event_string, NULL };
        struct ata_eh_info *ehi = &ap->link.eh_info;
-
-       if (event == 0 || event == 1) {
-              unsigned long flags;
-              spin_lock_irqsave(ap->lock, flags);
-              ata_ehi_clear_desc(ehi);
-              ata_ehi_push_desc(ehi, "ACPI event");
-              ata_ehi_hotplugged(ehi);
-              ata_port_freeze(ap);
-              spin_unlock_irqrestore(ap->lock, flags);
+       int wait = 0;
+       unsigned long flags;
+
+       spin_lock_irqsave(ap->lock, flags);
+       /*
+        * When dock driver calls into the routine, it will always use
+        * ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
+        * ACPI_NOTIFY_EJECT_REQUEST for remove
+        */
+       switch (event) {
+       case ACPI_NOTIFY_BUS_CHECK:
+       case ACPI_NOTIFY_DEVICE_CHECK:
+               ata_ehi_push_desc(ehi, "ACPI event");
+
+               ata_ehi_hotplugged(ehi);
+               ata_port_freeze(ap);
+               break;
+       case ACPI_NOTIFY_EJECT_REQUEST:
+               ata_ehi_push_desc(ehi, "ACPI event");
+
+               ata_acpi_detach_device(ap, dev);
+               wait = 1;
+               break;
        }
 
-       if (kobj) {
-               sprintf(event_string, "BAY_EVENT=%d", event);
-               kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
-       }
+       spin_unlock_irqrestore(ap->lock, flags);
+
+       if (wait)
+               ata_port_wait_eh(ap);
 }
 
-static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
+static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data)
 {
        struct ata_device *dev = data;
+
+       ata_acpi_handle_hotplug(dev->link->ap, dev, event);
+}
+
+static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data)
+{
+       struct ata_port *ap = data;
+
+       ata_acpi_handle_hotplug(ap, NULL, event);
+}
+
+static void ata_acpi_uevent(struct ata_port *ap, struct ata_device *dev,
+       u32 event)
+{
        struct kobject *kobj = NULL;
+       char event_string[20];
+       char *envp[] = { event_string, NULL };
 
-       if (dev->sdev)
-               kobj = &dev->sdev->sdev_gendev.kobj;
+       if (dev) {
+               if (dev->sdev)
+                       kobj = &dev->sdev->sdev_gendev.kobj;
+       } else
+               kobj = &ap->dev->kobj;
 
-       ata_acpi_handle_hotplug(dev->link->ap, kobj, event);
+       if (kobj) {
+               snprintf(event_string, 20, "BAY_EVENT=%d", event);
+               kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
+       }
 }
 
-static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
+static void ata_acpi_ap_uevent(acpi_handle handle, u32 event, void *data)
 {
-       struct ata_port *ap = data;
+       ata_acpi_uevent(data, NULL, event);
+}
 
-       ata_acpi_handle_hotplug(ap, &ap->dev->kobj, event);
+static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data)
+{
+       struct ata_device *dev = data;
+       ata_acpi_uevent(dev->link->ap, dev, event);
 }
 
+static const struct acpi_dock_ops ata_acpi_dev_dock_ops = {
+       .handler = ata_acpi_dev_notify_dock,
+       .uevent = ata_acpi_dev_uevent,
+};
+
+static const struct acpi_dock_ops ata_acpi_ap_dock_ops = {
+       .handler = ata_acpi_ap_notify_dock,
+       .uevent = ata_acpi_ap_uevent,
+};
+
 /**
  * ata_acpi_associate - associate ATA host with ACPI objects
  * @host: target ATA host
@@ -178,20 +260,20 @@ void ata_acpi_associate(struct ata_host *host)
                else
                        ata_acpi_associate_ide_port(ap);
 
-               if (ap->acpi_handle)
-                       acpi_install_notify_handler (ap->acpi_handle,
-                                                    ACPI_SYSTEM_NOTIFY,
-                                                    ata_acpi_ap_notify,
-                                                    ap);
+               if (ap->acpi_handle) {
+                       /* we might be on a docking station */
+                       register_hotplug_dock_device(ap->acpi_handle,
+                                            &ata_acpi_ap_dock_ops, ap);
+               }
 
                for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
                        struct ata_device *dev = &ap->link.device[j];
 
-                       if (dev->acpi_handle)
-                               acpi_install_notify_handler (dev->acpi_handle,
-                                                            ACPI_SYSTEM_NOTIFY,
-                                                            ata_acpi_dev_notify,
-                                                            dev);
+                       if (dev->acpi_handle) {
+                               /* we might be on a docking station */
+                               register_hotplug_dock_device(dev->acpi_handle,
+                                            &ata_acpi_dev_dock_ops, dev);
+                       }
                }
        }
 }
@@ -250,25 +332,22 @@ int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
 
        rc = -EINVAL;
        if (ACPI_FAILURE(status)) {
-               ata_port_printk(ap, KERN_ERR,
-                               "ACPI get timing mode failed (AE 0x%x)\n",
-                               status);
+               ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n",
+                            status);
                goto out_free;
        }
 
        out_obj = output.pointer;
        if (out_obj->type != ACPI_TYPE_BUFFER) {
-               ata_port_printk(ap, KERN_WARNING,
-                               "_GTM returned unexpected object type 0x%x\n",
-                               out_obj->type);
+               ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n",
+                             out_obj->type);
 
                goto out_free;
        }
 
        if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
-               ata_port_printk(ap, KERN_ERR,
-                               "_GTM returned invalid length %d\n",
-                               out_obj->buffer.length);
+               ata_port_err(ap, "_GTM returned invalid length %d\n",
+                            out_obj->buffer.length);
                goto out_free;
        }
 
@@ -320,8 +399,8 @@ int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
        if (status == AE_NOT_FOUND)
                return -ENOENT;
        if (ACPI_FAILURE(status)) {
-               ata_port_printk(ap, KERN_ERR,
-                       "ACPI set timing mode failed (status=0x%x)\n", status);
+               ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
+                            status);
                return -EINVAL;
        }
        return 0;
@@ -368,8 +447,8 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
        output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
-                              __FUNCTION__, ap->port_no);
+               ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
+                           __func__, ap->port_no);
 
        /* _GTF has no input parameters */
        status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
@@ -377,9 +456,8 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
 
        if (ACPI_FAILURE(status)) {
                if (status != AE_NOT_FOUND) {
-                       ata_dev_printk(dev, KERN_WARNING,
-                                      "_GTF evaluation failed (AE 0x%x)\n",
-                                      status);
+                       ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
+                                    status);
                        rc = -EINVAL;
                }
                goto out_free;
@@ -387,27 +465,24 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
 
        if (!output.length || !output.pointer) {
                if (ata_msg_probe(ap))
-                       ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
-                               "length or ptr is NULL (0x%llx, 0x%p)\n",
-                               __FUNCTION__,
-                               (unsigned long long)output.length,
-                               output.pointer);
+                       ata_dev_dbg(dev, "%s: Run _GTF: length or ptr is NULL (0x%llx, 0x%p)\n",
+                                   __func__,
+                                   (unsigned long long)output.length,
+                                   output.pointer);
                rc = -EINVAL;
                goto out_free;
        }
 
        if (out_obj->type != ACPI_TYPE_BUFFER) {
-               ata_dev_printk(dev, KERN_WARNING,
-                              "_GTF unexpected object type 0x%x\n",
-                              out_obj->type);
+               ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n",
+                            out_obj->type);
                rc = -EINVAL;
                goto out_free;
        }
 
        if (out_obj->buffer.length % REGS_PER_GTF) {
-               ata_dev_printk(dev, KERN_WARNING,
-                              "unexpected _GTF length (%d)\n",
-                              out_obj->buffer.length);
+               ata_dev_warn(dev, "unexpected _GTF length (%d)\n",
+                            out_obj->buffer.length);
                rc = -EINVAL;
                goto out_free;
        }
@@ -417,9 +492,8 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
        if (gtf) {
                *gtf = (void *)out_obj->buffer.pointer;
                if (ata_msg_probe(ap))
-                       ata_dev_printk(dev, KERN_DEBUG,
-                                      "%s: returning gtf=%p, gtf_count=%d\n",
-                                      __FUNCTION__, *gtf, rc);
+                       ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
+                                   __func__, *gtf, rc);
        }
        return rc;
 
@@ -429,49 +503,156 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
 }
 
 /**
+ * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
+ * @dev: target device
+ * @gtm: GTM parameter to use
+ *
+ * Determine xfermask for @dev from @gtm.
+ *
+ * LOCKING:
+ * None.
+ *
+ * RETURNS:
+ * Determined xfermask.
+ */
+unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
+                                   const struct ata_acpi_gtm *gtm)
+{
+       unsigned long xfer_mask = 0;
+       unsigned int type;
+       int unit;
+       u8 mode;
+
+       /* we always use the 0 slot for crap hardware */
+       unit = dev->devno;
+       if (!(gtm->flags & 0x10))
+               unit = 0;
+
+       /* PIO */
+       mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
+       xfer_mask |= ata_xfer_mode2mask(mode);
+
+       /* See if we have MWDMA or UDMA data. We don't bother with
+        * MWDMA if UDMA is available as this means the BIOS set UDMA
+        * and our error changedown if it works is UDMA to PIO anyway.
+        */
+       if (!(gtm->flags & (1 << (2 * unit))))
+               type = ATA_SHIFT_MWDMA;
+       else
+               type = ATA_SHIFT_UDMA;
+
+       mode = ata_timing_cycle2mode(type, gtm->drive[unit].dma);
+       xfer_mask |= ata_xfer_mode2mask(mode);
+
+       return xfer_mask;
+}
+EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);
+
+/**
  * ata_acpi_cbl_80wire         -       Check for 80 wire cable
  * @ap: Port to check
+ * @gtm: GTM data to use
  *
- * Return 1 if the ACPI mode data for this port indicates the BIOS selected
- * an 80wire mode.
+ * Return 1 if the @gtm indicates the BIOS selected an 80wire mode.
  */
-
-int ata_acpi_cbl_80wire(struct ata_port *ap)
+int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
 {
-       const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
-       int valid = 0;
+       struct ata_device *dev;
 
-       if (!gtm)
-               return 0;
+       ata_for_each_dev(dev, &ap->link, ENABLED) {
+               unsigned long xfer_mask, udma_mask;
+
+               xfer_mask = ata_acpi_gtm_xfermask(dev, gtm);
+               ata_unpack_xfermask(xfer_mask, NULL, NULL, &udma_mask);
+
+               if (udma_mask & ~ATA_UDMA_MASK_40C)
+                       return 1;
+       }
 
-       /* Split timing, DMA enabled */
-       if ((gtm->flags & 0x11) == 0x11 && gtm->drive[0].dma < 55)
-               valid |= 1;
-       if ((gtm->flags & 0x14) == 0x14 && gtm->drive[1].dma < 55)
-               valid |= 2;
-       /* Shared timing, DMA enabled */
-       if ((gtm->flags & 0x11) == 0x01 && gtm->drive[0].dma < 55)
-               valid |= 1;
-       if ((gtm->flags & 0x14) == 0x04 && gtm->drive[0].dma < 55)
-               valid |= 2;
-
-       /* Drive check */
-       if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
-               return 1;
-       if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
-               return 1;
        return 0;
 }
-
 EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
 
+static void ata_acpi_gtf_to_tf(struct ata_device *dev,
+                              const struct ata_acpi_gtf *gtf,
+                              struct ata_taskfile *tf)
+{
+       ata_tf_init(dev, tf);
+
+       tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+       tf->protocol = ATA_PROT_NODATA;
+       tf->feature = gtf->tf[0];       /* 0x1f1 */
+       tf->nsect   = gtf->tf[1];       /* 0x1f2 */
+       tf->lbal    = gtf->tf[2];       /* 0x1f3 */
+       tf->lbam    = gtf->tf[3];       /* 0x1f4 */
+       tf->lbah    = gtf->tf[4];       /* 0x1f5 */
+       tf->device  = gtf->tf[5];       /* 0x1f6 */
+       tf->command = gtf->tf[6];       /* 0x1f7 */
+}
+
+static int ata_acpi_filter_tf(struct ata_device *dev,
+                             const struct ata_taskfile *tf,
+                             const struct ata_taskfile *ptf)
+{
+       if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
+               /* libata doesn't use ACPI to configure transfer mode.
+                * It will only confuse device configuration.  Skip.
+                */
+               if (tf->command == ATA_CMD_SET_FEATURES &&
+                   tf->feature == SETFEATURES_XFER)
+                       return 1;
+       }
+
+       if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
+               /* BIOS writers, sorry but we don't wanna lock
+                * features unless the user explicitly said so.
+                */
+
+               /* DEVICE CONFIGURATION FREEZE LOCK */
+               if (tf->command == ATA_CMD_CONF_OVERLAY &&
+                   tf->feature == ATA_DCO_FREEZE_LOCK)
+                       return 1;
+
+               /* SECURITY FREEZE LOCK */
+               if (tf->command == ATA_CMD_SEC_FREEZE_LOCK)
+                       return 1;
+
+               /* SET MAX LOCK and SET MAX FREEZE LOCK */
+               if ((!ptf || ptf->command != ATA_CMD_READ_NATIVE_MAX) &&
+                   tf->command == ATA_CMD_SET_MAX &&
+                   (tf->feature == ATA_SET_MAX_LOCK ||
+                    tf->feature == ATA_SET_MAX_FREEZE_LOCK))
+                       return 1;
+       }
+
+       if (tf->command == ATA_CMD_SET_FEATURES &&
+           tf->feature == SETFEATURES_SATA_ENABLE) {
+               /* inhibit enabling DIPM */
+               if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
+                   tf->nsect == SATA_DIPM)
+                       return 1;
+
+               /* inhibit FPDMA non-zero offset */
+               if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
+                   (tf->nsect == SATA_FPDMA_OFFSET ||
+                    tf->nsect == SATA_FPDMA_IN_ORDER))
+                       return 1;
+
+               /* inhibit FPDMA auto activation */
+               if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
+                   tf->nsect == SATA_FPDMA_AA)
+                       return 1;
+       }
+
+       return 0;
+}
+
 /**
- * taskfile_load_raw - send taskfile registers to host controller
+ * ata_acpi_run_tf - send taskfile registers to host controller
  * @dev: target ATA device
  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
  *
- * Outputs ATA taskfile to standard ATA host controller using MMIO
- * or PIO as indicated by the ATA_FLAG_MMIO flag.
+ * Outputs ATA taskfile to standard ATA host controller.
  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
  * hob_lbal, hob_lbam, and hob_lbah.
@@ -485,59 +666,82 @@ EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
  * EH context.
  *
  * RETURNS:
- * 0 on success, -errno on failure.
+ * 1 if command is executed successfully.  0 if ignored, rejected or
+ * filtered out, -errno on other errors.
  */
-static int taskfile_load_raw(struct ata_device *dev,
-                             const struct ata_acpi_gtf *gtf)
+static int ata_acpi_run_tf(struct ata_device *dev,
+                          const struct ata_acpi_gtf *gtf,
+                          const struct ata_acpi_gtf *prev_gtf)
 {
-       struct ata_port *ap = dev->link->ap;
-       struct ata_taskfile tf, rtf;
+       struct ata_taskfile *pptf = NULL;
+       struct ata_taskfile tf, ptf, rtf;
        unsigned int err_mask;
+       const char *level;
+       const char *descr;
+       char msg[60];
+       int rc;
 
        if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
            && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
            && (gtf->tf[6] == 0))
                return 0;
 
-       ata_tf_init(dev, &tf);
-
-       /* convert gtf to tf */
-       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
-       tf.protocol = ATA_PROT_NODATA;
-       tf.feature = gtf->tf[0];        /* 0x1f1 */
-       tf.nsect   = gtf->tf[1];        /* 0x1f2 */
-       tf.lbal    = gtf->tf[2];        /* 0x1f3 */
-       tf.lbam    = gtf->tf[3];        /* 0x1f4 */
-       tf.lbah    = gtf->tf[4];        /* 0x1f5 */
-       tf.device  = gtf->tf[5];        /* 0x1f6 */
-       tf.command = gtf->tf[6];        /* 0x1f7 */
+       ata_acpi_gtf_to_tf(dev, gtf, &tf);
+       if (prev_gtf) {
+               ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
+               pptf = &ptf;
+       }
 
-       if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
-                              "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
-                              tf.command, tf.feature, tf.nsect,
-                              tf.lbal, tf.lbam, tf.lbah, tf.device);
-
-       rtf = tf;
-       err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0, 0);
-       if (err_mask) {
-               ata_dev_printk(dev, KERN_ERR,
-                       "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
-                       "(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
-                       tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
-                       tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
-               return -EIO;
+       if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
+               rtf = tf;
+               err_mask = ata_exec_internal(dev, &rtf, NULL,
+                                            DMA_NONE, NULL, 0, 0);
+
+               switch (err_mask) {
+               case 0:
+                       level = KERN_DEBUG;
+                       snprintf(msg, sizeof(msg), "succeeded");
+                       rc = 1;
+                       break;
+
+               case AC_ERR_DEV:
+                       level = KERN_INFO;
+                       snprintf(msg, sizeof(msg),
+                                "rejected by device (Stat=0x%02x Err=0x%02x)",
+                                rtf.command, rtf.feature);
+                       rc = 0;
+                       break;
+
+               default:
+                       level = KERN_ERR;
+                       snprintf(msg, sizeof(msg),
+                                "failed (Emask=0x%x Stat=0x%02x Err=0x%02x)",
+                                err_mask, rtf.command, rtf.feature);
+                       rc = -EIO;
+                       break;
+               }
+       } else {
+               level = KERN_INFO;
+               snprintf(msg, sizeof(msg), "filtered out");
+               rc = 0;
        }
+       descr = ata_get_cmd_descript(tf.command);
 
-       return 0;
+       ata_dev_printk(dev, level,
+                      "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
+                      tf.command, tf.feature, tf.nsect, tf.lbal,
+                      tf.lbam, tf.lbah, tf.device,
+                      (descr ? descr : "unknown"), msg);
+
+       return rc;
 }
 
 /**
  * ata_acpi_exec_tfs - get then write drive taskfile settings
  * @dev: target ATA device
- * @nr_executed: out paramter for the number of executed commands
+ * @nr_executed: out parameter for the number of executed commands
  *
- * Evaluate _GTF and excute returned taskfiles.
+ * Evaluate _GTF and execute returned taskfiles.
  *
  * LOCKING:
  * EH context.
@@ -548,7 +752,7 @@ static int taskfile_load_raw(struct ata_device *dev,
  */
 static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
 {
-       struct ata_acpi_gtf *gtf = NULL;
+       struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
        int gtf_count, i, rc;
 
        /* get taskfiles */
@@ -558,22 +762,21 @@ static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
        gtf_count = rc;
 
        /* execute them */
-       for (i = 0, rc = 0; i < gtf_count; i++) {
-               int tmp;
-
-               /* ACPI errors are eventually ignored.  Run till the
-                * end even after errors.
-                */
-               tmp = taskfile_load_raw(dev, gtf++);
-               if (!rc)
-                       rc = tmp;
-
-               (*nr_executed)++;
+       for (i = 0; i < gtf_count; i++, gtf++) {
+               rc = ata_acpi_run_tf(dev, gtf, pgtf);
+               if (rc < 0)
+                       break;
+               if (rc) {
+                       (*nr_executed)++;
+                       pgtf = gtf;
+               }
        }
 
        ata_acpi_clear_gtf(dev);
 
-       return rc;
+       if (rc < 0)
+               return rc;
+       return 0;
 }
 
 /**
@@ -590,19 +793,18 @@ static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
  * EH context.
  *
  * RETURNS:
- * 0 on success, -errno on failure.
+ * 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure.
  */
 static int ata_acpi_push_id(struct ata_device *dev)
 {
        struct ata_port *ap = dev->link->ap;
-       int err;
        acpi_status status;
        struct acpi_object_list input;
        union acpi_object in_params[1];
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
-                              __FUNCTION__, dev->devno, ap->port_no);
+               ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n",
+                           __func__, dev->devno, ap->port_no);
 
        /* Give the drive Identify data to the drive via the _SDD method */
        /* _SDD: set up input parameters */
@@ -618,12 +820,15 @@ static int ata_acpi_push_id(struct ata_device *dev)
        status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
        swap_buf_le16(dev->id, ATA_ID_WORDS);
 
-       err = ACPI_FAILURE(status) ? -EIO : 0;
-       if (err < 0)
-               ata_dev_printk(dev, KERN_WARNING,
-                              "ACPI _SDD failed (AE 0x%x)\n", status);
+       if (status == AE_NOT_FOUND)
+               return -ENOENT;
 
-       return err;
+       if (ACPI_FAILURE(status)) {
+               ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
+               return -EIO;
+       }
+
+       return 0;
 }
 
 /**
@@ -672,9 +877,10 @@ void ata_acpi_on_resume(struct ata_port *ap)
                 * use values set by _STM.  Cache _GTF result and
                 * schedule _GTF.
                 */
-               ata_link_for_each_dev(dev, &ap->link) {
+               ata_for_each_dev(dev, &ap->link, ALL) {
                        ata_acpi_clear_gtf(dev);
-                       if (ata_dev_get_GTF(dev, NULL) >= 0)
+                       if (ata_dev_enabled(dev) &&
+                           ata_dev_get_GTF(dev, NULL) >= 0)
                                dev->flags |= ATA_DFLAG_ACPI_PENDING;
                }
        } else {
@@ -682,14 +888,45 @@ void ata_acpi_on_resume(struct ata_port *ap)
                 * there's no reason to evaluate IDE _GTF early
                 * without _STM.  Clear cache and schedule _GTF.
                 */
-               ata_link_for_each_dev(dev, &ap->link) {
+               ata_for_each_dev(dev, &ap->link, ALL) {
                        ata_acpi_clear_gtf(dev);
-                       dev->flags |= ATA_DFLAG_ACPI_PENDING;
+                       if (ata_dev_enabled(dev))
+                               dev->flags |= ATA_DFLAG_ACPI_PENDING;
                }
        }
 }
 
 /**
+ * ata_acpi_set_state - set the port power state
+ * @ap: target ATA port
+ * @state: state, on/off
+ *
+ * This function executes the _PS0/_PS3 ACPI method to set the power state.
+ * ACPI spec requires _PS0 when IDE power on and _PS3 when power off
+ */
+void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
+{
+       struct ata_device *dev;
+
+       if (!ap->acpi_handle || (ap->flags & ATA_FLAG_ACPI_SATA))
+               return;
+
+       /* channel first and then drives for power on and vica versa
+          for power off */
+       if (state.event == PM_EVENT_ON)
+               acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0);
+
+       ata_for_each_dev(dev, &ap->link, ENABLED) {
+               if (dev->acpi_handle)
+                       acpi_bus_set_power(dev->acpi_handle,
+                               state.event == PM_EVENT_ON ?
+                                       ACPI_STATE_D0 : ACPI_STATE_D3);
+       }
+       if (state.event != PM_EVENT_ON)
+               acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D3);
+}
+
+/**
  * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
  * @dev: target ATA device
  *
@@ -722,7 +959,7 @@ int ata_acpi_on_devcfg(struct ata_device *dev)
        /* do _SDD if SATA */
        if (acpi_sata) {
                rc = ata_acpi_push_id(dev);
-               if (rc)
+               if (rc && rc != -ENOENT)
                        goto acpi_err;
        }
 
@@ -737,8 +974,8 @@ int ata_acpi_on_devcfg(struct ata_device *dev)
        if (nr_executed) {
                rc = ata_dev_reread_id(dev, 0);
                if (rc < 0) {
-                       ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
-                                      "after ACPI commands\n");
+                       ata_dev_err(dev,
+                                   "failed to IDENTIFY after ACPI commands\n");
                        return rc;
                }
        }
@@ -756,8 +993,7 @@ int ata_acpi_on_devcfg(struct ata_device *dev)
                return rc;
        }
 
-       ata_dev_printk(dev, KERN_WARNING,
-                      "ACPI: failed the second time, disabled\n");
+       ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
        dev->acpi_handle = NULL;
 
        /* We can safely continue if no _GTF command has been executed