mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
- Device PM QoS support for latency tolerance constraints on systems with hardware interfaces allowing such constraints to be specified. That is necessary to prevent hardware-driven power management from becoming overly aggressive on some systems and to prevent power management features leading to excessive latencies from being used in some cases. - Consolidation of the handling of ACPI hotplug notifications for device objects. This causes all device hotplug notifications to go through the root notify handler (that was executed for all of them anyway before) that propagates them to individual subsystems, if necessary, by executing callbacks provided by those subsystems (those callbacks are associated with struct acpi_device objects during device enumeration). As a result, the code in question becomes both smaller in size and more straightforward and all of those changes should not affect users. - ACPICA update, including fixes related to the handling of _PRT in cases when it is broken and the addition of "Windows 2013" to the list of supported "features" for _OSI (which is necessary to support systems that work incorrectly or don't even boot without it). Changes from Bob Moore and Lv Zheng. - Consolidation of ACPI _OST handling from Jiang Liu. - ACPI battery and AC fixes allowing unusual system configurations to be handled by that code from Alexander Mezin. - New device IDs for the ACPI LPSS driver from Chiau Ee Chew. - ACPI fan and thermal optimizations related to system suspend and resume from Aaron Lu. - Cleanups related to ACPI video from Jean Delvare. - Assorted ACPI fixes and cleanups from Al Stone, Hanjun Guo, Lan Tianyu, Paul Bolle, Tomasz Nowicki. - Intel RAPL (Running Average Power Limits) driver cleanups from Jacob Pan. - intel_pstate fixes and cleanups from Dirk Brandewie. - cpufreq fixes related to system suspend/resume handling from Viresh Kumar. - cpufreq core fixes and cleanups from Viresh Kumar, Stratos Karafotis, Saravana Kannan, Rashika Kheria, Joe Perches. - cpufreq drivers updates from Viresh Kumar, Zhuoyu Zhang, Rob Herring. - cpuidle fixes related to the menu governor from Tuukka Tikkanen. - cpuidle fix related to coupled CPUs handling from Paul Burton. - Asynchronous execution of all device suspend and resume callbacks, except for ->prepare and ->complete, during system suspend and resume from Chuansheng Liu. - Delayed resuming of runtime-suspended devices during system suspend for the PCI bus type and ACPI PM domain. - New set of PM helper routines to allow device runtime PM callbacks to be used during system suspend and resume more easily from Ulf Hansson. - Assorted fixes and cleanups in the PM core from Geert Uytterhoeven, Prabhakar Lad, Philipp Zabel, Rashika Kheria, Sebastian Capella. - devfreq fix from Saravana Kannan. / -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.22 (GNU/Linux) iQIcBAABCAAGBQJTLgB1AAoJEILEb/54YlRxfs4P/35fIu9h8ClNWUPXqi3nlGIt yMyumKvF1VdsOKLbjTtFq6B3UOlhqDijYTCQd7Xt7X8ONTk/ND9ec2t/5xGkSdUI q46fa0qZXeqUn0Kt2t+kl6tgVQOkDj94aNlEh+7Ya3Uu6WYDDfmZtOBOFAMk6D8l ND4rHJpX+eUsRLBrcxaUxxdD8AW5guGcPKyeyzsXv1bY1BZnpLFrZ3PhuI5dn2CL L/zmk3A+wG6+ZlQxnwDdrKa3E6uhRSIDeF0vI4Byspa1wi5zXknJG2J7MoQ9JEE9 VQpBXlqach5wgXqJ8PAqAeaB6Ie26/F7PYG8r446zKw/5UUtdNUx+0dkjQ7Mz8Tu ajuVxfwrrPhZeQqmVBxlH5Gg7Ez2KBKEfDxTdRnzI7FoA7PE5XDcg3kO64bhj8LJ yugnV/ToU9wMztZnPC7CoGPwUgxMJvr9LwmxS4aeKcVUBES05eg0vS3lwdZMgqkV iO0QkWTmhZ952qZCqZxbh0JqaaX8Wgx2kpX2tf1G2GJqLMZco289bLh6njNT+8CH EzdQKYYyn6G6+Qg2M0f/6So3qU17x9XtE4ZBWQdGDpqYOGZhjZAOs/VnB1Ysw/K3 cDBzswlJd0CyyUps9B+qbf49OpbWVwl5kKeuHUuPxugEVryhpSp9AuG+tNil74Sj JuGTGR4fyFjDBX5cvAPm =ywR6 -----END PGP SIGNATURE----- Merge tag 'pm+acpi-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm Pull ACPI and power management updates from Rafael Wysocki: "The majority of this material spent some time in linux-next, some of it even several weeks. There are a few relatively fresh commits in it, but they are mostly fixes and simple cleanups. ACPI took the lead this time, both in terms of the number of commits and the number of modified lines of code, cpufreq follows and there are a few changes in the PM core and in cpuidle too. A new feature that already got some LWN.net's attention is the device PM QoS extension allowing latency tolerance requirements to be propagated from leaf devices to their ancestors with hardware interfaces for specifying latency tolerance. That should help systems with hardware-driven power management to avoid going too far with it in cases when there are latency tolerance constraints. There also are some significant changes in the ACPI core related to the way in which hotplug notifications are handled. They affect PCI hotplug (ACPIPHP) and the ACPI dock station code too. The bottom line is that all those notification now go through the root notify handler and are propagated to the interested subsystems by means of callbacks instead of having to install a notify handler for each device object that we can potentially get hotplug notifications for. In addition to that ACPICA will now advertise "Windows 2013" compatibility for _OSI, because some systems out there don't work correctly if that is not done (some of them don't even boot). On the system suspend side of things, all of the device suspend and resume callbacks, except for ->prepare() and ->complete(), are now going to be executed asynchronously as that turns out to speed up system suspend and resume on some platforms quite significantly and we have a few more optimizations in that area. Apart from that, there are some new device IDs and fixes and cleanups all over. In particular, the system suspend and resume handling by cpufreq should be improved and the cpuidle menu governor should be a bit more robust now. Specifics: - Device PM QoS support for latency tolerance constraints on systems with hardware interfaces allowing such constraints to be specified. That is necessary to prevent hardware-driven power management from becoming overly aggressive on some systems and to prevent power management features leading to excessive latencies from being used in some cases. - Consolidation of the handling of ACPI hotplug notifications for device objects. This causes all device hotplug notifications to go through the root notify handler (that was executed for all of them anyway before) that propagates them to individual subsystems, if necessary, by executing callbacks provided by those subsystems (those callbacks are associated with struct acpi_device objects during device enumeration). As a result, the code in question becomes both smaller in size and more straightforward and all of those changes should not affect users. - ACPICA update, including fixes related to the handling of _PRT in cases when it is broken and the addition of "Windows 2013" to the list of supported "features" for _OSI (which is necessary to support systems that work incorrectly or don't even boot without it). Changes from Bob Moore and Lv Zheng. - Consolidation of ACPI _OST handling from Jiang Liu. - ACPI battery and AC fixes allowing unusual system configurations to be handled by that code from Alexander Mezin. - New device IDs for the ACPI LPSS driver from Chiau Ee Chew. - ACPI fan and thermal optimizations related to system suspend and resume from Aaron Lu. - Cleanups related to ACPI video from Jean Delvare. - Assorted ACPI fixes and cleanups from Al Stone, Hanjun Guo, Lan Tianyu, Paul Bolle, Tomasz Nowicki. - Intel RAPL (Running Average Power Limits) driver cleanups from Jacob Pan. - intel_pstate fixes and cleanups from Dirk Brandewie. - cpufreq fixes related to system suspend/resume handling from Viresh Kumar. - cpufreq core fixes and cleanups from Viresh Kumar, Stratos Karafotis, Saravana Kannan, Rashika Kheria, Joe Perches. - cpufreq drivers updates from Viresh Kumar, Zhuoyu Zhang, Rob Herring. - cpuidle fixes related to the menu governor from Tuukka Tikkanen. - cpuidle fix related to coupled CPUs handling from Paul Burton. - Asynchronous execution of all device suspend and resume callbacks, except for ->prepare and ->complete, during system suspend and resume from Chuansheng Liu. - Delayed resuming of runtime-suspended devices during system suspend for the PCI bus type and ACPI PM domain. - New set of PM helper routines to allow device runtime PM callbacks to be used during system suspend and resume more easily from Ulf Hansson. - Assorted fixes and cleanups in the PM core from Geert Uytterhoeven, Prabhakar Lad, Philipp Zabel, Rashika Kheria, Sebastian Capella. - devfreq fix from Saravana Kannan" * tag 'pm+acpi-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (162 commits) PM / devfreq: Rewrite devfreq_update_status() to fix multiple bugs PM / sleep: Correct whitespace errors in <linux/pm.h> intel_pstate: Set core to min P state during core offline cpufreq: Add stop CPU callback to cpufreq_driver interface cpufreq: Remove unnecessary braces cpufreq: Fix checkpatch errors and warnings cpufreq: powerpc: add cpufreq transition latency for FSL e500mc SoCs MAINTAINERS: Reorder maintainer addresses for PM and ACPI PM / Runtime: Update runtime_idle() documentation for return value meaning video / output: Drop display output class support fujitsu-laptop: Drop unneeded include acer-wmi: Stop selecting VIDEO_OUTPUT_CONTROL ACPI / gpu / drm: Stop selecting VIDEO_OUTPUT_CONTROL ACPI / video: fix ACPI_VIDEO dependencies cpufreq: remove unused notifier: CPUFREQ_{SUSPENDCHANGE|RESUMECHANGE} cpufreq: Do not allow ->setpolicy drivers to provide ->target cpufreq: arm_big_little: set 'physical_cluster' for each CPU cpufreq: arm_big_little: make vexpress driver depend on bL core driver ACPI / button: Add ACPI Button event via netlink routine ACPI: Remove duplicate definitions of PREFIX ...
1054 lines
26 KiB
C
1054 lines
26 KiB
C
/*
|
|
* libata-acpi.c
|
|
* Provides ACPI support for PATA/SATA.
|
|
*
|
|
* Copyright (C) 2006 Intel Corp.
|
|
* Copyright (C) 2006 Randy Dunlap
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/ata.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/device.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/libata.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <scsi/scsi_device.h>
|
|
#include "libata.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))
|
|
|
|
#define REGS_PER_GTF 7
|
|
struct ata_acpi_gtf {
|
|
u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */
|
|
} __packed;
|
|
|
|
static void ata_acpi_clear_gtf(struct ata_device *dev)
|
|
{
|
|
kfree(dev->gtf_cache);
|
|
dev->gtf_cache = NULL;
|
|
}
|
|
|
|
struct ata_acpi_hotplug_context {
|
|
struct acpi_hotplug_context hp;
|
|
union {
|
|
struct ata_port *ap;
|
|
struct ata_device *dev;
|
|
} data;
|
|
};
|
|
|
|
#define ata_hotplug_data(context) (container_of((context), struct ata_acpi_hotplug_context, hp)->data)
|
|
|
|
/**
|
|
* ata_dev_acpi_handle - provide the acpi_handle for an ata_device
|
|
* @dev: the acpi_handle returned will correspond to this device
|
|
*
|
|
* Returns the acpi_handle for the ACPI namespace object corresponding to
|
|
* the ata_device passed into the function, or NULL if no such object exists
|
|
* or ACPI is disabled for this device due to consecutive errors.
|
|
*/
|
|
acpi_handle ata_dev_acpi_handle(struct ata_device *dev)
|
|
{
|
|
return dev->flags & ATA_DFLAG_ACPI_DISABLED ?
|
|
NULL : ACPI_HANDLE(&dev->tdev);
|
|
}
|
|
|
|
/* @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)
|
|
{
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
|
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;
|
|
}
|
|
|
|
spin_unlock_irqrestore(ap->lock, flags);
|
|
|
|
if (wait)
|
|
ata_port_wait_eh(ap);
|
|
}
|
|
|
|
static int ata_acpi_dev_notify_dock(struct acpi_device *adev, u32 event)
|
|
{
|
|
struct ata_device *dev = ata_hotplug_data(adev->hp).dev;
|
|
ata_acpi_handle_hotplug(dev->link->ap, dev, event);
|
|
return 0;
|
|
}
|
|
|
|
static int ata_acpi_ap_notify_dock(struct acpi_device *adev, u32 event)
|
|
{
|
|
ata_acpi_handle_hotplug(ata_hotplug_data(adev->hp).ap, NULL, event);
|
|
return 0;
|
|
}
|
|
|
|
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) {
|
|
if (dev->sdev)
|
|
kobj = &dev->sdev->sdev_gendev.kobj;
|
|
} else
|
|
kobj = &ap->dev->kobj;
|
|
|
|
if (kobj) {
|
|
snprintf(event_string, 20, "BAY_EVENT=%d", event);
|
|
kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
|
|
}
|
|
}
|
|
|
|
static void ata_acpi_ap_uevent(struct acpi_device *adev, u32 event)
|
|
{
|
|
ata_acpi_uevent(ata_hotplug_data(adev->hp).ap, NULL, event);
|
|
}
|
|
|
|
static void ata_acpi_dev_uevent(struct acpi_device *adev, u32 event)
|
|
{
|
|
struct ata_device *dev = ata_hotplug_data(adev->hp).dev;
|
|
ata_acpi_uevent(dev->link->ap, dev, event);
|
|
}
|
|
|
|
/* bind acpi handle to pata port */
|
|
void ata_acpi_bind_port(struct ata_port *ap)
|
|
{
|
|
struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
|
|
struct acpi_device *adev;
|
|
struct ata_acpi_hotplug_context *context;
|
|
|
|
if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA || !host_companion)
|
|
return;
|
|
|
|
acpi_preset_companion(&ap->tdev, host_companion, ap->port_no);
|
|
|
|
if (ata_acpi_gtm(ap, &ap->__acpi_init_gtm) == 0)
|
|
ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
|
|
|
|
adev = ACPI_COMPANION(&ap->tdev);
|
|
if (!adev || adev->hp)
|
|
return;
|
|
|
|
context = kzalloc(sizeof(*context), GFP_KERNEL);
|
|
if (!context)
|
|
return;
|
|
|
|
context->data.ap = ap;
|
|
acpi_initialize_hp_context(adev, &context->hp, ata_acpi_ap_notify_dock,
|
|
ata_acpi_ap_uevent);
|
|
}
|
|
|
|
void ata_acpi_bind_dev(struct ata_device *dev)
|
|
{
|
|
struct ata_port *ap = dev->link->ap;
|
|
struct acpi_device *port_companion = ACPI_COMPANION(&ap->tdev);
|
|
struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
|
|
struct acpi_device *parent, *adev;
|
|
struct ata_acpi_hotplug_context *context;
|
|
u64 adr;
|
|
|
|
/*
|
|
* For both sata/pata devices, host companion device is required.
|
|
* For pata device, port companion device is also required.
|
|
*/
|
|
if (libata_noacpi || !host_companion ||
|
|
(!(ap->flags & ATA_FLAG_ACPI_SATA) && !port_companion))
|
|
return;
|
|
|
|
if (ap->flags & ATA_FLAG_ACPI_SATA) {
|
|
if (!sata_pmp_attached(ap))
|
|
adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
|
|
else
|
|
adr = SATA_ADR(ap->port_no, dev->link->pmp);
|
|
parent = host_companion;
|
|
} else {
|
|
adr = dev->devno;
|
|
parent = port_companion;
|
|
}
|
|
|
|
acpi_preset_companion(&dev->tdev, parent, adr);
|
|
adev = ACPI_COMPANION(&dev->tdev);
|
|
if (!adev || adev->hp)
|
|
return;
|
|
|
|
context = kzalloc(sizeof(*context), GFP_KERNEL);
|
|
if (!context)
|
|
return;
|
|
|
|
context->data.dev = dev;
|
|
acpi_initialize_hp_context(adev, &context->hp, ata_acpi_dev_notify_dock,
|
|
ata_acpi_dev_uevent);
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_dissociate - dissociate ATA host from ACPI objects
|
|
* @host: target ATA host
|
|
*
|
|
* This function is called during driver detach after the whole host
|
|
* is shut down.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*/
|
|
void ata_acpi_dissociate(struct ata_host *host)
|
|
{
|
|
int i;
|
|
|
|
/* Restore initial _GTM values so that driver which attaches
|
|
* afterward can use them too.
|
|
*/
|
|
for (i = 0; i < host->n_ports; i++) {
|
|
struct ata_port *ap = host->ports[i];
|
|
const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
|
|
|
|
if (ACPI_HANDLE(&ap->tdev) && gtm)
|
|
ata_acpi_stm(ap, gtm);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_gtm - execute _GTM
|
|
* @ap: target ATA port
|
|
* @gtm: out parameter for _GTM result
|
|
*
|
|
* Evaluate _GTM and store the result in @gtm.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
|
|
*/
|
|
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *gtm)
|
|
{
|
|
struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
|
|
union acpi_object *out_obj;
|
|
acpi_status status;
|
|
int rc = 0;
|
|
acpi_handle handle = ACPI_HANDLE(&ap->tdev);
|
|
|
|
if (!handle)
|
|
return -EINVAL;
|
|
|
|
status = acpi_evaluate_object(handle, "_GTM", NULL, &output);
|
|
|
|
rc = -ENOENT;
|
|
if (status == AE_NOT_FOUND)
|
|
goto out_free;
|
|
|
|
rc = -EINVAL;
|
|
if (ACPI_FAILURE(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_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_err(ap, "_GTM returned invalid length %d\n",
|
|
out_obj->buffer.length);
|
|
goto out_free;
|
|
}
|
|
|
|
memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
|
|
rc = 0;
|
|
out_free:
|
|
kfree(output.pointer);
|
|
return rc;
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_gtm);
|
|
|
|
/**
|
|
* ata_acpi_stm - execute _STM
|
|
* @ap: target ATA port
|
|
* @stm: timing parameter to _STM
|
|
*
|
|
* Evaluate _STM with timing parameter @stm.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
|
|
*/
|
|
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
|
|
{
|
|
acpi_status status;
|
|
struct ata_acpi_gtm stm_buf = *stm;
|
|
struct acpi_object_list input;
|
|
union acpi_object in_params[3];
|
|
|
|
in_params[0].type = ACPI_TYPE_BUFFER;
|
|
in_params[0].buffer.length = sizeof(struct ata_acpi_gtm);
|
|
in_params[0].buffer.pointer = (u8 *)&stm_buf;
|
|
/* Buffers for id may need byteswapping ? */
|
|
in_params[1].type = ACPI_TYPE_BUFFER;
|
|
in_params[1].buffer.length = 512;
|
|
in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
|
|
in_params[2].type = ACPI_TYPE_BUFFER;
|
|
in_params[2].buffer.length = 512;
|
|
in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
|
|
|
|
input.count = 3;
|
|
input.pointer = in_params;
|
|
|
|
status = acpi_evaluate_object(ACPI_HANDLE(&ap->tdev), "_STM",
|
|
&input, NULL);
|
|
|
|
if (status == AE_NOT_FOUND)
|
|
return -ENOENT;
|
|
if (ACPI_FAILURE(status)) {
|
|
ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
|
|
status);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_stm);
|
|
|
|
/**
|
|
* ata_dev_get_GTF - get the drive bootup default taskfile settings
|
|
* @dev: target ATA device
|
|
* @gtf: output parameter for buffer containing _GTF taskfile arrays
|
|
*
|
|
* This applies to both PATA and SATA drives.
|
|
*
|
|
* The _GTF method has no input parameters.
|
|
* It returns a variable number of register set values (registers
|
|
* hex 1F1..1F7, taskfiles).
|
|
* The <variable number> is not known in advance, so have ACPI-CA
|
|
* allocate the buffer as needed and return it, then free it later.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL
|
|
* if _GTF is invalid.
|
|
*/
|
|
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
|
|
{
|
|
struct ata_port *ap = dev->link->ap;
|
|
acpi_status status;
|
|
struct acpi_buffer output;
|
|
union acpi_object *out_obj;
|
|
int rc = 0;
|
|
|
|
/* if _GTF is cached, use the cached value */
|
|
if (dev->gtf_cache) {
|
|
out_obj = dev->gtf_cache;
|
|
goto done;
|
|
}
|
|
|
|
/* set up output buffer */
|
|
output.length = ACPI_ALLOCATE_BUFFER;
|
|
output.pointer = NULL; /* ACPI-CA sets this; save/free it later */
|
|
|
|
if (ata_msg_probe(ap))
|
|
ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
|
|
__func__, ap->port_no);
|
|
|
|
/* _GTF has no input parameters */
|
|
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL,
|
|
&output);
|
|
out_obj = dev->gtf_cache = output.pointer;
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
if (status != AE_NOT_FOUND) {
|
|
ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
|
|
status);
|
|
rc = -EINVAL;
|
|
}
|
|
goto out_free;
|
|
}
|
|
|
|
if (!output.length || !output.pointer) {
|
|
if (ata_msg_probe(ap))
|
|
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_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_warn(dev, "unexpected _GTF length (%d)\n",
|
|
out_obj->buffer.length);
|
|
rc = -EINVAL;
|
|
goto out_free;
|
|
}
|
|
|
|
done:
|
|
rc = out_obj->buffer.length / REGS_PER_GTF;
|
|
if (gtf) {
|
|
*gtf = (void *)out_obj->buffer.pointer;
|
|
if (ata_msg_probe(ap))
|
|
ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
|
|
__func__, *gtf, rc);
|
|
}
|
|
return rc;
|
|
|
|
out_free:
|
|
ata_acpi_clear_gtf(dev);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* 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 @gtm indicates the BIOS selected an 80wire mode.
|
|
*/
|
|
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
|
|
{
|
|
struct ata_device *dev;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* 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.
|
|
*
|
|
* This function waits for idle (!BUSY and !DRQ) after writing
|
|
* registers. If the control register has a new value, this
|
|
* function also waits for idle after writing control and before
|
|
* writing the remaining registers.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* 1 if command is executed successfully. 0 if ignored, rejected or
|
|
* filtered out, -errno on other errors.
|
|
*/
|
|
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_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_acpi_gtf_to_tf(dev, gtf, &tf);
|
|
if (prev_gtf) {
|
|
ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
|
|
pptf = &ptf;
|
|
}
|
|
|
|
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);
|
|
|
|
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 parameter for the number of executed commands
|
|
*
|
|
* Evaluate _GTF and execute returned taskfiles.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* Number of executed taskfiles on success, 0 if _GTF doesn't exist.
|
|
* -errno on other errors.
|
|
*/
|
|
static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
|
|
{
|
|
struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
|
|
int gtf_count, i, rc;
|
|
|
|
/* get taskfiles */
|
|
rc = ata_dev_get_GTF(dev, >f);
|
|
if (rc < 0)
|
|
return rc;
|
|
gtf_count = rc;
|
|
|
|
/* execute them */
|
|
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);
|
|
|
|
if (rc < 0)
|
|
return rc;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_push_id - send Identify data to drive
|
|
* @dev: target ATA device
|
|
*
|
|
* _SDD ACPI object: for SATA mode only
|
|
* Must be after Identify (Packet) Device -- uses its data
|
|
* ATM this function never returns a failure. It is an optional
|
|
* method and if it fails for whatever reason, we should still
|
|
* just keep going.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* 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;
|
|
acpi_status status;
|
|
struct acpi_object_list input;
|
|
union acpi_object in_params[1];
|
|
|
|
if (ata_msg_probe(ap))
|
|
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 */
|
|
input.count = 1;
|
|
input.pointer = in_params;
|
|
in_params[0].type = ACPI_TYPE_BUFFER;
|
|
in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
|
|
in_params[0].buffer.pointer = (u8 *)dev->id;
|
|
/* Output buffer: _SDD has no output */
|
|
|
|
/* It's OK for _SDD to be missing too. */
|
|
swap_buf_le16(dev->id, ATA_ID_WORDS);
|
|
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input,
|
|
NULL);
|
|
swap_buf_le16(dev->id, ATA_ID_WORDS);
|
|
|
|
if (status == AE_NOT_FOUND)
|
|
return -ENOENT;
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
|
|
return -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_on_suspend - ATA ACPI hook called on suspend
|
|
* @ap: target ATA port
|
|
*
|
|
* This function is called when @ap is about to be suspended. All
|
|
* devices are already put to sleep but the port_suspend() callback
|
|
* hasn't been executed yet. Error return from this function aborts
|
|
* suspend.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* 0 on success, -errno on failure.
|
|
*/
|
|
int ata_acpi_on_suspend(struct ata_port *ap)
|
|
{
|
|
/* nada */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_on_resume - ATA ACPI hook called on resume
|
|
* @ap: target ATA port
|
|
*
|
|
* This function is called when @ap is resumed - right after port
|
|
* itself is resumed but before any EH action is taken.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*/
|
|
void ata_acpi_on_resume(struct ata_port *ap)
|
|
{
|
|
const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
|
|
struct ata_device *dev;
|
|
|
|
if (ACPI_HANDLE(&ap->tdev) && gtm) {
|
|
/* _GTM valid */
|
|
|
|
/* restore timing parameters */
|
|
ata_acpi_stm(ap, gtm);
|
|
|
|
/* _GTF should immediately follow _STM so that it can
|
|
* use values set by _STM. Cache _GTF result and
|
|
* schedule _GTF.
|
|
*/
|
|
ata_for_each_dev(dev, &ap->link, ALL) {
|
|
ata_acpi_clear_gtf(dev);
|
|
if (ata_dev_enabled(dev) &&
|
|
ata_dev_acpi_handle(dev) &&
|
|
ata_dev_get_GTF(dev, NULL) >= 0)
|
|
dev->flags |= ATA_DFLAG_ACPI_PENDING;
|
|
}
|
|
} else {
|
|
/* SATA _GTF needs to be evaulated after _SDD and
|
|
* there's no reason to evaluate IDE _GTF early
|
|
* without _STM. Clear cache and schedule _GTF.
|
|
*/
|
|
ata_for_each_dev(dev, &ap->link, ALL) {
|
|
ata_acpi_clear_gtf(dev);
|
|
if (ata_dev_enabled(dev))
|
|
dev->flags |= ATA_DFLAG_ACPI_PENDING;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime)
|
|
{
|
|
int d_max_in = ACPI_STATE_D3_COLD;
|
|
if (!runtime)
|
|
goto out;
|
|
|
|
/*
|
|
* For ATAPI, runtime D3 cold is only allowed
|
|
* for ZPODD in zero power ready state
|
|
*/
|
|
if (dev->class == ATA_DEV_ATAPI &&
|
|
!(zpodd_dev_enabled(dev) && zpodd_zpready(dev)))
|
|
d_max_in = ACPI_STATE_D3_HOT;
|
|
|
|
out:
|
|
return acpi_pm_device_sleep_state(&dev->tdev, NULL, d_max_in);
|
|
}
|
|
|
|
static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state)
|
|
{
|
|
bool runtime = PMSG_IS_AUTO(state);
|
|
struct ata_device *dev;
|
|
acpi_handle handle;
|
|
int acpi_state;
|
|
|
|
ata_for_each_dev(dev, &ap->link, ENABLED) {
|
|
handle = ata_dev_acpi_handle(dev);
|
|
if (!handle)
|
|
continue;
|
|
|
|
if (!(state.event & PM_EVENT_RESUME)) {
|
|
acpi_state = ata_acpi_choose_suspend_state(dev, runtime);
|
|
if (acpi_state == ACPI_STATE_D0)
|
|
continue;
|
|
if (runtime && zpodd_dev_enabled(dev) &&
|
|
acpi_state == ACPI_STATE_D3_COLD)
|
|
zpodd_enable_run_wake(dev);
|
|
acpi_bus_set_power(handle, acpi_state);
|
|
} else {
|
|
if (runtime && zpodd_dev_enabled(dev))
|
|
zpodd_disable_run_wake(dev);
|
|
acpi_bus_set_power(handle, ACPI_STATE_D0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ACPI spec requires _PS0 when IDE power on and _PS3 when power off */
|
|
static void pata_acpi_set_state(struct ata_port *ap, pm_message_t state)
|
|
{
|
|
struct ata_device *dev;
|
|
acpi_handle port_handle;
|
|
|
|
port_handle = ACPI_HANDLE(&ap->tdev);
|
|
if (!port_handle)
|
|
return;
|
|
|
|
/* channel first and then drives for power on and vica versa
|
|
for power off */
|
|
if (state.event & PM_EVENT_RESUME)
|
|
acpi_bus_set_power(port_handle, ACPI_STATE_D0);
|
|
|
|
ata_for_each_dev(dev, &ap->link, ENABLED) {
|
|
acpi_handle dev_handle = ata_dev_acpi_handle(dev);
|
|
if (!dev_handle)
|
|
continue;
|
|
|
|
acpi_bus_set_power(dev_handle, state.event & PM_EVENT_RESUME ?
|
|
ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
|
|
}
|
|
|
|
if (!(state.event & PM_EVENT_RESUME))
|
|
acpi_bus_set_power(port_handle, ACPI_STATE_D3_COLD);
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_set_state - set the port power state
|
|
* @ap: target ATA port
|
|
* @state: state, on/off
|
|
*
|
|
* This function sets a proper ACPI D state for the device on
|
|
* system and runtime PM operations.
|
|
*/
|
|
void ata_acpi_set_state(struct ata_port *ap, pm_message_t state)
|
|
{
|
|
if (ap->flags & ATA_FLAG_ACPI_SATA)
|
|
sata_acpi_set_state(ap, state);
|
|
else
|
|
pata_acpi_set_state(ap, state);
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
|
|
* @dev: target ATA device
|
|
*
|
|
* This function is called when @dev is about to be configured.
|
|
* IDENTIFY data might have been modified after this hook is run.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*
|
|
* RETURNS:
|
|
* Positive number if IDENTIFY data needs to be refreshed, 0 if not,
|
|
* -errno on failure.
|
|
*/
|
|
int ata_acpi_on_devcfg(struct ata_device *dev)
|
|
{
|
|
struct ata_port *ap = dev->link->ap;
|
|
struct ata_eh_context *ehc = &ap->link.eh_context;
|
|
int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
|
|
int nr_executed = 0;
|
|
int rc;
|
|
|
|
if (!ata_dev_acpi_handle(dev))
|
|
return 0;
|
|
|
|
/* do we need to do _GTF? */
|
|
if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
|
|
!(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
|
|
return 0;
|
|
|
|
/* do _SDD if SATA */
|
|
if (acpi_sata) {
|
|
rc = ata_acpi_push_id(dev);
|
|
if (rc && rc != -ENOENT)
|
|
goto acpi_err;
|
|
}
|
|
|
|
/* do _GTF */
|
|
rc = ata_acpi_exec_tfs(dev, &nr_executed);
|
|
if (rc)
|
|
goto acpi_err;
|
|
|
|
dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
|
|
|
|
/* refresh IDENTIFY page if any _GTF command has been executed */
|
|
if (nr_executed) {
|
|
rc = ata_dev_reread_id(dev, 0);
|
|
if (rc < 0) {
|
|
ata_dev_err(dev,
|
|
"failed to IDENTIFY after ACPI commands\n");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
acpi_err:
|
|
/* ignore evaluation failure if we can continue safely */
|
|
if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
|
|
return 0;
|
|
|
|
/* fail and let EH retry once more for unknown IO errors */
|
|
if (!(dev->flags & ATA_DFLAG_ACPI_FAILED)) {
|
|
dev->flags |= ATA_DFLAG_ACPI_FAILED;
|
|
return rc;
|
|
}
|
|
|
|
dev->flags |= ATA_DFLAG_ACPI_DISABLED;
|
|
ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
|
|
|
|
/* We can safely continue if no _GTF command has been executed
|
|
* and port is not frozen.
|
|
*/
|
|
if (!nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
|
|
return 0;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ata_acpi_on_disable - ATA ACPI hook called when a device is disabled
|
|
* @dev: target ATA device
|
|
*
|
|
* This function is called when @dev is about to be disabled.
|
|
*
|
|
* LOCKING:
|
|
* EH context.
|
|
*/
|
|
void ata_acpi_on_disable(struct ata_device *dev)
|
|
{
|
|
ata_acpi_clear_gtf(dev);
|
|
}
|