config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / ata / libata-acpi.c
index 9f0b208..bb7c5f1 100644 (file)
 #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>
-
-enum {
-       ATA_ACPI_FILTER_SETXFER = 1 << 0,
-       ATA_ACPI_FILTER_LOCK    = 1 << 1,
-
-       ATA_ACPI_FILTER_DEFAULT = ATA_ACPI_FILTER_SETXFER |
-                                 ATA_ACPI_FILTER_LOCK,
-};
 
-static unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
+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)");
+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))
@@ -77,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);
@@ -87,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);
@@ -118,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
@@ -191,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);
+                       }
                }
        }
 }
@@ -263,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;
        }
 
@@ -333,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;
@@ -381,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);
@@ -390,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;
@@ -400,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;
        }
@@ -430,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;
 
@@ -441,22 +502,6 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
        return rc;
 }
 
-/* Welcome to ACPI, bring a bucket */
-const unsigned int ata_acpi_pio_cycle[7] = {
-       600, 383, 240, 180, 120, 100, 80
-};
-EXPORT_SYMBOL_GPL(ata_acpi_pio_cycle);
-
-const unsigned int ata_acpi_mwdma_cycle[5] = {
-       480, 150, 120, 100, 80
-};
-EXPORT_SYMBOL_GPL(ata_acpi_mwdma_cycle);
-
-const unsigned int ata_acpi_udma_cycle[7] = {
-       120, 80, 60, 45, 30, 20, 15
-};
-EXPORT_SYMBOL_GPL(ata_acpi_udma_cycle);
-
 /**
  * ata_acpi_gtm_xfermode - determine xfermode from GTM parameter
  * @dev: target device
@@ -473,87 +518,59 @@ EXPORT_SYMBOL_GPL(ata_acpi_udma_cycle);
 unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
                                    const struct ata_acpi_gtm *gtm)
 {
-       unsigned long pio_mask = 0, mwdma_mask = 0, udma_mask = 0;
-       int unit, i;
-       u32 t;
+       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;
 
-       /* Values larger than the longest cycle results in 0 mask
-        * while values equal to smaller than the shortest cycle
-        * results in mask which includes all supported modes.
-        * Disabled transfer method has the value of 0xffffffff which
-        * will always result in 0 mask.
-        */
-
-       /* start by scanning for PIO modes */
-       t = gtm->drive[unit].pio;
-       for (i = 0; i < ARRAY_SIZE(ata_acpi_pio_cycle); i++)
-               if (t > ata_acpi_pio_cycle[i])
-                       break;
-       pio_mask = (1 << i) - 1;
+       /* 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.
         */
-       t = gtm->drive[unit].dma;
-       if (!(gtm->flags & (1 << (2 * unit)))) {
-               /* MWDMA */
-               for (i = 0; i < ARRAY_SIZE(ata_acpi_mwdma_cycle); i++)
-                       if (t > ata_acpi_mwdma_cycle[i])
-                               break;
-               mwdma_mask = (1 << i) - 1;
-       } else {
-               /* UDMA */
-               for (i = 0; i < ARRAY_SIZE(ata_acpi_udma_cycle); i++)
-                       if (t > ata_acpi_udma_cycle[i])
-                               break;
-               udma_mask = (1 << i) - 1;
-       }
+       if (!(gtm->flags & (1 << (2 * unit))))
+               type = ATA_SHIFT_MWDMA;
+       else
+               type = ATA_SHIFT_UDMA;
 
-       return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
+       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,
@@ -573,10 +590,11 @@ static void ata_acpi_gtf_to_tf(struct ata_device *dev,
        tf->command = gtf->tf[6];       /* 0x1f7 */
 }
 
-static int ata_acpi_filter_tf(const struct ata_taskfile *tf,
+static int ata_acpi_filter_tf(struct ata_device *dev,
+                             const struct ata_taskfile *tf,
                              const struct ata_taskfile *ptf)
 {
-       if (ata_acpi_gtf_filter & ATA_ACPI_FILTER_SETXFER) {
+       if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
                /* libata doesn't use ACPI to configure transfer mode.
                 * It will only confuse device configuration.  Skip.
                 */
@@ -585,7 +603,7 @@ static int ata_acpi_filter_tf(const struct ata_taskfile *tf,
                        return 1;
        }
 
-       if (ata_acpi_gtf_filter & ATA_ACPI_FILTER_LOCK) {
+       if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
                /* BIOS writers, sorry but we don't wanna lock
                 * features unless the user explicitly said so.
                 */
@@ -607,6 +625,25 @@ static int ata_acpi_filter_tf(const struct ata_taskfile *tf,
                        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;
 }
 
@@ -615,8 +652,7 @@ static int ata_acpi_filter_tf(const struct ata_taskfile *tf,
  * @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.
@@ -641,6 +677,7 @@ static int ata_acpi_run_tf(struct ata_device *dev,
        struct ata_taskfile tf, ptf, rtf;
        unsigned int err_mask;
        const char *level;
+       const char *descr;
        char msg[60];
        int rc;
 
@@ -655,7 +692,7 @@ static int ata_acpi_run_tf(struct ata_device *dev,
                pptf = &ptf;
        }
 
-       if (!ata_acpi_filter_tf(&tf, pptf)) {
+       if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
                rtf = tf;
                err_mask = ata_exec_internal(dev, &rtf, NULL,
                                             DMA_NONE, NULL, 0, 0);
@@ -688,11 +725,13 @@ static int ata_acpi_run_tf(struct ata_device *dev,
                snprintf(msg, sizeof(msg), "filtered out");
                rc = 0;
        }
+       descr = ata_get_cmd_descript(tf.command);
 
        ata_dev_printk(dev, level,
-                      "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x %s\n",
+                      "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, msg);
+                      tf.lbam, tf.lbah, tf.device,
+                      (descr ? descr : "unknown"), msg);
 
        return rc;
 }
@@ -700,9 +739,9 @@ static int ata_acpi_run_tf(struct ata_device *dev,
 /**
  * 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.
@@ -754,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 */
@@ -782,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;
 }
 
 /**
@@ -836,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 {
@@ -846,9 +888,10 @@ 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;
                }
        }
 }
@@ -873,8 +916,8 @@ void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
        if (state.event == PM_EVENT_ON)
                acpi_bus_set_power(ap->acpi_handle, ACPI_STATE_D0);
 
-       ata_link_for_each_dev(dev, &ap->link) {
-               if (dev->acpi_handle && ata_dev_enabled(dev))
+       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);
@@ -916,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;
        }
 
@@ -931,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;
                }
        }
@@ -950,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