2006-09-29 01:29:01 +07:00
|
|
|
/*
|
|
|
|
* libata-acpi.c
|
|
|
|
* Provides ACPI support for PATA/SATA.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Intel Corp.
|
|
|
|
* Copyright (C) 2006 Randy Dunlap
|
|
|
|
*/
|
|
|
|
|
2007-12-15 13:05:06 +07:00
|
|
|
#include <linux/module.h>
|
2006-09-29 01:29:01 +07:00
|
|
|
#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 cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2012-06-25 15:13:06 +07:00
|
|
|
#include <linux/pm_runtime.h>
|
2007-10-03 07:24:16 +07:00
|
|
|
#include <scsi/scsi_device.h>
|
2006-09-29 01:29:01 +07:00
|
|
|
#include "libata.h"
|
|
|
|
|
2009-09-16 02:17:28 +07:00
|
|
|
unsigned int ata_acpi_gtf_filter = ATA_ACPI_FILTER_DEFAULT;
|
2007-12-15 13:05:06 +07:00
|
|
|
module_param_named(acpi_gtf_filter, ata_acpi_gtf_filter, int, 0644);
|
2009-09-16 02:17:02 +07:00
|
|
|
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)");
|
2007-12-15 13:05:06 +07:00
|
|
|
|
2006-09-29 01:29:01 +07:00
|
|
|
#define NO_PORT_MULT 0xffff
|
2007-10-19 17:42:56 +07:00
|
|
|
#define SATA_ADR(root, pmp) (((root) << 16) | (pmp))
|
2006-09-29 01:29:01 +07:00
|
|
|
|
|
|
|
#define REGS_PER_GTF 7
|
2007-05-15 01:28:16 +07:00
|
|
|
struct ata_acpi_gtf {
|
|
|
|
u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */
|
|
|
|
} __packed;
|
2006-09-29 01:29:01 +07:00
|
|
|
|
2007-12-15 13:05:03 +07:00
|
|
|
static void ata_acpi_clear_gtf(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
kfree(dev->gtf_cache);
|
|
|
|
dev->gtf_cache = NULL;
|
|
|
|
}
|
|
|
|
|
2012-06-25 15:13:04 +07:00
|
|
|
/**
|
|
|
|
* ata_dev_acpi_handle - provide the acpi_handle for an ata_device
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
* @dev: the acpi_handle returned will correspond to this device
|
2012-06-25 15:13:04 +07:00
|
|
|
*
|
|
|
|
* 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
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
* or ACPI is disabled for this device due to consecutive errors.
|
2012-06-25 15:13:04 +07:00
|
|
|
*/
|
|
|
|
acpi_handle ata_dev_acpi_handle(struct ata_device *dev)
|
2012-06-25 15:13:03 +07:00
|
|
|
{
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
return dev->flags & ATA_DFLAG_ACPI_DISABLED ?
|
|
|
|
NULL : ACPI_HANDLE(&dev->tdev);
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
/* @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;
|
|
|
|
|
2008-11-03 18:03:17 +07:00
|
|
|
ata_for_each_link(tlink, ap, EDGE)
|
|
|
|
ata_for_each_dev(tdev, tlink, ALL)
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
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,
|
2008-08-28 09:05:45 +07:00
|
|
|
u32 event)
|
2007-10-03 07:24:16 +07:00
|
|
|
{
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
2008-03-12 12:24:43 +07:00
|
|
|
int wait = 0;
|
|
|
|
unsigned long flags;
|
2008-07-11 20:42:03 +07:00
|
|
|
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
spin_lock_irqsave(ap->lock, flags);
|
2008-08-28 09:05:45 +07:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2008-03-12 12:24:43 +07:00
|
|
|
switch (event) {
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
|
|
|
ata_ehi_push_desc(ehi, "ACPI event");
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
|
2008-08-28 09:05:45 +07:00
|
|
|
ata_ehi_hotplugged(ehi);
|
|
|
|
ata_port_freeze(ap);
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
break;
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
|
|
|
ata_ehi_push_desc(ehi, "ACPI event");
|
|
|
|
|
|
|
|
ata_acpi_detach_device(ap, dev);
|
|
|
|
wait = 1;
|
|
|
|
break;
|
2007-10-03 07:24:16 +07:00
|
|
|
}
|
|
|
|
|
2008-05-19 23:29:34 +07:00
|
|
|
spin_unlock_irqrestore(ap->lock, flags);
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
if (wait)
|
2008-05-19 23:29:34 +07:00
|
|
|
ata_port_wait_eh(ap);
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ata_acpi_dev_notify_dock(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
struct ata_device *dev = data;
|
|
|
|
|
2008-08-28 09:05:45 +07:00
|
|
|
ata_acpi_handle_hotplug(dev->link->ap, dev, event);
|
[libata] ACPI: Properly handle bay devices in dock stations
* Differentiate between bay devices in dock stations and others:
- When an ACPI_NOTIFY_EJECT_REQUEST appears, just signal uevent to
userspace (that is when the optional eject button on a bay device is
pressed/pulled) giving the possibility to unmount file systems and to
clean up. Also, only send uevent in case we get an EJECT_REQUEST
without doing anything else. In other cases, you'll get an add/remove
event because libata attaches/detaches the device.
- In case of a dock event, which in turn signals an
ACPI_NOTIFY_EJECT_REQUEST, immediately detach the device, because it
may already have been gone
* In case of an ACPI_NOTIFY_DEVICE/BUS_CHECK, evaluate _STA to check if
the device has been plugged or unplugged. If plugged, hotplug it, if
unplugged, just signal event to userspace
(initial patch by Matthew Garrett <mjg59@srcf.ucam.org>)
* Call ACPI _EJ0 for detached devices
Signed-off-by: Holger Macht <hmacht@suse.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-06-04 01:27:59 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ata_acpi_ap_notify_dock(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = data;
|
|
|
|
|
2008-08-28 09:05:45 +07:00
|
|
|
ata_acpi_handle_hotplug(ap, NULL, event);
|
2007-10-03 07:24:16 +07:00
|
|
|
}
|
|
|
|
|
2008-08-28 09:06:16 +07:00
|
|
|
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(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
ata_acpi_uevent(data, NULL, 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);
|
|
|
|
}
|
|
|
|
|
2011-06-26 00:07:52 +07:00
|
|
|
static const struct acpi_dock_ops ata_acpi_dev_dock_ops = {
|
2008-08-28 09:06:16 +07:00
|
|
|
.handler = ata_acpi_dev_notify_dock,
|
|
|
|
.uevent = ata_acpi_dev_uevent,
|
|
|
|
};
|
|
|
|
|
2011-06-26 00:07:52 +07:00
|
|
|
static const struct acpi_dock_ops ata_acpi_ap_dock_ops = {
|
2008-08-28 09:06:16 +07:00
|
|
|
.handler = ata_acpi_ap_notify_dock,
|
|
|
|
.uevent = ata_acpi_ap_uevent,
|
|
|
|
};
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
/* bind acpi handle to pata port */
|
|
|
|
void ata_acpi_bind_port(struct ata_port *ap)
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
{
|
2013-11-29 05:58:28 +07:00
|
|
|
struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
|
2013-11-29 05:58:28 +07:00
|
|
|
if (libata_noacpi || ap->flags & ATA_FLAG_ACPI_SATA || !host_companion)
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
return;
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
|
2013-11-29 05:58:28 +07:00
|
|
|
acpi_preset_companion(&ap->tdev, host_companion, ap->port_no);
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
if (ata_acpi_gtm(ap, &ap->__acpi_init_gtm) == 0)
|
|
|
|
ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
/* we might be on a docking station */
|
|
|
|
register_hotplug_dock_device(ACPI_HANDLE(&ap->tdev),
|
|
|
|
&ata_acpi_ap_dock_ops, ap, NULL, NULL);
|
|
|
|
}
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
void ata_acpi_bind_dev(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = dev->link->ap;
|
2013-11-29 05:58:28 +07:00
|
|
|
struct acpi_device *port_companion = ACPI_COMPANION(&ap->tdev);
|
|
|
|
struct acpi_device *host_companion = ACPI_COMPANION(ap->host->dev);
|
|
|
|
struct acpi_device *parent;
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
u64 adr;
|
|
|
|
|
|
|
|
/*
|
2013-11-29 05:58:28 +07:00
|
|
|
* For both sata/pata devices, host companion device is required.
|
|
|
|
* For pata device, port companion device is also required.
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
*/
|
2013-11-29 05:58:28 +07:00
|
|
|
if (libata_noacpi || !host_companion ||
|
|
|
|
(!(ap->flags & ATA_FLAG_ACPI_SATA) && !port_companion))
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
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);
|
2013-11-29 05:58:28 +07:00
|
|
|
parent = host_companion;
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
} else {
|
|
|
|
adr = dev->devno;
|
2013-11-29 05:58:28 +07:00
|
|
|
parent = port_companion;
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
}
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
|
2013-11-29 05:58:28 +07:00
|
|
|
acpi_preset_companion(&dev->tdev, parent, adr);
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
|
|
|
|
register_hotplug_dock_device(ata_dev_acpi_handle(dev),
|
|
|
|
&ata_acpi_dev_dock_ops, dev, NULL, NULL);
|
libata-acpi: add back ACPI based hotplug functionality
Commit 30dcf76acc69 "libata: migrate ACPI code over to new bindings"
mistakenly dropped the code to register hotplug notificaion handler
for ATA port/devices, causing regression for people using ATA bay,
as kernel bug #59871 shows.
Fix this by adding back the hotplug notification handler registration
code. Since this code has to be run once and notification needs to
be installed on every ATA port/devices handle no matter if there is
actual device attached, we can't do this in binding time for ATA
device ACPI handle, as the binding only occurs when a SCSI device is
created, i.e. there is device attached. So introduce the
ata_acpi_hotplug_init() function to loop scan all ATA ACPI handles
and if it is available, install the notificaion handler for it during
ATA init time.
With the ATA ACPI handle binding to SCSI device tree, it is possible
now that when the SCSI hotplug work removes the SCSI device, the ACPI
unbind function will find that the corresponding ACPI device has
already been deleted by dock driver, causing a scaring message like:
[ 128.263966] scsi 4:0:0:0: Oops, 'acpi_handle' corrupt
Fix this by waiting for SCSI hotplug task finish in our notificaion
handler, so that the removal of ACPI device done in ACPI unbind
function triggered by the removal of SCSI device is run earlier when
ACPI device is still available.
[rjw: Rebased]
References: https://bugzilla.kernel.org/show_bug.cgi?id=59871
Reported-bisected-and-tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: 3.6+ <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-20 08:38:34 +07:00
|
|
|
}
|
|
|
|
|
2007-12-15 13:05:01 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-12-15 13:05:02 +07:00
|
|
|
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);
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
if (ACPI_HANDLE(&ap->tdev) && gtm)
|
2007-12-15 13:05:02 +07:00
|
|
|
ata_acpi_stm(ap, gtm);
|
|
|
|
}
|
2007-12-15 13:05:01 +07:00
|
|
|
}
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
2007-05-15 01:28:16 +07:00
|
|
|
{
|
|
|
|
struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
|
|
|
|
union acpi_object *out_obj;
|
|
|
|
acpi_status status;
|
|
|
|
int rc = 0;
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
acpi_handle handle = ACPI_HANDLE(&ap->tdev);
|
|
|
|
|
|
|
|
if (!handle)
|
|
|
|
return -EINVAL;
|
2007-05-15 01:28:16 +07:00
|
|
|
|
[libata] acpi: make ata_ap_acpi_handle not block
Since commit 30dcf76acc, ata_ap_acpi_handle will always do a namespace
walk, which requires acquiring an acpi namespace mutex. This made it
impossible to be used when calling path has held a spinlock.
For example, it can occur in the following code path for pata_acpi:
ata_scsi_queuecmd (ap->lock is acquired)
__ata_scsi_queuecmd
ata_scsi_translate
ata_qc_issue
pacpi_qc_issue
ata_acpi_stm
ata_ap_acpi_handle
acpi_get_child
acpi_walk_namespace
acpi_ut_acquire_mutex (acquire mutex while holding lock)
This caused scheduling while atomic bug, as reported in bug #56781.
Actually, ata_ap_acpi_handle doesn't have to walk the namespace every
time it is called, it can simply return the bound acpi handle on the
corresponding SCSI host. The reason previously it is not done this way
is, ata_ap_acpi_handle is used in the binding function
ata_acpi_bind_host by ata_acpi_gtm when the handle is not bound to the
SCSI host yet. Since we already have the ATA port's handle in its
binding function, we can simply use it instead of calling
ata_ap_acpi_handle there. So introduce a new function __ata_acpi_gtm,
where it will receive an acpi handle param in addition to the ATA port
which is solely used for debug statement. With this change, we can make
ata_ap_acpi_handle simply return the bound handle for SCSI host instead
of walking the acpi namespace now.
Buglink: https://bugzilla.kernel.org/show_bug.cgi?id=56781
Reported-and-tested-by: <kenzopl@o2.pl>
Cc: <stable@vger.kernel.org>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2013-04-27 08:33:07 +07:00
|
|
|
status = acpi_evaluate_object(handle, "_GTM", NULL, &output);
|
2007-05-15 01:28:16 +07:00
|
|
|
|
|
|
|
rc = -ENOENT;
|
|
|
|
if (status == AE_NOT_FOUND)
|
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
if (ACPI_FAILURE(status)) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_port_err(ap, "ACPI get timing mode failed (AE 0x%x)\n",
|
|
|
|
status);
|
2007-05-15 01:28:16 +07:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_obj = output.pointer;
|
|
|
|
if (out_obj->type != ACPI_TYPE_BUFFER) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_port_warn(ap, "_GTM returned unexpected object type 0x%x\n",
|
|
|
|
out_obj->type);
|
2007-05-15 01:28:16 +07:00
|
|
|
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (out_obj->buffer.length != sizeof(struct ata_acpi_gtm)) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_port_err(ap, "_GTM returned invalid length %d\n",
|
|
|
|
out_obj->buffer.length);
|
2007-05-15 01:28:16 +07:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(gtm, out_obj->buffer.pointer, sizeof(struct ata_acpi_gtm));
|
|
|
|
rc = 0;
|
|
|
|
out_free:
|
|
|
|
kfree(output.pointer);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-10-05 03:28:18 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_gtm);
|
|
|
|
|
2007-05-15 01:28:16 +07:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-12-15 13:04:57 +07:00
|
|
|
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm)
|
2007-05-15 01:28:16 +07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
2007-12-15 13:04:57 +07:00
|
|
|
struct ata_acpi_gtm stm_buf = *stm;
|
2007-05-15 01:28:16 +07:00
|
|
|
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);
|
2007-12-15 13:04:57 +07:00
|
|
|
in_params[0].buffer.pointer = (u8 *)&stm_buf;
|
2007-05-15 01:28:16 +07:00
|
|
|
/* Buffers for id may need byteswapping ? */
|
|
|
|
in_params[1].type = ACPI_TYPE_BUFFER;
|
|
|
|
in_params[1].buffer.length = 512;
|
2007-08-06 16:36:22 +07:00
|
|
|
in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
|
2007-05-15 01:28:16 +07:00
|
|
|
in_params[2].type = ACPI_TYPE_BUFFER;
|
|
|
|
in_params[2].buffer.length = 512;
|
2007-08-06 16:36:22 +07:00
|
|
|
in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
|
2007-05-15 01:28:16 +07:00
|
|
|
|
|
|
|
input.count = 3;
|
|
|
|
input.pointer = in_params;
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
status = acpi_evaluate_object(ACPI_HANDLE(&ap->tdev), "_STM",
|
|
|
|
&input, NULL);
|
2007-05-15 01:28:16 +07:00
|
|
|
|
|
|
|
if (status == AE_NOT_FOUND)
|
|
|
|
return -ENOENT;
|
|
|
|
if (ACPI_FAILURE(status)) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_port_err(ap, "ACPI set timing mode failed (status=0x%x)\n",
|
|
|
|
status);
|
2007-05-15 01:28:16 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-05 03:28:18 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_stm);
|
|
|
|
|
2006-09-29 01:29:01 +07:00
|
|
|
/**
|
2007-05-15 01:28:16 +07:00
|
|
|
* ata_dev_get_GTF - get the drive bootup default taskfile settings
|
2007-05-05 21:50:38 +07:00
|
|
|
* @dev: target ATA device
|
2007-05-15 01:28:16 +07:00
|
|
|
* @gtf: output parameter for buffer containing _GTF taskfile arrays
|
2006-09-29 01:29:01 +07:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2007-05-15 01:28:16 +07:00
|
|
|
* LOCKING:
|
|
|
|
* EH context.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
2007-12-15 13:05:04 +07:00
|
|
|
* Number of taskfiles on success, 0 if _GTF doesn't exist. -EINVAL
|
|
|
|
* if _GTF is invalid.
|
2006-09-29 01:29:01 +07:00
|
|
|
*/
|
2007-12-15 13:05:03 +07:00
|
|
|
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf)
|
2006-09-29 01:29:01 +07:00
|
|
|
{
|
2007-08-06 16:36:22 +07:00
|
|
|
struct ata_port *ap = dev->link->ap;
|
2007-05-05 21:50:38 +07:00
|
|
|
acpi_status status;
|
|
|
|
struct acpi_buffer output;
|
|
|
|
union acpi_object *out_obj;
|
2007-05-15 01:28:16 +07:00
|
|
|
int rc = 0;
|
2006-09-29 01:29:01 +07:00
|
|
|
|
2007-12-15 13:05:03 +07:00
|
|
|
/* if _GTF is cached, use the cached value */
|
|
|
|
if (dev->gtf_cache) {
|
|
|
|
out_obj = dev->gtf_cache;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-05-15 01:28:16 +07:00
|
|
|
/* set up output buffer */
|
|
|
|
output.length = ACPI_ALLOCATE_BUFFER;
|
|
|
|
output.pointer = NULL; /* ACPI-CA sets this; save/free it later */
|
2006-09-29 01:29:01 +07:00
|
|
|
|
|
|
|
if (ata_msg_probe(ap))
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_dbg(dev, "%s: ENTER: port#: %d\n",
|
|
|
|
__func__, ap->port_no);
|
2006-09-29 01:29:01 +07:00
|
|
|
|
|
|
|
/* _GTF has no input parameters */
|
2012-06-25 15:13:04 +07:00
|
|
|
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_GTF", NULL,
|
|
|
|
&output);
|
2007-12-15 13:05:03 +07:00
|
|
|
out_obj = dev->gtf_cache = output.pointer;
|
2007-05-15 01:28:16 +07:00
|
|
|
|
2006-09-29 01:29:01 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2007-05-15 01:28:16 +07:00
|
|
|
if (status != AE_NOT_FOUND) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_warn(dev, "_GTF evaluation failed (AE 0x%x)\n",
|
|
|
|
status);
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = -EINVAL;
|
2007-05-15 01:28:16 +07:00
|
|
|
}
|
|
|
|
goto out_free;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!output.length || !output.pointer) {
|
|
|
|
if (ata_msg_probe(ap))
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
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);
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = -EINVAL;
|
2007-05-15 01:28:16 +07:00
|
|
|
goto out_free;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (out_obj->type != ACPI_TYPE_BUFFER) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_warn(dev, "_GTF unexpected object type 0x%x\n",
|
|
|
|
out_obj->type);
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = -EINVAL;
|
2007-05-15 01:28:16 +07:00
|
|
|
goto out_free;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
2007-05-15 01:28:16 +07:00
|
|
|
if (out_obj->buffer.length % REGS_PER_GTF) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_warn(dev, "unexpected _GTF length (%d)\n",
|
|
|
|
out_obj->buffer.length);
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = -EINVAL;
|
2007-05-15 01:28:16 +07:00
|
|
|
goto out_free;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
2007-12-15 13:05:03 +07:00
|
|
|
done:
|
2007-05-15 01:28:16 +07:00
|
|
|
rc = out_obj->buffer.length / REGS_PER_GTF;
|
2007-12-15 13:05:03 +07:00
|
|
|
if (gtf) {
|
|
|
|
*gtf = (void *)out_obj->buffer.pointer;
|
|
|
|
if (ata_msg_probe(ap))
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_dbg(dev, "%s: returning gtf=%p, gtf_count=%d\n",
|
|
|
|
__func__, *gtf, rc);
|
2007-12-15 13:05:03 +07:00
|
|
|
}
|
2007-05-15 01:28:16 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
out_free:
|
2007-12-15 13:05:03 +07:00
|
|
|
ata_acpi_clear_gtf(dev);
|
2007-05-15 01:28:16 +07:00
|
|
|
return rc;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
2007-12-18 14:33:03 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-12-18 14:33:05 +07:00
|
|
|
unsigned long xfer_mask = 0;
|
|
|
|
unsigned int type;
|
|
|
|
int unit;
|
|
|
|
u8 mode;
|
2007-12-18 14:33:03 +07:00
|
|
|
|
|
|
|
/* we always use the 0 slot for crap hardware */
|
|
|
|
unit = dev->devno;
|
|
|
|
if (!(gtm->flags & 0x10))
|
|
|
|
unit = 0;
|
|
|
|
|
2007-12-18 14:33:05 +07:00
|
|
|
/* PIO */
|
|
|
|
mode = ata_timing_cycle2mode(ATA_SHIFT_PIO, gtm->drive[unit].pio);
|
|
|
|
xfer_mask |= ata_xfer_mode2mask(mode);
|
2007-12-18 14:33:03 +07:00
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2007-12-18 14:33:05 +07:00
|
|
|
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);
|
2007-12-18 14:33:03 +07:00
|
|
|
|
2007-12-18 14:33:05 +07:00
|
|
|
return xfer_mask;
|
2007-12-18 14:33:03 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_gtm_xfermask);
|
|
|
|
|
2007-08-16 13:33:36 +07:00
|
|
|
/**
|
|
|
|
* ata_acpi_cbl_80wire - Check for 80 wire cable
|
|
|
|
* @ap: Port to check
|
2007-12-18 14:33:06 +07:00
|
|
|
* @gtm: GTM data to use
|
2007-08-16 13:33:36 +07:00
|
|
|
*
|
2007-12-18 14:33:06 +07:00
|
|
|
* Return 1 if the @gtm indicates the BIOS selected an 80wire mode.
|
2007-08-16 13:33:36 +07:00
|
|
|
*/
|
2007-12-18 14:33:06 +07:00
|
|
|
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm)
|
2007-08-16 13:33:36 +07:00
|
|
|
{
|
2007-12-18 14:33:06 +07:00
|
|
|
struct ata_device *dev;
|
|
|
|
|
2008-11-03 18:03:17 +07:00
|
|
|
ata_for_each_dev(dev, &ap->link, ENABLED) {
|
2007-12-18 14:33:06 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-08-16 13:33:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
|
|
|
|
|
2007-12-15 13:05:06 +07:00
|
|
|
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 */
|
|
|
|
}
|
|
|
|
|
2009-09-16 02:17:28 +07:00
|
|
|
static int ata_acpi_filter_tf(struct ata_device *dev,
|
|
|
|
const struct ata_taskfile *tf,
|
2007-12-15 13:05:06 +07:00
|
|
|
const struct ata_taskfile *ptf)
|
|
|
|
{
|
2009-09-16 02:17:28 +07:00
|
|
|
if (dev->gtf_filter & ATA_ACPI_FILTER_SETXFER) {
|
2007-12-15 13:05:06 +07:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2009-09-16 02:17:28 +07:00
|
|
|
if (dev->gtf_filter & ATA_ACPI_FILTER_LOCK) {
|
2007-12-15 13:05:06 +07:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2009-09-16 02:17:02 +07:00
|
|
|
if (tf->command == ATA_CMD_SET_FEATURES &&
|
|
|
|
tf->feature == SETFEATURES_SATA_ENABLE) {
|
2008-07-06 21:15:03 +07:00
|
|
|
/* inhibit enabling DIPM */
|
2009-09-16 02:17:28 +07:00
|
|
|
if (dev->gtf_filter & ATA_ACPI_FILTER_DIPM &&
|
2008-07-06 21:15:03 +07:00
|
|
|
tf->nsect == SATA_DIPM)
|
|
|
|
return 1;
|
2009-09-16 02:17:02 +07:00
|
|
|
|
|
|
|
/* inhibit FPDMA non-zero offset */
|
2009-09-16 02:17:28 +07:00
|
|
|
if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_OFFSET &&
|
2009-09-16 02:17:02 +07:00
|
|
|
(tf->nsect == SATA_FPDMA_OFFSET ||
|
|
|
|
tf->nsect == SATA_FPDMA_IN_ORDER))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* inhibit FPDMA auto activation */
|
2009-09-16 02:17:28 +07:00
|
|
|
if (dev->gtf_filter & ATA_ACPI_FILTER_FPDMA_AA &&
|
2009-09-16 02:17:02 +07:00
|
|
|
tf->nsect == SATA_FPDMA_AA)
|
|
|
|
return 1;
|
2008-07-06 21:15:03 +07:00
|
|
|
}
|
|
|
|
|
2007-12-15 13:05:06 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-29 01:29:01 +07:00
|
|
|
/**
|
2007-12-15 13:05:05 +07:00
|
|
|
* ata_acpi_run_tf - send taskfile registers to host controller
|
2007-05-05 21:50:38 +07:00
|
|
|
* @dev: target ATA device
|
2006-09-29 01:29:01 +07:00
|
|
|
* @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
|
|
|
|
*
|
2011-02-05 02:04:17 +07:00
|
|
|
* Outputs ATA taskfile to standard ATA host controller.
|
2006-09-29 01:29:01 +07:00
|
|
|
* 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.
|
|
|
|
*
|
2007-05-15 01:28:16 +07:00
|
|
|
* LOCKING:
|
|
|
|
* EH context.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
2007-12-15 13:05:06 +07:00
|
|
|
* 1 if command is executed successfully. 0 if ignored, rejected or
|
|
|
|
* filtered out, -errno on other errors.
|
2006-09-29 01:29:01 +07:00
|
|
|
*/
|
2007-12-15 13:05:05 +07:00
|
|
|
static int ata_acpi_run_tf(struct ata_device *dev,
|
2007-12-15 13:05:06 +07:00
|
|
|
const struct ata_acpi_gtf *gtf,
|
|
|
|
const struct ata_acpi_gtf *prev_gtf)
|
2006-09-29 01:29:01 +07:00
|
|
|
{
|
2007-12-15 13:05:06 +07:00
|
|
|
struct ata_taskfile *pptf = NULL;
|
|
|
|
struct ata_taskfile tf, ptf, rtf;
|
2007-05-15 01:28:16 +07:00
|
|
|
unsigned int err_mask;
|
2007-12-15 13:05:05 +07:00
|
|
|
const char *level;
|
2009-07-15 09:43:39 +07:00
|
|
|
const char *descr;
|
2007-12-15 13:05:05 +07:00
|
|
|
char msg[60];
|
|
|
|
int rc;
|
2007-02-25 09:05:01 +07:00
|
|
|
|
2007-05-15 01:28:16 +07:00
|
|
|
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;
|
2006-09-29 01:29:01 +07:00
|
|
|
|
2007-12-15 13:05:06 +07:00
|
|
|
ata_acpi_gtf_to_tf(dev, gtf, &tf);
|
|
|
|
if (prev_gtf) {
|
|
|
|
ata_acpi_gtf_to_tf(dev, prev_gtf, &ptf);
|
|
|
|
pptf = &ptf;
|
|
|
|
}
|
|
|
|
|
2009-09-16 02:17:28 +07:00
|
|
|
if (!ata_acpi_filter_tf(dev, &tf, pptf)) {
|
2007-12-15 13:05:06 +07:00
|
|
|
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 {
|
2007-12-15 13:05:05 +07:00
|
|
|
level = KERN_INFO;
|
2007-12-15 13:05:06 +07:00
|
|
|
snprintf(msg, sizeof(msg), "filtered out");
|
2007-12-15 13:05:05 +07:00
|
|
|
rc = 0;
|
2007-05-15 01:28:16 +07:00
|
|
|
}
|
2009-07-15 09:43:39 +07:00
|
|
|
descr = ata_get_cmd_descript(tf.command);
|
2007-05-15 01:28:16 +07:00
|
|
|
|
2007-12-15 13:05:05 +07:00
|
|
|
ata_dev_printk(dev, level,
|
2009-07-15 09:43:39 +07:00
|
|
|
"ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x (%s) %s\n",
|
2007-12-15 13:05:05 +07:00
|
|
|
tf.command, tf.feature, tf.nsect, tf.lbal,
|
2009-07-15 09:43:39 +07:00
|
|
|
tf.lbam, tf.lbah, tf.device,
|
|
|
|
(descr ? descr : "unknown"), msg);
|
2007-12-15 13:05:05 +07:00
|
|
|
|
|
|
|
return rc;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ata_acpi_exec_tfs - get then write drive taskfile settings
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
* @dev: target ATA device
|
2009-04-22 23:21:29 +07:00
|
|
|
* @nr_executed: out parameter for the number of executed commands
|
2006-09-29 01:29:01 +07:00
|
|
|
*
|
2009-04-22 23:21:29 +07:00
|
|
|
* Evaluate _GTF and execute returned taskfiles.
|
2007-05-15 01:28:16 +07:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* EH context.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
2007-12-15 13:05:04 +07:00
|
|
|
* Number of executed taskfiles on success, 0 if _GTF doesn't exist.
|
|
|
|
* -errno on other errors.
|
2006-09-29 01:29:01 +07:00
|
|
|
*/
|
2007-12-15 13:05:04 +07:00
|
|
|
static int ata_acpi_exec_tfs(struct ata_device *dev, int *nr_executed)
|
2006-09-29 01:29:01 +07:00
|
|
|
{
|
2007-12-15 13:05:06 +07:00
|
|
|
struct ata_acpi_gtf *gtf = NULL, *pgtf = NULL;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
int gtf_count, i, rc;
|
|
|
|
|
|
|
|
/* get taskfiles */
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = ata_dev_get_GTF(dev, >f);
|
|
|
|
if (rc < 0)
|
|
|
|
return rc;
|
|
|
|
gtf_count = rc;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
|
|
|
|
/* execute them */
|
2007-12-15 13:05:06 +07:00
|
|
|
for (i = 0; i < gtf_count; i++, gtf++) {
|
|
|
|
rc = ata_acpi_run_tf(dev, gtf, pgtf);
|
2007-12-15 13:05:05 +07:00
|
|
|
if (rc < 0)
|
|
|
|
break;
|
2007-12-15 13:05:06 +07:00
|
|
|
if (rc) {
|
2007-12-15 13:05:05 +07:00
|
|
|
(*nr_executed)++;
|
2007-12-15 13:05:06 +07:00
|
|
|
pgtf = gtf;
|
|
|
|
}
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
2007-12-15 13:05:03 +07:00
|
|
|
ata_acpi_clear_gtf(dev);
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
|
2007-12-15 13:05:05 +07:00
|
|
|
if (rc < 0)
|
|
|
|
return rc;
|
|
|
|
return 0;
|
2006-09-29 01:29:01 +07:00
|
|
|
}
|
|
|
|
|
2006-09-29 01:29:12 +07:00
|
|
|
/**
|
|
|
|
* ata_acpi_push_id - send Identify data to drive
|
2007-05-05 21:50:38 +07:00
|
|
|
* @dev: target ATA device
|
2006-09-29 01:29:12 +07:00
|
|
|
*
|
|
|
|
* _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.
|
2007-05-15 01:28:16 +07:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* EH context.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
2009-11-18 20:24:21 +07:00
|
|
|
* 0 on success, -ENOENT if _SDD doesn't exist, -errno on failure.
|
2006-09-29 01:29:12 +07:00
|
|
|
*/
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
static int ata_acpi_push_id(struct ata_device *dev)
|
2006-09-29 01:29:12 +07:00
|
|
|
{
|
2007-08-06 16:36:22 +07:00
|
|
|
struct ata_port *ap = dev->link->ap;
|
2007-05-05 21:50:38 +07:00
|
|
|
acpi_status status;
|
|
|
|
struct acpi_object_list input;
|
|
|
|
union acpi_object in_params[1];
|
2006-09-29 01:29:12 +07:00
|
|
|
|
|
|
|
if (ata_msg_probe(ap))
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_dbg(dev, "%s: ix = %d, port#: %d\n",
|
|
|
|
__func__, dev->devno, ap->port_no);
|
2006-09-29 01:29:12 +07:00
|
|
|
|
|
|
|
/* 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;
|
2007-05-05 21:50:38 +07:00
|
|
|
in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
|
|
|
|
in_params[0].buffer.pointer = (u8 *)dev->id;
|
2006-09-29 01:29:12 +07:00
|
|
|
/* Output buffer: _SDD has no output */
|
|
|
|
|
|
|
|
/* It's OK for _SDD to be missing too. */
|
2007-05-05 21:50:38 +07:00
|
|
|
swap_buf_le16(dev->id, ATA_ID_WORDS);
|
2012-06-25 15:13:04 +07:00
|
|
|
status = acpi_evaluate_object(ata_dev_acpi_handle(dev), "_SDD", &input,
|
|
|
|
NULL);
|
2007-05-05 21:50:38 +07:00
|
|
|
swap_buf_le16(dev->id, ATA_ID_WORDS);
|
2006-09-29 01:29:12 +07:00
|
|
|
|
2009-11-18 20:24:21 +07:00
|
|
|
if (status == AE_NOT_FOUND)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_warn(dev, "ACPI _SDD failed (AE 0x%x)\n", status);
|
2009-11-18 20:24:21 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
2006-09-29 01:29:12 +07:00
|
|
|
|
2009-11-18 20:24:21 +07:00
|
|
|
return 0;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
}
|
|
|
|
|
2007-05-15 01:28:16 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-12-15 13:05:02 +07:00
|
|
|
/* nada */
|
|
|
|
return 0;
|
2007-05-15 01:28:16 +07:00
|
|
|
}
|
|
|
|
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-12-15 13:05:02 +07:00
|
|
|
const struct ata_acpi_gtm *gtm = ata_acpi_init_gtm(ap);
|
2007-08-06 16:36:23 +07:00
|
|
|
struct ata_device *dev;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
if (ACPI_HANDLE(&ap->tdev) && gtm) {
|
2007-12-15 13:05:03 +07:00
|
|
|
/* _GTM valid */
|
|
|
|
|
|
|
|
/* restore timing parameters */
|
2007-12-15 13:05:02 +07:00
|
|
|
ata_acpi_stm(ap, gtm);
|
2007-05-15 01:28:16 +07:00
|
|
|
|
2007-12-15 13:05:03 +07:00
|
|
|
/* _GTF should immediately follow _STM so that it can
|
|
|
|
* use values set by _STM. Cache _GTF result and
|
|
|
|
* schedule _GTF.
|
|
|
|
*/
|
2008-11-03 18:03:17 +07:00
|
|
|
ata_for_each_dev(dev, &ap->link, ALL) {
|
2007-12-15 13:05:03 +07:00
|
|
|
ata_acpi_clear_gtf(dev);
|
2008-03-25 15:50:45 +07:00
|
|
|
if (ata_dev_enabled(dev) &&
|
|
|
|
ata_dev_get_GTF(dev, NULL) >= 0)
|
2007-12-15 13:05:03 +07:00
|
|
|
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.
|
|
|
|
*/
|
2008-11-03 18:03:17 +07:00
|
|
|
ata_for_each_dev(dev, &ap->link, ALL) {
|
2007-12-15 13:05:03 +07:00
|
|
|
ata_acpi_clear_gtf(dev);
|
2008-03-25 15:50:45 +07:00
|
|
|
if (ata_dev_enabled(dev))
|
|
|
|
dev->flags |= ATA_DFLAG_ACPI_PENDING;
|
2007-12-15 13:05:03 +07:00
|
|
|
}
|
|
|
|
}
|
2006-09-29 01:29:12 +07:00
|
|
|
}
|
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
static int ata_acpi_choose_suspend_state(struct ata_device *dev, bool runtime)
|
2013-01-15 16:21:01 +07:00
|
|
|
{
|
|
|
|
int d_max_in = ACPI_STATE_D3_COLD;
|
2013-01-25 13:29:35 +07:00
|
|
|
if (!runtime)
|
|
|
|
goto out;
|
2013-01-15 16:21:01 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
out:
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
return acpi_pm_device_sleep_state(&dev->tdev, NULL, d_max_in);
|
2013-01-15 16:21:01 +07:00
|
|
|
}
|
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
static void sata_acpi_set_state(struct ata_port *ap, pm_message_t state)
|
2007-11-02 08:32:38 +07:00
|
|
|
{
|
2013-01-25 13:29:35 +07:00
|
|
|
bool runtime = PMSG_IS_AUTO(state);
|
2007-11-02 08:32:38 +07:00
|
|
|
struct ata_device *dev;
|
2012-06-25 15:13:05 +07:00
|
|
|
acpi_handle handle;
|
2012-06-25 15:13:06 +07:00
|
|
|
int acpi_state;
|
2007-11-02 08:32:38 +07:00
|
|
|
|
2008-11-03 18:03:17 +07:00
|
|
|
ata_for_each_dev(dev, &ap->link, ENABLED) {
|
2012-06-25 15:13:05 +07:00
|
|
|
handle = ata_dev_acpi_handle(dev);
|
2012-06-25 15:13:06 +07:00
|
|
|
if (!handle)
|
|
|
|
continue;
|
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
if (!(state.event & PM_EVENT_RESUME)) {
|
|
|
|
acpi_state = ata_acpi_choose_suspend_state(dev, runtime);
|
2013-01-15 16:21:01 +07:00
|
|
|
if (acpi_state == ACPI_STATE_D0)
|
|
|
|
continue;
|
2013-01-25 13:29:35 +07:00
|
|
|
if (runtime && zpodd_dev_enabled(dev) &&
|
2013-01-15 16:21:01 +07:00
|
|
|
acpi_state == ACPI_STATE_D3_COLD)
|
|
|
|
zpodd_enable_run_wake(dev);
|
|
|
|
acpi_bus_set_power(handle, acpi_state);
|
2012-06-25 15:13:06 +07:00
|
|
|
} else {
|
2013-01-25 13:29:35 +07:00
|
|
|
if (runtime && zpodd_dev_enabled(dev))
|
2013-01-15 16:21:01 +07:00
|
|
|
zpodd_disable_run_wake(dev);
|
2012-06-25 15:13:06 +07:00
|
|
|
acpi_bus_set_power(handle, ACPI_STATE_D0);
|
|
|
|
}
|
2007-11-02 08:32:38 +07:00
|
|
|
}
|
2013-01-25 13:29:35 +07:00
|
|
|
}
|
2012-06-25 15:13:05 +07:00
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
/* 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;
|
|
|
|
|
ata: acpi: rework the ata acpi bind support
Binding ACPI handle to SCSI device has several drawbacks, namely:
1 During ATA device initialization time, ACPI handle will be needed
while SCSI devices are not created yet. So each time ACPI handle is
needed, instead of retrieving the handle by ACPI_HANDLE macro,
a namespace scan is performed to find the handle for the corresponding
ATA device. This is inefficient, and also expose a restriction on
calling path not holding any lock.
2 The binding to SCSI device tree makes code complex, while at the same
time doesn't bring us any benefit. All ACPI handlings are still done
in ATA module, not in SCSI.
Rework the ATA ACPI binding code to bind ACPI handle to ATA transport
devices(ATA port and ATA device). The binding needs to be done only once,
since the ATA transport devices do not go away with hotplug. And due to
this, the flush_work call in hotplug handler for ATA bay is no longer
needed.
Tested on an Intel test platform for binding and runtime power off for
ODD(ZPODD) and hard disk; on an ASUS S400C for binding and normal boot
and S3, where its SATA port node has _SDD and _GTF control methods when
configured as an AHCI controller and its PATA device node has _GTF
control method when configured as an IDE controller. SATA PMP binding
and ATA hotplug is not tested.
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Tested-by: Dirk Griesbach <spamthis@freenet.de>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-08-23 09:17:54 +07:00
|
|
|
port_handle = ACPI_HANDLE(&ap->tdev);
|
2013-01-25 13:29:35 +07:00
|
|
|
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);
|
2012-06-25 15:13:05 +07:00
|
|
|
|
2013-01-25 13:29:35 +07:00
|
|
|
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 ?
|
2013-07-30 19:36:20 +07:00
|
|
|
ACPI_STATE_D0 : ACPI_STATE_D3_COLD);
|
2013-01-25 13:29:35 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(state.event & PM_EVENT_RESUME))
|
2013-07-30 19:36:20 +07:00
|
|
|
acpi_bus_set_power(port_handle, ACPI_STATE_D3_COLD);
|
2013-01-25 13:29:35 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
2007-11-02 08:32:38 +07:00
|
|
|
}
|
|
|
|
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-08-06 16:36:22 +07:00
|
|
|
struct ata_port *ap = dev->link->ap;
|
|
|
|
struct ata_eh_context *ehc = &ap->link.eh_context;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
|
2007-12-15 13:05:04 +07:00
|
|
|
int nr_executed = 0;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
int rc;
|
|
|
|
|
2012-06-25 15:13:04 +07:00
|
|
|
if (!ata_dev_acpi_handle(dev))
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
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);
|
2009-11-18 20:24:21 +07:00
|
|
|
if (rc && rc != -ENOENT)
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
goto acpi_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do _GTF */
|
2007-12-15 13:05:04 +07:00
|
|
|
rc = ata_acpi_exec_tfs(dev, &nr_executed);
|
|
|
|
if (rc)
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
goto acpi_err;
|
|
|
|
|
|
|
|
dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
|
|
|
|
|
|
|
|
/* refresh IDENTIFY page if any _GTF command has been executed */
|
2007-12-15 13:05:04 +07:00
|
|
|
if (nr_executed) {
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
rc = ata_dev_reread_id(dev, 0);
|
|
|
|
if (rc < 0) {
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_err(dev,
|
|
|
|
"failed to IDENTIFY after ACPI commands\n");
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
acpi_err:
|
2007-12-15 13:05:04 +07:00
|
|
|
/* ignore evaluation failure if we can continue safely */
|
|
|
|
if (rc == -EINVAL && !nr_executed && !(ap->pflags & ATA_PFLAG_FROZEN))
|
|
|
|
return 0;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
|
2007-12-15 13:05:04 +07:00
|
|
|
/* 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;
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
}
|
2007-12-15 13:05:04 +07:00
|
|
|
|
2012-11-26 12:55:25 +07:00
|
|
|
dev->flags |= ATA_DFLAG_ACPI_DISABLED;
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-16 05:51:59 +07:00
|
|
|
ata_dev_warn(dev, "ACPI: failed the second time, disabled\n");
|
2007-12-15 13:05:04 +07:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-15 01:28:16 +07:00
|
|
|
return rc;
|
|
|
|
}
|
2007-12-15 13:05:01 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-12-15 13:05:03 +07:00
|
|
|
ata_acpi_clear_gtf(dev);
|
2007-12-15 13:05:01 +07:00
|
|
|
}
|