mirror of
https://github.com/joel16/android_kernel_sony_msm8994_rework.git
synced 2024-11-27 22:00:42 +00:00
ACPI and power management updates for 3.8-rc1
* Introduction of device PM QoS flags. * ACPI device power management update allowing subsystems other than PCI to use it more easily. * ACPI device enumeration rework allowing additional kinds of devices to be enumerated via ACPI. From Mika Westerberg, Adrian Hunter, Mathias Nyman, Andy Shevchenko, and Rafael J. Wysocki. * ACPICA update to version 20121018 from Bob Moore and Lv Zheng. * ACPI memory hotplug update from Wen Congyang and Yasuaki Ishimatsu. * Introduction of acpi_handle_<level>() messaging macros and ACPI-based CPU hot-remove support from Toshi Kani. * ACPI EC updates from Feng Tang. * cpufreq updates from Viresh Kumar, Fabio Baltieri and others. * cpuidle changes to quickly notice governor prediction failure from Youquan Song. * Support for using multiple cpuidle drivers at the same time and cpuidle cleanups from Daniel Lezcano. * devfreq updates from Nishanth Menon and others. * cpupower update from Thomas Renninger. * Fixes and small cleanups all over the place. -- -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.19 (GNU/Linux) iQIcBAABAgAGBQJQxxevAAoJEKhOf7ml8uNsHacQAK2xoQozDddPBAaTCf1OWW/G J4E2qMn+gy4AtFmQ0/xeZVvvylOCn9eu/kv3QJ/bFlVoUsqTgfPwQBjT6HjF1Acn 7yVFdr9H/tn2wi9nW2Gv6Tl2Hr/kFLpo0f5Kd40Z+P8SV5sKX5ktJcVpJ/I/P4Vh Qw2nWtj7hQktZDERzgG4ZpMbQToNhbLhbKWB9ad3/XQSSA9JkfgvBFgrTEGHcZD5 bwsggjNdOAWNGeDdzRsQSDn0Alld5ILVdSJ5xKimO1O70WvKc7fqA1IdYRIeKL90 yz4bcoYKzl9iktlw8+x5o1U9mrc8TFV5p4+zV+t5Z6pzS/J3kWvnsW4zu9sCrxFv Wic3SKyiem7s2dxrYyj4ZXAci3GK4ouRTrCLqk7/00tEGdwAQD1ZNfsUJp6jKayz FvtZUgItcOyrlQ6B4nh951OY6dI3AUYJ2NuWWNr5NZkgVAvQGV8zTGOImbeVeL2+ pMiw14zScO3ylYilVcjTKDDMj2sDZ68mw5PIcbmksvWsCLo26jDBVDtLVmtYWyd4 ek3WnOrQZr0R3agvOLLssMKXompvpP+N4Klf4rV+GtqGsWtHryYKys2Laju9FwFj yYLchxYlxhGTzqq8LjF90HDL0TWpPe6cPi+B5ow9g/SXLexbMKNQGhv3Jovm2yR3 j54tKBWy7e9AAYEDPirX =6OEP -----END PGP SIGNATURE----- Merge tag 'pm+acpi-for-3.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm Pull ACPI and power management updates from Rafael Wysocki: - Introduction of device PM QoS flags. - ACPI device power management update allowing subsystems other than PCI to use it more easily. - ACPI device enumeration rework allowing additional kinds of devices to be enumerated via ACPI. From Mika Westerberg, Adrian Hunter, Mathias Nyman, Andy Shevchenko, and Rafael J. Wysocki. - ACPICA update to version 20121018 from Bob Moore and Lv Zheng. - ACPI memory hotplug update from Wen Congyang and Yasuaki Ishimatsu. - Introduction of acpi_handle_<level>() messaging macros and ACPI-based CPU hot-remove support from Toshi Kani. - ACPI EC updates from Feng Tang. - cpufreq updates from Viresh Kumar, Fabio Baltieri and others. - cpuidle changes to quickly notice governor prediction failure from Youquan Song. - Support for using multiple cpuidle drivers at the same time and cpuidle cleanups from Daniel Lezcano. - devfreq updates from Nishanth Menon and others. - cpupower update from Thomas Renninger. - Fixes and small cleanups all over the place. * tag 'pm+acpi-for-3.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (196 commits) mmc: sdhci-acpi: enable runtime-pm for device HID INT33C6 ACPI: add Haswell LPSS devices to acpi_platform_device_ids list ACPI: add documentation about ACPI 5 enumeration pnpacpi: fix incorrect TEST_ALPHA() test ACPI / PM: Fix header of acpi_dev_pm_detach() in acpi.h ACPI / video: ignore BIOS initial backlight value for HP Folio 13-2000 ACPI : do not use Lid and Sleep button for S5 wakeup ACPI / PNP: Do not crash due to stale pointer use during system resume ACPI / video: Add "Asus UL30VT" to ACPI video detect blacklist ACPI: do acpisleep dmi check when CONFIG_ACPI_SLEEP is set spi / ACPI: add ACPI enumeration support gpio / ACPI: add ACPI support PM / devfreq: remove compiler error with module governors (2) cpupower: IvyBridge (0x3a and 0x3e models) support cpupower: Provide -c param for cpupower monitor to schedule process on all cores cpupower tools: Fix warning and a bug with the cpu package count cpupower tools: Fix malloc of cpu_info structure cpupower tools: Fix issues with sysfs_topology_read_file cpupower tools: Fix minor warnings cpupower tools: Update .gitignore for files created in the debug directories ...
This commit is contained in:
Linus Torvalds
commit
bad73c5aa0
@ -11,7 +11,7 @@ What: /sys/class/devfreq/.../governor
|
||||
Date: September 2011
|
||||
Contact: MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
Description:
|
||||
The /sys/class/devfreq/.../governor shows the name of the
|
||||
The /sys/class/devfreq/.../governor show or set the name of the
|
||||
governor used by the corresponding devfreq object.
|
||||
|
||||
What: /sys/class/devfreq/.../cur_freq
|
||||
@ -19,15 +19,16 @@ Date: September 2011
|
||||
Contact: MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
Description:
|
||||
The /sys/class/devfreq/.../cur_freq shows the current
|
||||
frequency of the corresponding devfreq object.
|
||||
frequency of the corresponding devfreq object. Same as
|
||||
target_freq when get_cur_freq() is not implemented by
|
||||
devfreq driver.
|
||||
|
||||
What: /sys/class/devfreq/.../central_polling
|
||||
Date: September 2011
|
||||
Contact: MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
What: /sys/class/devfreq/.../target_freq
|
||||
Date: September 2012
|
||||
Contact: Rajagopal Venkat <rajagopal.venkat@linaro.org>
|
||||
Description:
|
||||
The /sys/class/devfreq/.../central_polling shows whether
|
||||
the devfreq ojbect is using devfreq-provided central
|
||||
polling mechanism or not.
|
||||
The /sys/class/devfreq/.../target_freq shows the next governor
|
||||
predicted target frequency of the corresponding devfreq object.
|
||||
|
||||
What: /sys/class/devfreq/.../polling_interval
|
||||
Date: September 2011
|
||||
@ -43,6 +44,17 @@ Description:
|
||||
(/sys/class/devfreq/.../central_polling is 0), this value
|
||||
may be useless.
|
||||
|
||||
What: /sys/class/devfreq/.../trans_stat
|
||||
Date: October 2012
|
||||
Contact: MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
Descrtiption:
|
||||
This ABI shows the statistics of devfreq behavior on a
|
||||
specific device. It shows the time spent in each state and
|
||||
the number of transitions between states.
|
||||
In order to activate this ABI, the devfreq target device
|
||||
driver should provide the list of available frequencies
|
||||
with its profile.
|
||||
|
||||
What: /sys/class/devfreq/.../userspace/set_freq
|
||||
Date: September 2011
|
||||
Contact: MyungJoo Ham <myungjoo.ham@samsung.com>
|
||||
@ -50,3 +62,19 @@ Description:
|
||||
The /sys/class/devfreq/.../userspace/set_freq shows and
|
||||
sets the requested frequency for the devfreq object if
|
||||
userspace governor is in effect.
|
||||
|
||||
What: /sys/class/devfreq/.../available_frequencies
|
||||
Date: October 2012
|
||||
Contact: Nishanth Menon <nm@ti.com>
|
||||
Description:
|
||||
The /sys/class/devfreq/.../available_frequencies shows
|
||||
the available frequencies of the corresponding devfreq object.
|
||||
This is a snapshot of available frequencies and not limited
|
||||
by the min/max frequency restrictions.
|
||||
|
||||
What: /sys/class/devfreq/.../available_governors
|
||||
Date: October 2012
|
||||
Contact: Nishanth Menon <nm@ti.com>
|
||||
Description:
|
||||
The /sys/class/devfreq/.../available_governors shows
|
||||
currently available governors in the system.
|
||||
|
||||
@ -204,3 +204,34 @@ Description:
|
||||
|
||||
This attribute has no effect on system-wide suspend/resume and
|
||||
hibernation.
|
||||
|
||||
What: /sys/devices/.../power/pm_qos_no_power_off
|
||||
Date: September 2012
|
||||
Contact: Rafael J. Wysocki <rjw@sisk.pl>
|
||||
Description:
|
||||
The /sys/devices/.../power/pm_qos_no_power_off attribute
|
||||
is used for manipulating the PM QoS "no power off" flag. If
|
||||
set, this flag indicates to the kernel that power should not
|
||||
be removed entirely from the device.
|
||||
|
||||
Not all drivers support this attribute. If it isn't supported,
|
||||
it is not present.
|
||||
|
||||
This attribute has no effect on system-wide suspend/resume and
|
||||
hibernation.
|
||||
|
||||
What: /sys/devices/.../power/pm_qos_remote_wakeup
|
||||
Date: September 2012
|
||||
Contact: Rafael J. Wysocki <rjw@sisk.pl>
|
||||
Description:
|
||||
The /sys/devices/.../power/pm_qos_remote_wakeup attribute
|
||||
is used for manipulating the PM QoS "remote wakeup required"
|
||||
flag. If set, this flag indicates to the kernel that the
|
||||
device is a source of user events that have to be signaled from
|
||||
its low-power states.
|
||||
|
||||
Not all drivers support this attribute. If it isn't supported,
|
||||
it is not present.
|
||||
|
||||
This attribute has no effect on system-wide suspend/resume and
|
||||
hibernation.
|
||||
|
||||
14
Documentation/ABI/testing/sysfs-devices-sun
Normal file
14
Documentation/ABI/testing/sysfs-devices-sun
Normal file
@ -0,0 +1,14 @@
|
||||
Whatt: /sys/devices/.../sun
|
||||
Date: October 2012
|
||||
Contact: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
|
||||
Description:
|
||||
The file contains a Slot-unique ID which provided by the _SUN
|
||||
method in the ACPI namespace. The value is written in Advanced
|
||||
Configuration and Power Interface Specification as follows:
|
||||
|
||||
"The _SUN value is required to be unique among the slots of
|
||||
the same type. It is also recommended that this number match
|
||||
the slot number printed on the physical slot whenever possible."
|
||||
|
||||
So reading the sysfs file, we can identify a physical position
|
||||
of the slot in the system.
|
||||
227
Documentation/acpi/enumeration.txt
Normal file
227
Documentation/acpi/enumeration.txt
Normal file
@ -0,0 +1,227 @@
|
||||
ACPI based device enumeration
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
ACPI 5 introduced a set of new resources (UartTSerialBus, I2cSerialBus,
|
||||
SpiSerialBus, GpioIo and GpioInt) which can be used in enumerating slave
|
||||
devices behind serial bus controllers.
|
||||
|
||||
In addition we are starting to see peripherals integrated in the
|
||||
SoC/Chipset to appear only in ACPI namespace. These are typically devices
|
||||
that are accessed through memory-mapped registers.
|
||||
|
||||
In order to support this and re-use the existing drivers as much as
|
||||
possible we decided to do following:
|
||||
|
||||
o Devices that have no bus connector resource are represented as
|
||||
platform devices.
|
||||
|
||||
o Devices behind real busses where there is a connector resource
|
||||
are represented as struct spi_device or struct i2c_device
|
||||
(standard UARTs are not busses so there is no struct uart_device).
|
||||
|
||||
As both ACPI and Device Tree represent a tree of devices (and their
|
||||
resources) this implementation follows the Device Tree way as much as
|
||||
possible.
|
||||
|
||||
The ACPI implementation enumerates devices behind busses (platform, SPI and
|
||||
I2C), creates the physical devices and binds them to their ACPI handle in
|
||||
the ACPI namespace.
|
||||
|
||||
This means that when ACPI_HANDLE(dev) returns non-NULL the device was
|
||||
enumerated from ACPI namespace. This handle can be used to extract other
|
||||
device-specific configuration. There is an example of this below.
|
||||
|
||||
Platform bus support
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
Since we are using platform devices to represent devices that are not
|
||||
connected to any physical bus we only need to implement a platform driver
|
||||
for the device and add supported ACPI IDs. If this same IP-block is used on
|
||||
some other non-ACPI platform, the driver might work out of the box or needs
|
||||
some minor changes.
|
||||
|
||||
Adding ACPI support for an existing driver should be pretty
|
||||
straightforward. Here is the simplest example:
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
static struct acpi_device_id mydrv_acpi_match[] = {
|
||||
/* ACPI IDs here */
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(acpi, mydrv_acpi_match);
|
||||
#endif
|
||||
|
||||
static struct platform_driver my_driver = {
|
||||
...
|
||||
.driver = {
|
||||
.acpi_match_table = ACPI_PTR(mydrv_acpi_match),
|
||||
},
|
||||
};
|
||||
|
||||
If the driver needs to perform more complex initialization like getting and
|
||||
configuring GPIOs it can get its ACPI handle and extract this information
|
||||
from ACPI tables.
|
||||
|
||||
Currently the kernel is not able to automatically determine from which ACPI
|
||||
device it should make the corresponding platform device so we need to add
|
||||
the ACPI device explicitly to acpi_platform_device_ids list defined in
|
||||
drivers/acpi/scan.c. This limitation is only for the platform devices, SPI
|
||||
and I2C devices are created automatically as described below.
|
||||
|
||||
SPI serial bus support
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
Slave devices behind SPI bus have SpiSerialBus resource attached to them.
|
||||
This is extracted automatically by the SPI core and the slave devices are
|
||||
enumerated once spi_register_master() is called by the bus driver.
|
||||
|
||||
Here is what the ACPI namespace for a SPI slave might look like:
|
||||
|
||||
Device (EEP0)
|
||||
{
|
||||
Name (_ADR, 1)
|
||||
Name (_CID, Package() {
|
||||
"ATML0025",
|
||||
"AT25",
|
||||
})
|
||||
...
|
||||
Method (_CRS, 0, NotSerialized)
|
||||
{
|
||||
SPISerialBus(1, PolarityLow, FourWireMode, 8,
|
||||
ControllerInitiated, 1000000, ClockPolarityLow,
|
||||
ClockPhaseFirst, "\\_SB.PCI0.SPI1",)
|
||||
}
|
||||
...
|
||||
|
||||
The SPI device drivers only need to add ACPI IDs in a similar way than with
|
||||
the platform device drivers. Below is an example where we add ACPI support
|
||||
to at25 SPI eeprom driver (this is meant for the above ACPI snippet):
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
static struct acpi_device_id at25_acpi_match[] = {
|
||||
{ "AT25", 0 },
|
||||
{ },
|
||||
};
|
||||
MODULE_DEVICE_TABLE(acpi, at25_acpi_match);
|
||||
#endif
|
||||
|
||||
static struct spi_driver at25_driver = {
|
||||
.driver = {
|
||||
...
|
||||
.acpi_match_table = ACPI_PTR(at25_acpi_match),
|
||||
},
|
||||
};
|
||||
|
||||
Note that this driver actually needs more information like page size of the
|
||||
eeprom etc. but at the time writing this there is no standard way of
|
||||
passing those. One idea is to return this in _DSM method like:
|
||||
|
||||
Device (EEP0)
|
||||
{
|
||||
...
|
||||
Method (_DSM, 4, NotSerialized)
|
||||
{
|
||||
Store (Package (6)
|
||||
{
|
||||
"byte-len", 1024,
|
||||
"addr-mode", 2,
|
||||
"page-size, 32
|
||||
}, Local0)
|
||||
|
||||
// Check UUIDs etc.
|
||||
|
||||
Return (Local0)
|
||||
}
|
||||
|
||||
Then the at25 SPI driver can get this configation by calling _DSM on its
|
||||
ACPI handle like:
|
||||
|
||||
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
|
||||
struct acpi_object_list input;
|
||||
acpi_status status;
|
||||
|
||||
/* Fill in the input buffer */
|
||||
|
||||
status = acpi_evaluate_object(ACPI_HANDLE(&spi->dev), "_DSM",
|
||||
&input, &output);
|
||||
if (ACPI_FAILURE(status))
|
||||
/* Handle the error */
|
||||
|
||||
/* Extract the data here */
|
||||
|
||||
kfree(output.pointer);
|
||||
|
||||
I2C serial bus support
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
The slaves behind I2C bus controller only need to add the ACPI IDs like
|
||||
with the platform and SPI drivers. However the I2C bus controller driver
|
||||
needs to call acpi_i2c_register_devices() after it has added the adapter.
|
||||
|
||||
An I2C bus (controller) driver does:
|
||||
|
||||
...
|
||||
ret = i2c_add_numbered_adapter(adapter);
|
||||
if (ret)
|
||||
/* handle error */
|
||||
|
||||
of_i2c_register_devices(adapter);
|
||||
/* Enumerate the slave devices behind this bus via ACPI */
|
||||
acpi_i2c_register_devices(adapter);
|
||||
|
||||
Below is an example of how to add ACPI support to the existing mpu3050
|
||||
input driver:
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
static struct acpi_device_id mpu3050_acpi_match[] = {
|
||||
{ "MPU3050", 0 },
|
||||
{ },
|
||||
};
|
||||
MODULE_DEVICE_TABLE(acpi, mpu3050_acpi_match);
|
||||
#endif
|
||||
|
||||
static struct i2c_driver mpu3050_i2c_driver = {
|
||||
.driver = {
|
||||
.name = "mpu3050",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = &mpu3050_pm,
|
||||
.of_match_table = mpu3050_of_match,
|
||||
.acpi_match_table ACPI_PTR(mpu3050_acpi_match),
|
||||
},
|
||||
.probe = mpu3050_probe,
|
||||
.remove = __devexit_p(mpu3050_remove),
|
||||
.id_table = mpu3050_ids,
|
||||
};
|
||||
|
||||
GPIO support
|
||||
~~~~~~~~~~~~
|
||||
ACPI 5 introduced two new resources to describe GPIO connections: GpioIo
|
||||
and GpioInt. These resources are used be used to pass GPIO numbers used by
|
||||
the device to the driver. For example:
|
||||
|
||||
Method (_CRS, 0, NotSerialized)
|
||||
{
|
||||
Name (SBUF, ResourceTemplate()
|
||||
{
|
||||
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000,
|
||||
IoRestrictionOutputOnly, "\\_SB.PCI0.GPI0",
|
||||
0x00, ResourceConsumer,,)
|
||||
{
|
||||
// Pin List
|
||||
0x0055
|
||||
}
|
||||
...
|
||||
|
||||
Return (SBUF)
|
||||
}
|
||||
}
|
||||
|
||||
These GPIO numbers are controller relative and path "\\_SB.PCI0.GPI0"
|
||||
specifies the path to the controller. In order to use these GPIOs in Linux
|
||||
we need to translate them to the Linux GPIO numbers.
|
||||
|
||||
The driver can do this by including <linux/acpi_gpio.h> and then calling
|
||||
acpi_get_gpio(path, gpio). This will return the Linux GPIO number or
|
||||
negative errno if there was no translation found.
|
||||
|
||||
Other GpioIo parameters must be converted first by the driver to be
|
||||
suitable to the gpiolib before passing them.
|
||||
|
||||
In case of GpioInt resource an additional call to gpio_to_irq() must be
|
||||
done before calling request_irq().
|
||||
42
Documentation/devicetree/bindings/cpufreq/cpufreq-spear.txt
Normal file
42
Documentation/devicetree/bindings/cpufreq/cpufreq-spear.txt
Normal file
@ -0,0 +1,42 @@
|
||||
SPEAr cpufreq driver
|
||||
-------------------
|
||||
|
||||
SPEAr SoC cpufreq driver for CPU frequency scaling.
|
||||
It supports both uniprocessor (UP) and symmetric multiprocessor (SMP) systems
|
||||
which share clock across all CPUs.
|
||||
|
||||
Required properties:
|
||||
- cpufreq_tbl: Table of frequencies CPU could be transitioned into, in the
|
||||
increasing order.
|
||||
|
||||
Optional properties:
|
||||
- clock-latency: Specify the possible maximum transition latency for clock, in
|
||||
unit of nanoseconds.
|
||||
|
||||
Both required and optional properties listed above must be defined under node
|
||||
/cpus/cpu@0.
|
||||
|
||||
Examples:
|
||||
--------
|
||||
cpus {
|
||||
|
||||
<...>
|
||||
|
||||
cpu@0 {
|
||||
compatible = "arm,cortex-a9";
|
||||
reg = <0>;
|
||||
|
||||
<...>
|
||||
|
||||
cpufreq_tbl = < 166000
|
||||
200000
|
||||
250000
|
||||
300000
|
||||
400000
|
||||
500000
|
||||
600000 >;
|
||||
};
|
||||
|
||||
<...>
|
||||
|
||||
};
|
||||
@ -99,7 +99,7 @@ reading the aggregated value does not require any locking mechanism.
|
||||
|
||||
From kernel mode the use of this interface is the following:
|
||||
|
||||
int dev_pm_qos_add_request(device, handle, value):
|
||||
int dev_pm_qos_add_request(device, handle, type, value):
|
||||
Will insert an element into the list for that identified device with the
|
||||
target value. Upon change to this list the new target is recomputed and any
|
||||
registered notifiers are called only if the target value is now different.
|
||||
|
||||
@ -908,6 +908,7 @@ config ARCH_NOMADIK
|
||||
|
||||
config PLAT_SPEAR
|
||||
bool "ST SPEAr"
|
||||
select ARCH_HAS_CPUFREQ
|
||||
select ARCH_REQUIRE_GPIOLIB
|
||||
select ARM_AMBA
|
||||
select CLKDEV_LOOKUP
|
||||
|
||||
@ -7,9 +7,6 @@
|
||||
#define _ASM_IA64_DEVICE_H
|
||||
|
||||
struct dev_archdata {
|
||||
#ifdef CONFIG_ACPI
|
||||
void *acpi_handle;
|
||||
#endif
|
||||
#ifdef CONFIG_INTEL_IOMMU
|
||||
void *iommu; /* hook for IOMMU specific extension */
|
||||
#endif
|
||||
|
||||
@ -633,6 +633,7 @@ int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
|
||||
ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
|
||||
IOSAPIC_LEVEL);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_register_gsi);
|
||||
|
||||
void acpi_unregister_gsi(u32 gsi)
|
||||
{
|
||||
@ -644,6 +645,7 @@ void acpi_unregister_gsi(u32 gsi)
|
||||
|
||||
iosapic_unregister_intr(gsi);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
|
||||
|
||||
static int __init acpi_parse_fadt(struct acpi_table_header *table)
|
||||
{
|
||||
|
||||
@ -36,7 +36,7 @@ static struct cpuidle_state *cpuidle_state_table;
|
||||
static inline void idle_loop_prolog(unsigned long *in_purr, ktime_t *kt_before)
|
||||
{
|
||||
|
||||
*kt_before = ktime_get_real();
|
||||
*kt_before = ktime_get();
|
||||
*in_purr = mfspr(SPRN_PURR);
|
||||
/*
|
||||
* Indicate to the HV that we are idle. Now would be
|
||||
@ -50,7 +50,7 @@ static inline s64 idle_loop_epilog(unsigned long in_purr, ktime_t kt_before)
|
||||
get_lppaca()->wait_state_cycles += mfspr(SPRN_PURR) - in_purr;
|
||||
get_lppaca()->idle = 0;
|
||||
|
||||
return ktime_to_us(ktime_sub(ktime_get_real(), kt_before));
|
||||
return ktime_to_us(ktime_sub(ktime_get(), kt_before));
|
||||
}
|
||||
|
||||
static int snooze_loop(struct cpuidle_device *dev,
|
||||
|
||||
@ -2,9 +2,6 @@
|
||||
#define _ASM_X86_DEVICE_H
|
||||
|
||||
struct dev_archdata {
|
||||
#ifdef CONFIG_ACPI
|
||||
void *acpi_handle;
|
||||
#endif
|
||||
#ifdef CONFIG_X86_DEV_DMA_OPS
|
||||
struct dma_map_ops *dma_ops;
|
||||
#endif
|
||||
|
||||
@ -574,6 +574,12 @@ int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity)
|
||||
|
||||
return irq;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_register_gsi);
|
||||
|
||||
void acpi_unregister_gsi(u32 gsi)
|
||||
{
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
|
||||
|
||||
void __init acpi_set_irq_model_pic(void)
|
||||
{
|
||||
|
||||
@ -101,6 +101,8 @@ static int __init acpi_sleep_setup(char *str)
|
||||
#endif
|
||||
if (strncmp(str, "nonvs", 5) == 0)
|
||||
acpi_nvs_nosave();
|
||||
if (strncmp(str, "nonvs_s3", 8) == 0)
|
||||
acpi_nvs_nosave_s3();
|
||||
if (strncmp(str, "old_ordering", 12) == 0)
|
||||
acpi_old_suspend_ordering();
|
||||
str = strchr(str, ',');
|
||||
|
||||
@ -181,6 +181,12 @@ config ACPI_DOCK
|
||||
This driver supports ACPI-controlled docking stations and removable
|
||||
drive bays such as the IBM Ultrabay and the Dell Module Bay.
|
||||
|
||||
config ACPI_I2C
|
||||
def_tristate I2C
|
||||
depends on I2C
|
||||
help
|
||||
ACPI I2C enumeration support.
|
||||
|
||||
config ACPI_PROCESSOR
|
||||
tristate "Processor"
|
||||
select THERMAL
|
||||
|
||||
@ -21,9 +21,10 @@ obj-y += acpi.o \
|
||||
acpi-y += osl.o utils.o reboot.o
|
||||
acpi-y += nvs.o
|
||||
|
||||
# sleep related files
|
||||
# Power management related files
|
||||
acpi-y += wakeup.o
|
||||
acpi-y += sleep.o
|
||||
acpi-$(CONFIG_PM) += device_pm.o
|
||||
acpi-$(CONFIG_ACPI_SLEEP) += proc.o
|
||||
|
||||
|
||||
@ -32,10 +33,12 @@ acpi-$(CONFIG_ACPI_SLEEP) += proc.o
|
||||
#
|
||||
acpi-y += bus.o glue.o
|
||||
acpi-y += scan.o
|
||||
acpi-y += resource.o
|
||||
acpi-y += processor_core.o
|
||||
acpi-y += ec.o
|
||||
acpi-$(CONFIG_ACPI_DOCK) += dock.o
|
||||
acpi-y += pci_root.o pci_link.o pci_irq.o pci_bind.o
|
||||
acpi-y += acpi_platform.o
|
||||
acpi-y += power.o
|
||||
acpi-y += event.o
|
||||
acpi-y += sysfs.o
|
||||
@ -67,6 +70,7 @@ obj-$(CONFIG_ACPI_HED) += hed.o
|
||||
obj-$(CONFIG_ACPI_EC_DEBUGFS) += ec_sys.o
|
||||
obj-$(CONFIG_ACPI_CUSTOM_METHOD)+= custom_method.o
|
||||
obj-$(CONFIG_ACPI_BGRT) += bgrt.o
|
||||
obj-$(CONFIG_ACPI_I2C) += acpi_i2c.o
|
||||
|
||||
# processor has its own "processor." module_param namespace
|
||||
processor-y := processor_driver.o processor_throttling.o
|
||||
|
||||
103
drivers/acpi/acpi_i2c.c
Normal file
103
drivers/acpi/acpi_i2c.c
Normal file
@ -0,0 +1,103 @@
|
||||
/*
|
||||
* ACPI I2C enumeration support
|
||||
*
|
||||
* Copyright (C) 2012, Intel Corporation
|
||||
* Author: Mika Westerberg <mika.westerberg@linux.intel.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/ioport.h>
|
||||
|
||||
ACPI_MODULE_NAME("i2c");
|
||||
|
||||
static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
|
||||
{
|
||||
struct i2c_board_info *info = data;
|
||||
|
||||
if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
|
||||
struct acpi_resource_i2c_serialbus *sb;
|
||||
|
||||
sb = &ares->data.i2c_serial_bus;
|
||||
if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
|
||||
info->addr = sb->slave_address;
|
||||
if (sb->access_mode == ACPI_I2C_10BIT_MODE)
|
||||
info->flags |= I2C_CLIENT_TEN;
|
||||
}
|
||||
} else if (info->irq < 0) {
|
||||
struct resource r;
|
||||
|
||||
if (acpi_dev_resource_interrupt(ares, 0, &r))
|
||||
info->irq = r.start;
|
||||
}
|
||||
|
||||
/* Tell the ACPI core to skip this resource */
|
||||
return 1;
|
||||
}
|
||||
|
||||
static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
|
||||
void *data, void **return_value)
|
||||
{
|
||||
struct i2c_adapter *adapter = data;
|
||||
struct list_head resource_list;
|
||||
struct i2c_board_info info;
|
||||
struct acpi_device *adev;
|
||||
int ret;
|
||||
|
||||
if (acpi_bus_get_device(handle, &adev))
|
||||
return AE_OK;
|
||||
if (acpi_bus_get_status(adev) || !adev->status.present)
|
||||
return AE_OK;
|
||||
|
||||
memset(&info, 0, sizeof(info));
|
||||
info.acpi_node.handle = handle;
|
||||
info.irq = -1;
|
||||
|
||||
INIT_LIST_HEAD(&resource_list);
|
||||
ret = acpi_dev_get_resources(adev, &resource_list,
|
||||
acpi_i2c_add_resource, &info);
|
||||
acpi_dev_free_resource_list(&resource_list);
|
||||
|
||||
if (ret < 0 || !info.addr)
|
||||
return AE_OK;
|
||||
|
||||
strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
|
||||
if (!i2c_new_device(adapter, &info)) {
|
||||
dev_err(&adapter->dev,
|
||||
"failed to add I2C device %s from ACPI\n",
|
||||
dev_name(&adev->dev));
|
||||
}
|
||||
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
|
||||
* @adapter: pointer to adapter
|
||||
*
|
||||
* Enumerate all I2C slave devices behind this adapter by walking the ACPI
|
||||
* namespace. When a device is found it will be added to the Linux device
|
||||
* model and bound to the corresponding ACPI handle.
|
||||
*/
|
||||
void acpi_i2c_register_devices(struct i2c_adapter *adapter)
|
||||
{
|
||||
acpi_handle handle;
|
||||
acpi_status status;
|
||||
|
||||
handle = ACPI_HANDLE(&adapter->dev);
|
||||
if (!handle)
|
||||
return;
|
||||
|
||||
status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
|
||||
acpi_i2c_add_device, NULL,
|
||||
adapter, NULL);
|
||||
if (ACPI_FAILURE(status))
|
||||
dev_warn(&adapter->dev, "failed to enumerate I2C slaves\n");
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_i2c_register_devices);
|
||||
@ -31,6 +31,7 @@
|
||||
#include <linux/types.h>
|
||||
#include <linux/memory_hotplug.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/acpi.h>
|
||||
#include <acpi/acpi_drivers.h>
|
||||
|
||||
#define ACPI_MEMORY_DEVICE_CLASS "memory"
|
||||
@ -78,6 +79,7 @@ struct acpi_memory_info {
|
||||
unsigned short caching; /* memory cache attribute */
|
||||
unsigned short write_protect; /* memory read/write attribute */
|
||||
unsigned int enabled:1;
|
||||
unsigned int failed:1;
|
||||
};
|
||||
|
||||
struct acpi_memory_device {
|
||||
@ -86,8 +88,6 @@ struct acpi_memory_device {
|
||||
struct list_head res_list;
|
||||
};
|
||||
|
||||
static int acpi_hotmem_initialized;
|
||||
|
||||
static acpi_status
|
||||
acpi_memory_get_resource(struct acpi_resource *resource, void *context)
|
||||
{
|
||||
@ -125,12 +125,20 @@ acpi_memory_get_resource(struct acpi_resource *resource, void *context)
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
static void
|
||||
acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
|
||||
{
|
||||
struct acpi_memory_info *info, *n;
|
||||
|
||||
list_for_each_entry_safe(info, n, &mem_device->res_list, list)
|
||||
kfree(info);
|
||||
INIT_LIST_HEAD(&mem_device->res_list);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpi_memory_info *info, *n;
|
||||
|
||||
|
||||
if (!list_empty(&mem_device->res_list))
|
||||
return 0;
|
||||
@ -138,9 +146,7 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
|
||||
status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
|
||||
acpi_memory_get_resource, mem_device);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
list_for_each_entry_safe(info, n, &mem_device->res_list, list)
|
||||
kfree(info);
|
||||
INIT_LIST_HEAD(&mem_device->res_list);
|
||||
acpi_memory_free_device_resources(mem_device);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -170,7 +176,7 @@ acpi_memory_get_device(acpi_handle handle,
|
||||
/* Get the parent device */
|
||||
result = acpi_bus_get_device(phandle, &pdevice);
|
||||
if (result) {
|
||||
printk(KERN_WARNING PREFIX "Cannot get acpi bus device");
|
||||
acpi_handle_warn(phandle, "Cannot get acpi bus device\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -180,14 +186,14 @@ acpi_memory_get_device(acpi_handle handle,
|
||||
*/
|
||||
result = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
|
||||
if (result) {
|
||||
printk(KERN_WARNING PREFIX "Cannot add acpi bus");
|
||||
acpi_handle_warn(handle, "Cannot add acpi bus\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
end:
|
||||
*mem_device = acpi_driver_data(device);
|
||||
if (!(*mem_device)) {
|
||||
printk(KERN_ERR "\n driver data not found");
|
||||
dev_err(&device->dev, "driver data not found\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
@ -224,7 +230,8 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
|
||||
/* Get the range from the _CRS */
|
||||
result = acpi_memory_get_device_resources(mem_device);
|
||||
if (result) {
|
||||
printk(KERN_ERR PREFIX "get_device_resources failed\n");
|
||||
dev_err(&mem_device->device->dev,
|
||||
"get_device_resources failed\n");
|
||||
mem_device->state = MEMORY_INVALID_STATE;
|
||||
return result;
|
||||
}
|
||||
@ -251,13 +258,27 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
|
||||
node = memory_add_physaddr_to_nid(info->start_addr);
|
||||
|
||||
result = add_memory(node, info->start_addr, info->length);
|
||||
if (result)
|
||||
|
||||
/*
|
||||
* If the memory block has been used by the kernel, add_memory()
|
||||
* returns -EEXIST. If add_memory() returns the other error, it
|
||||
* means that this memory block is not used by the kernel.
|
||||
*/
|
||||
if (result && result != -EEXIST) {
|
||||
info->failed = 1;
|
||||
continue;
|
||||
info->enabled = 1;
|
||||
}
|
||||
|
||||
if (!result)
|
||||
info->enabled = 1;
|
||||
/*
|
||||
* Add num_enable even if add_memory() returns -EEXIST, so the
|
||||
* device is bound to this driver.
|
||||
*/
|
||||
num_enabled++;
|
||||
}
|
||||
if (!num_enabled) {
|
||||
printk(KERN_ERR PREFIX "add_memory failed\n");
|
||||
dev_err(&mem_device->device->dev, "add_memory failed\n");
|
||||
mem_device->state = MEMORY_INVALID_STATE;
|
||||
return -EINVAL;
|
||||
}
|
||||
@ -272,68 +293,31 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
|
||||
static int acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpi_object_list arg_list;
|
||||
union acpi_object arg;
|
||||
unsigned long long current_status;
|
||||
|
||||
|
||||
/* Issue the _EJ0 command */
|
||||
arg_list.count = 1;
|
||||
arg_list.pointer = &arg;
|
||||
arg.type = ACPI_TYPE_INTEGER;
|
||||
arg.integer.value = 1;
|
||||
status = acpi_evaluate_object(mem_device->device->handle,
|
||||
"_EJ0", &arg_list, NULL);
|
||||
/* Return on _EJ0 failure */
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
/* Evalute _STA to check if the device is disabled */
|
||||
status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
|
||||
NULL, ¤t_status);
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
/* Check for device status. Device should be disabled */
|
||||
if (current_status & ACPI_STA_DEVICE_ENABLED)
|
||||
return -EINVAL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
|
||||
{
|
||||
int result;
|
||||
int result = 0;
|
||||
struct acpi_memory_info *info, *n;
|
||||
|
||||
|
||||
/*
|
||||
* Ask the VM to offline this memory range.
|
||||
* Note: Assume that this function returns zero on success
|
||||
*/
|
||||
list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
|
||||
if (info->enabled) {
|
||||
result = remove_memory(info->start_addr, info->length);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
if (info->failed)
|
||||
/* The kernel does not use this memory block */
|
||||
continue;
|
||||
|
||||
if (!info->enabled)
|
||||
/*
|
||||
* The kernel uses this memory block, but it may be not
|
||||
* managed by us.
|
||||
*/
|
||||
return -EBUSY;
|
||||
|
||||
result = remove_memory(info->start_addr, info->length);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
list_del(&info->list);
|
||||
kfree(info);
|
||||
}
|
||||
|
||||
/* Power-off and eject the device */
|
||||
result = acpi_memory_powerdown_device(mem_device);
|
||||
if (result) {
|
||||
/* Set the status of the device to invalid */
|
||||
mem_device->state = MEMORY_INVALID_STATE;
|
||||
return result;
|
||||
}
|
||||
|
||||
mem_device->state = MEMORY_POWER_OFF_STATE;
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -341,6 +325,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_memory_device *mem_device;
|
||||
struct acpi_device *device;
|
||||
struct acpi_eject_event *ej_event = NULL;
|
||||
u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
|
||||
|
||||
switch (event) {
|
||||
@ -353,7 +338,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"\nReceived DEVICE CHECK notification for device\n"));
|
||||
if (acpi_memory_get_device(handle, &mem_device)) {
|
||||
printk(KERN_ERR PREFIX "Cannot find driver data\n");
|
||||
acpi_handle_err(handle, "Cannot find driver data\n");
|
||||
break;
|
||||
}
|
||||
|
||||
@ -361,7 +346,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
break;
|
||||
|
||||
if (acpi_memory_enable_device(mem_device)) {
|
||||
printk(KERN_ERR PREFIX "Cannot enable memory device\n");
|
||||
acpi_handle_err(handle,"Cannot enable memory device\n");
|
||||
break;
|
||||
}
|
||||
|
||||
@ -373,40 +358,28 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
"\nReceived EJECT REQUEST notification for device\n"));
|
||||
|
||||
if (acpi_bus_get_device(handle, &device)) {
|
||||
printk(KERN_ERR PREFIX "Device doesn't exist\n");
|
||||
acpi_handle_err(handle, "Device doesn't exist\n");
|
||||
break;
|
||||
}
|
||||
mem_device = acpi_driver_data(device);
|
||||
if (!mem_device) {
|
||||
printk(KERN_ERR PREFIX "Driver Data is NULL\n");
|
||||
acpi_handle_err(handle, "Driver Data is NULL\n");
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Currently disabling memory device from kernel mode
|
||||
* TBD: Can also be disabled from user mode scripts
|
||||
* TBD: Can also be disabled by Callback registration
|
||||
* with generic sysfs driver
|
||||
*/
|
||||
if (acpi_memory_disable_device(mem_device)) {
|
||||
printk(KERN_ERR PREFIX "Disable memory device\n");
|
||||
/*
|
||||
* If _EJ0 was called but failed, _OST is not
|
||||
* necessary.
|
||||
*/
|
||||
if (mem_device->state == MEMORY_INVALID_STATE)
|
||||
return;
|
||||
|
||||
ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
|
||||
if (!ej_event) {
|
||||
pr_err(PREFIX "No memory, dropping EJECT\n");
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* TBD: Invoke acpi_bus_remove to cleanup data structures
|
||||
*/
|
||||
ej_event->handle = handle;
|
||||
ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
|
||||
acpi_os_hotplug_execute(acpi_bus_hot_remove_device,
|
||||
(void *)ej_event);
|
||||
|
||||
/* _EJ0 succeeded; _OST is not necessary */
|
||||
/* eject is performed asynchronously */
|
||||
return;
|
||||
|
||||
default:
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"Unsupported event [0x%x]\n", event));
|
||||
@ -420,6 +393,15 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
return;
|
||||
}
|
||||
|
||||
static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
|
||||
{
|
||||
if (!mem_device)
|
||||
return;
|
||||
|
||||
acpi_memory_free_device_resources(mem_device);
|
||||
kfree(mem_device);
|
||||
}
|
||||
|
||||
static int acpi_memory_device_add(struct acpi_device *device)
|
||||
{
|
||||
int result;
|
||||
@ -449,23 +431,16 @@ static int acpi_memory_device_add(struct acpi_device *device)
|
||||
/* Set the device state */
|
||||
mem_device->state = MEMORY_POWER_ON_STATE;
|
||||
|
||||
printk(KERN_DEBUG "%s \n", acpi_device_name(device));
|
||||
|
||||
/*
|
||||
* Early boot code has recognized memory area by EFI/E820.
|
||||
* If DSDT shows these memory devices on boot, hotplug is not necessary
|
||||
* for them. So, it just returns until completion of this driver's
|
||||
* start up.
|
||||
*/
|
||||
if (!acpi_hotmem_initialized)
|
||||
return 0;
|
||||
pr_debug("%s\n", acpi_device_name(device));
|
||||
|
||||
if (!acpi_memory_check_device(mem_device)) {
|
||||
/* call add_memory func */
|
||||
result = acpi_memory_enable_device(mem_device);
|
||||
if (result)
|
||||
printk(KERN_ERR PREFIX
|
||||
if (result) {
|
||||
dev_err(&device->dev,
|
||||
"Error in acpi_memory_enable_device\n");
|
||||
acpi_memory_device_free(mem_device);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
@ -473,13 +448,18 @@ static int acpi_memory_device_add(struct acpi_device *device)
|
||||
static int acpi_memory_device_remove(struct acpi_device *device, int type)
|
||||
{
|
||||
struct acpi_memory_device *mem_device = NULL;
|
||||
|
||||
int result;
|
||||
|
||||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
mem_device = acpi_driver_data(device);
|
||||
kfree(mem_device);
|
||||
|
||||
result = acpi_memory_remove_memory(mem_device);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
acpi_memory_device_free(mem_device);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -568,7 +548,6 @@ static int __init acpi_memory_device_init(void)
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
acpi_hotmem_initialized = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -286,7 +286,7 @@ static ssize_t acpi_pad_rrtime_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
if (strict_strtoul(buf, 0, &num))
|
||||
if (kstrtoul(buf, 0, &num))
|
||||
return -EINVAL;
|
||||
if (num < 1 || num >= 100)
|
||||
return -EINVAL;
|
||||
@ -309,7 +309,7 @@ static ssize_t acpi_pad_idlepct_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
if (strict_strtoul(buf, 0, &num))
|
||||
if (kstrtoul(buf, 0, &num))
|
||||
return -EINVAL;
|
||||
if (num < 1 || num >= 100)
|
||||
return -EINVAL;
|
||||
@ -332,7 +332,7 @@ static ssize_t acpi_pad_idlecpus_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
if (strict_strtoul(buf, 0, &num))
|
||||
if (kstrtoul(buf, 0, &num))
|
||||
return -EINVAL;
|
||||
mutex_lock(&isolated_cpus_lock);
|
||||
acpi_pad_idle_cpus(num);
|
||||
@ -457,7 +457,7 @@ static void acpi_pad_notify(acpi_handle handle, u32 event,
|
||||
dev_name(&device->dev), event, 0);
|
||||
break;
|
||||
default:
|
||||
printk(KERN_WARNING "Unsupported event [0x%x]\n", event);
|
||||
pr_warn("Unsupported event [0x%x]\n", event);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
104
drivers/acpi/acpi_platform.c
Normal file
104
drivers/acpi/acpi_platform.c
Normal file
@ -0,0 +1,104 @@
|
||||
/*
|
||||
* ACPI support for platform bus type.
|
||||
*
|
||||
* Copyright (C) 2012, Intel Corporation
|
||||
* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
|
||||
* Mathias Nyman <mathias.nyman@linux.intel.com>
|
||||
* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
ACPI_MODULE_NAME("platform");
|
||||
|
||||
/**
|
||||
* acpi_create_platform_device - Create platform device for ACPI device node
|
||||
* @adev: ACPI device node to create a platform device for.
|
||||
*
|
||||
* Check if the given @adev can be represented as a platform device and, if
|
||||
* that's the case, create and register a platform device, populate its common
|
||||
* resources and returns a pointer to it. Otherwise, return %NULL.
|
||||
*
|
||||
* The platform device's name will be taken from the @adev's _HID and _UID.
|
||||
*/
|
||||
struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
|
||||
{
|
||||
struct platform_device *pdev = NULL;
|
||||
struct acpi_device *acpi_parent;
|
||||
struct platform_device_info pdevinfo;
|
||||
struct resource_list_entry *rentry;
|
||||
struct list_head resource_list;
|
||||
struct resource *resources;
|
||||
int count;
|
||||
|
||||
/* If the ACPI node already has a physical device attached, skip it. */
|
||||
if (adev->physical_node_count)
|
||||
return NULL;
|
||||
|
||||
INIT_LIST_HEAD(&resource_list);
|
||||
count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
|
||||
if (count <= 0)
|
||||
return NULL;
|
||||
|
||||
resources = kmalloc(count * sizeof(struct resource), GFP_KERNEL);
|
||||
if (!resources) {
|
||||
dev_err(&adev->dev, "No memory for resources\n");
|
||||
acpi_dev_free_resource_list(&resource_list);
|
||||
return NULL;
|
||||
}
|
||||
count = 0;
|
||||
list_for_each_entry(rentry, &resource_list, node)
|
||||
resources[count++] = rentry->res;
|
||||
|
||||
acpi_dev_free_resource_list(&resource_list);
|
||||
|
||||
memset(&pdevinfo, 0, sizeof(pdevinfo));
|
||||
/*
|
||||
* If the ACPI node has a parent and that parent has a physical device
|
||||
* attached to it, that physical device should be the parent of the
|
||||
* platform device we are about to create.
|
||||
*/
|
||||
pdevinfo.parent = NULL;
|
||||
acpi_parent = adev->parent;
|
||||
if (acpi_parent) {
|
||||
struct acpi_device_physical_node *entry;
|
||||
struct list_head *list;
|
||||
|
||||
mutex_lock(&acpi_parent->physical_node_lock);
|
||||
list = &acpi_parent->physical_node_list;
|
||||
if (!list_empty(list)) {
|
||||
entry = list_first_entry(list,
|
||||
struct acpi_device_physical_node,
|
||||
node);
|
||||
pdevinfo.parent = entry->dev;
|
||||
}
|
||||
mutex_unlock(&acpi_parent->physical_node_lock);
|
||||
}
|
||||
pdevinfo.name = dev_name(&adev->dev);
|
||||
pdevinfo.id = -1;
|
||||
pdevinfo.res = resources;
|
||||
pdevinfo.num_res = count;
|
||||
pdevinfo.acpi_node.handle = adev->handle;
|
||||
pdev = platform_device_register_full(&pdevinfo);
|
||||
if (IS_ERR(pdev)) {
|
||||
dev_err(&adev->dev, "platform device creation failed: %ld\n",
|
||||
PTR_ERR(pdev));
|
||||
pdev = NULL;
|
||||
} else {
|
||||
dev_dbg(&adev->dev, "created platform device %s\n",
|
||||
dev_name(&pdev->dev));
|
||||
}
|
||||
|
||||
kfree(resources);
|
||||
return pdev;
|
||||
}
|
||||
@ -161,3 +161,6 @@ acpi-y += \
|
||||
utxfinit.o \
|
||||
utxferror.o \
|
||||
utxfmutex.o
|
||||
|
||||
acpi-$(ACPI_FUTURE_USAGE) += uttrack.o utcache.o utclib.o
|
||||
|
||||
|
||||
@ -44,17 +44,28 @@
|
||||
#ifndef __ACDEBUG_H__
|
||||
#define __ACDEBUG_H__
|
||||
|
||||
#define ACPI_DEBUG_BUFFER_SIZE 4196
|
||||
#define ACPI_DEBUG_BUFFER_SIZE 0x4000 /* 16K buffer for return objects */
|
||||
|
||||
struct command_info {
|
||||
struct acpi_db_command_info {
|
||||
char *name; /* Command Name */
|
||||
u8 min_args; /* Minimum arguments required */
|
||||
};
|
||||
|
||||
struct argument_info {
|
||||
struct acpi_db_command_help {
|
||||
u8 line_count; /* Number of help lines */
|
||||
char *invocation; /* Command Invocation */
|
||||
char *description; /* Command Description */
|
||||
};
|
||||
|
||||
struct acpi_db_argument_info {
|
||||
char *name; /* Argument Name */
|
||||
};
|
||||
|
||||
struct acpi_db_execute_walk {
|
||||
u32 count;
|
||||
u32 max_count;
|
||||
};
|
||||
|
||||
#define PARAM_LIST(pl) pl
|
||||
#define DBTEST_OUTPUT_LEVEL(lvl) if (acpi_gbl_db_opt_verbose)
|
||||
#define VERBOSE_PRINT(fp) DBTEST_OUTPUT_LEVEL(lvl) {\
|
||||
@ -77,43 +88,19 @@ acpi_db_single_step(struct acpi_walk_state *walk_state,
|
||||
/*
|
||||
* dbcmds - debug commands and output routines
|
||||
*/
|
||||
acpi_status acpi_db_disassemble_method(char *name);
|
||||
struct acpi_namespace_node *acpi_db_convert_to_node(char *in_string);
|
||||
|
||||
void acpi_db_display_table_info(char *table_arg);
|
||||
|
||||
void acpi_db_unload_acpi_table(char *table_arg, char *instance_arg);
|
||||
void acpi_db_display_template(char *buffer_arg);
|
||||
|
||||
void
|
||||
acpi_db_set_method_breakpoint(char *location,
|
||||
struct acpi_walk_state *walk_state,
|
||||
union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_set_method_call_breakpoint(union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_get_bus_info(void);
|
||||
|
||||
void acpi_db_disassemble_aml(char *statements, union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_dump_namespace(char *start_arg, char *depth_arg);
|
||||
|
||||
void acpi_db_dump_namespace_by_owner(char *owner_arg, char *depth_arg);
|
||||
void acpi_db_unload_acpi_table(char *name);
|
||||
|
||||
void acpi_db_send_notify(char *name, u32 value);
|
||||
|
||||
void acpi_db_set_method_data(char *type_arg, char *index_arg, char *value_arg);
|
||||
|
||||
acpi_status
|
||||
acpi_db_display_objects(char *obj_type_arg, char *display_count_arg);
|
||||
|
||||
void acpi_db_display_interfaces(char *action_arg, char *interface_name_arg);
|
||||
|
||||
acpi_status acpi_db_find_name_in_namespace(char *name_arg);
|
||||
|
||||
void acpi_db_set_scope(char *name);
|
||||
|
||||
ACPI_HW_DEPENDENT_RETURN_OK(acpi_status acpi_db_sleep(char *object_arg))
|
||||
|
||||
void acpi_db_find_references(char *object_arg);
|
||||
acpi_status acpi_db_sleep(char *object_arg);
|
||||
|
||||
void acpi_db_display_locks(void);
|
||||
|
||||
@ -121,15 +108,51 @@ void acpi_db_display_resources(char *object_arg);
|
||||
|
||||
ACPI_HW_DEPENDENT_RETURN_VOID(void acpi_db_display_gpes(void))
|
||||
|
||||
void acpi_db_check_integrity(void);
|
||||
void acpi_db_display_handlers(void);
|
||||
|
||||
ACPI_HW_DEPENDENT_RETURN_VOID(void
|
||||
acpi_db_generate_gpe(char *gpe_arg,
|
||||
char *block_arg))
|
||||
|
||||
/*
|
||||
* dbmethod - control method commands
|
||||
*/
|
||||
void
|
||||
acpi_db_set_method_breakpoint(char *location,
|
||||
struct acpi_walk_state *walk_state,
|
||||
union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_set_method_call_breakpoint(union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_set_method_data(char *type_arg, char *index_arg, char *value_arg);
|
||||
|
||||
acpi_status acpi_db_disassemble_method(char *name);
|
||||
|
||||
void acpi_db_disassemble_aml(char *statements, union acpi_parse_object *op);
|
||||
|
||||
void acpi_db_batch_execute(char *count_arg);
|
||||
|
||||
/*
|
||||
* dbnames - namespace commands
|
||||
*/
|
||||
void acpi_db_set_scope(char *name);
|
||||
|
||||
void acpi_db_dump_namespace(char *start_arg, char *depth_arg);
|
||||
|
||||
void acpi_db_dump_namespace_by_owner(char *owner_arg, char *depth_arg);
|
||||
|
||||
acpi_status acpi_db_find_name_in_namespace(char *name_arg);
|
||||
|
||||
void acpi_db_check_predefined_names(void);
|
||||
|
||||
void acpi_db_batch_execute(void);
|
||||
acpi_status
|
||||
acpi_db_display_objects(char *obj_type_arg, char *display_count_arg);
|
||||
|
||||
void acpi_db_check_integrity(void);
|
||||
|
||||
void acpi_db_find_references(char *object_arg);
|
||||
|
||||
void acpi_db_get_bus_info(void);
|
||||
|
||||
/*
|
||||
* dbdisply - debug display commands
|
||||
@ -161,7 +184,8 @@ acpi_db_display_argument_object(union acpi_operand_object *obj_desc,
|
||||
/*
|
||||
* dbexec - debugger control method execution
|
||||
*/
|
||||
void acpi_db_execute(char *name, char **args, u32 flags);
|
||||
void
|
||||
acpi_db_execute(char *name, char **args, acpi_object_type * types, u32 flags);
|
||||
|
||||
void
|
||||
acpi_db_create_execution_threads(char *num_threads_arg,
|
||||
@ -175,7 +199,8 @@ u32 acpi_db_get_cache_info(struct acpi_memory_list *cache);
|
||||
* dbfileio - Debugger file I/O commands
|
||||
*/
|
||||
acpi_object_type
|
||||
acpi_db_match_argument(char *user_argument, struct argument_info *arguments);
|
||||
acpi_db_match_argument(char *user_argument,
|
||||
struct acpi_db_argument_info *arguments);
|
||||
|
||||
void acpi_db_close_debug_file(void);
|
||||
|
||||
@ -208,6 +233,11 @@ acpi_db_command_dispatch(char *input_buffer,
|
||||
|
||||
void ACPI_SYSTEM_XFACE acpi_db_execute_thread(void *context);
|
||||
|
||||
acpi_status acpi_db_user_commands(char prompt, union acpi_parse_object *op);
|
||||
|
||||
char *acpi_db_get_next_token(char *string,
|
||||
char **next, acpi_object_type * return_type);
|
||||
|
||||
/*
|
||||
* dbstats - Generation and display of ACPI table statistics
|
||||
*/
|
||||
|
||||
@ -309,10 +309,13 @@ acpi_ds_obj_stack_push(void *object, struct acpi_walk_state *walk_state);
|
||||
acpi_status
|
||||
acpi_ds_obj_stack_pop(u32 pop_count, struct acpi_walk_state *walk_state);
|
||||
|
||||
struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id, union acpi_parse_object
|
||||
*origin, union acpi_operand_object
|
||||
*mth_desc, struct acpi_thread_state
|
||||
*thread);
|
||||
struct acpi_walk_state * acpi_ds_create_walk_state(acpi_owner_id owner_id,
|
||||
union acpi_parse_object
|
||||
*origin,
|
||||
union acpi_operand_object
|
||||
*mth_desc,
|
||||
struct acpi_thread_state
|
||||
*thread);
|
||||
|
||||
acpi_status
|
||||
acpi_ds_init_aml_walk(struct acpi_walk_state *walk_state,
|
||||
|
||||
@ -84,9 +84,11 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info);
|
||||
|
||||
acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
|
||||
|
||||
acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
acpi_status
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
|
||||
acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
acpi_status
|
||||
acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
|
||||
struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
|
||||
u32 gpe_number);
|
||||
|
||||
@ -70,7 +70,7 @@
|
||||
|
||||
/*
|
||||
* Enable "slack" in the AML interpreter? Default is FALSE, and the
|
||||
* interpreter strictly follows the ACPI specification. Setting to TRUE
|
||||
* interpreter strictly follows the ACPI specification. Setting to TRUE
|
||||
* allows the interpreter to ignore certain errors and/or bad AML constructs.
|
||||
*
|
||||
* Currently, these features are enabled by this flag:
|
||||
@ -153,26 +153,6 @@ u8 acpi_gbl_reduced_hardware;
|
||||
|
||||
ACPI_EXTERN u8 ACPI_INIT_GLOBAL(acpi_gbl_no_resource_disassembly, FALSE);
|
||||
|
||||
/*****************************************************************************
|
||||
*
|
||||
* Debug support
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/* Procedure nesting level for debug output */
|
||||
|
||||
extern u32 acpi_gbl_nesting_level;
|
||||
|
||||
ACPI_EXTERN u32 acpi_gpe_count;
|
||||
ACPI_EXTERN u32 acpi_fixed_event_count[ACPI_NUM_FIXED_EVENTS];
|
||||
|
||||
/* Support for dynamic control method tracing mechanism */
|
||||
|
||||
ACPI_EXTERN u32 acpi_gbl_original_dbg_level;
|
||||
ACPI_EXTERN u32 acpi_gbl_original_dbg_layer;
|
||||
ACPI_EXTERN u32 acpi_gbl_trace_dbg_level;
|
||||
ACPI_EXTERN u32 acpi_gbl_trace_dbg_layer;
|
||||
|
||||
/*****************************************************************************
|
||||
*
|
||||
* ACPI Table globals
|
||||
@ -259,15 +239,6 @@ ACPI_EXTERN acpi_spinlock acpi_gbl_hardware_lock; /* For ACPI H/W except GPE reg
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
|
||||
|
||||
/* Lists for tracking memory allocations */
|
||||
|
||||
ACPI_EXTERN struct acpi_memory_list *acpi_gbl_global_list;
|
||||
ACPI_EXTERN struct acpi_memory_list *acpi_gbl_ns_node_list;
|
||||
ACPI_EXTERN u8 acpi_gbl_display_final_mem_stats;
|
||||
#endif
|
||||
|
||||
/* Object caches */
|
||||
|
||||
ACPI_EXTERN acpi_cache_t *acpi_gbl_namespace_cache;
|
||||
@ -326,6 +297,15 @@ extern const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS];
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
|
||||
|
||||
/* Lists for tracking memory allocations */
|
||||
|
||||
ACPI_EXTERN struct acpi_memory_list *acpi_gbl_global_list;
|
||||
ACPI_EXTERN struct acpi_memory_list *acpi_gbl_ns_node_list;
|
||||
ACPI_EXTERN u8 acpi_gbl_display_final_mem_stats;
|
||||
#endif
|
||||
|
||||
/*****************************************************************************
|
||||
*
|
||||
* Namespace globals
|
||||
@ -396,11 +376,33 @@ ACPI_EXTERN struct acpi_gpe_block_info
|
||||
#if (!ACPI_REDUCED_HARDWARE)
|
||||
|
||||
ACPI_EXTERN u8 acpi_gbl_all_gpes_initialized;
|
||||
ACPI_EXTERN ACPI_GBL_EVENT_HANDLER acpi_gbl_global_event_handler;
|
||||
ACPI_EXTERN acpi_gbl_event_handler acpi_gbl_global_event_handler;
|
||||
ACPI_EXTERN void *acpi_gbl_global_event_handler_context;
|
||||
|
||||
#endif /* !ACPI_REDUCED_HARDWARE */
|
||||
|
||||
/*****************************************************************************
|
||||
*
|
||||
* Debug support
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/* Procedure nesting level for debug output */
|
||||
|
||||
extern u32 acpi_gbl_nesting_level;
|
||||
|
||||
/* Event counters */
|
||||
|
||||
ACPI_EXTERN u32 acpi_gpe_count;
|
||||
ACPI_EXTERN u32 acpi_fixed_event_count[ACPI_NUM_FIXED_EVENTS];
|
||||
|
||||
/* Support for dynamic control method tracing mechanism */
|
||||
|
||||
ACPI_EXTERN u32 acpi_gbl_original_dbg_level;
|
||||
ACPI_EXTERN u32 acpi_gbl_original_dbg_layer;
|
||||
ACPI_EXTERN u32 acpi_gbl_trace_dbg_level;
|
||||
ACPI_EXTERN u32 acpi_gbl_trace_dbg_layer;
|
||||
|
||||
/*****************************************************************************
|
||||
*
|
||||
* Debugger globals
|
||||
@ -426,10 +428,11 @@ ACPI_EXTERN u8 acpi_gbl_db_opt_stats;
|
||||
ACPI_EXTERN u8 acpi_gbl_db_opt_ini_methods;
|
||||
|
||||
ACPI_EXTERN char *acpi_gbl_db_args[ACPI_DEBUGGER_MAX_ARGS];
|
||||
ACPI_EXTERN char acpi_gbl_db_line_buf[80];
|
||||
ACPI_EXTERN char acpi_gbl_db_parsed_buf[80];
|
||||
ACPI_EXTERN char acpi_gbl_db_scope_buf[40];
|
||||
ACPI_EXTERN char acpi_gbl_db_debug_filename[40];
|
||||
ACPI_EXTERN acpi_object_type acpi_gbl_db_arg_types[ACPI_DEBUGGER_MAX_ARGS];
|
||||
ACPI_EXTERN char acpi_gbl_db_line_buf[ACPI_DB_LINE_BUFFER_SIZE];
|
||||
ACPI_EXTERN char acpi_gbl_db_parsed_buf[ACPI_DB_LINE_BUFFER_SIZE];
|
||||
ACPI_EXTERN char acpi_gbl_db_scope_buf[80];
|
||||
ACPI_EXTERN char acpi_gbl_db_debug_filename[80];
|
||||
ACPI_EXTERN u8 acpi_gbl_db_output_to_file;
|
||||
ACPI_EXTERN char *acpi_gbl_db_buffer;
|
||||
ACPI_EXTERN char *acpi_gbl_db_filename;
|
||||
|
||||
@ -262,10 +262,10 @@ struct acpi_create_field_info {
|
||||
};
|
||||
|
||||
typedef
|
||||
acpi_status(*ACPI_INTERNAL_METHOD) (struct acpi_walk_state * walk_state);
|
||||
acpi_status(*acpi_internal_method) (struct acpi_walk_state * walk_state);
|
||||
|
||||
/*
|
||||
* Bitmapped ACPI types. Used internally only
|
||||
* Bitmapped ACPI types. Used internally only
|
||||
*/
|
||||
#define ACPI_BTYPE_ANY 0x00000000
|
||||
#define ACPI_BTYPE_INTEGER 0x00000001
|
||||
@ -486,8 +486,10 @@ struct acpi_gpe_device_info {
|
||||
struct acpi_namespace_node *gpe_device;
|
||||
};
|
||||
|
||||
typedef acpi_status(*acpi_gpe_callback) (struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
struct acpi_gpe_block_info *gpe_block, void *context);
|
||||
typedef acpi_status(*acpi_gpe_callback) (struct acpi_gpe_xrupt_info *
|
||||
gpe_xrupt_info,
|
||||
struct acpi_gpe_block_info *gpe_block,
|
||||
void *context);
|
||||
|
||||
/* Information about each particular fixed event */
|
||||
|
||||
@ -582,7 +584,7 @@ struct acpi_pscope_state {
|
||||
};
|
||||
|
||||
/*
|
||||
* Thread state - one per thread across multiple walk states. Multiple walk
|
||||
* Thread state - one per thread across multiple walk states. Multiple walk
|
||||
* states are created when there are nested control methods executing.
|
||||
*/
|
||||
struct acpi_thread_state {
|
||||
@ -645,7 +647,7 @@ union acpi_generic_state {
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
typedef acpi_status(*ACPI_EXECUTE_OP) (struct acpi_walk_state * walk_state);
|
||||
typedef acpi_status(*acpi_execute_op) (struct acpi_walk_state * walk_state);
|
||||
|
||||
/* Address Range info block */
|
||||
|
||||
@ -1031,6 +1033,7 @@ struct acpi_db_method_info {
|
||||
acpi_handle method;
|
||||
acpi_handle main_thread_gate;
|
||||
acpi_handle thread_complete_gate;
|
||||
acpi_handle info_gate;
|
||||
acpi_thread_id *threads;
|
||||
u32 num_threads;
|
||||
u32 num_created;
|
||||
@ -1041,6 +1044,7 @@ struct acpi_db_method_info {
|
||||
u32 num_loops;
|
||||
char pathname[128];
|
||||
char **args;
|
||||
acpi_object_type *types;
|
||||
|
||||
/*
|
||||
* Arguments to be passed to method for the command
|
||||
|
||||
@ -84,29 +84,29 @@
|
||||
|
||||
/* These macros reverse the bytes during the move, converting little-endian to big endian */
|
||||
|
||||
/* Big Endian <== Little Endian */
|
||||
/* Hi...Lo Lo...Hi */
|
||||
/* Big Endian <== Little Endian */
|
||||
/* Hi...Lo Lo...Hi */
|
||||
/* 16-bit source, 16/32/64 destination */
|
||||
|
||||
#define ACPI_MOVE_16_TO_16(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[1];\
|
||||
(( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[0];}
|
||||
(( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[0];}
|
||||
|
||||
#define ACPI_MOVE_16_TO_32(d, s) {(*(u32 *)(void *)(d))=0;\
|
||||
((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\
|
||||
((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];}
|
||||
((u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\
|
||||
((u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];}
|
||||
|
||||
#define ACPI_MOVE_16_TO_64(d, s) {(*(u64 *)(void *)(d))=0;\
|
||||
((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\
|
||||
((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];}
|
||||
((u8 *)(void *)(d))[6] = ((u8 *)(void *)(s))[1];\
|
||||
((u8 *)(void *)(d))[7] = ((u8 *)(void *)(s))[0];}
|
||||
|
||||
/* 32-bit source, 16/32/64 destination */
|
||||
|
||||
#define ACPI_MOVE_32_TO_16(d, s) ACPI_MOVE_16_TO_16(d, s) /* Truncate to 16 */
|
||||
|
||||
#define ACPI_MOVE_32_TO_32(d, s) {(( u8 *)(void *)(d))[0] = ((u8 *)(void *)(s))[3];\
|
||||
(( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[2];\
|
||||
(( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\
|
||||
(( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];}
|
||||
(( u8 *)(void *)(d))[1] = ((u8 *)(void *)(s))[2];\
|
||||
(( u8 *)(void *)(d))[2] = ((u8 *)(void *)(s))[1];\
|
||||
(( u8 *)(void *)(d))[3] = ((u8 *)(void *)(s))[0];}
|
||||
|
||||
#define ACPI_MOVE_32_TO_64(d, s) {(*(u64 *)(void *)(d))=0;\
|
||||
((u8 *)(void *)(d))[4] = ((u8 *)(void *)(s))[3];\
|
||||
@ -196,24 +196,12 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Macros based on machine integer width */
|
||||
|
||||
#if ACPI_MACHINE_WIDTH == 32
|
||||
#define ACPI_MOVE_SIZE_TO_16(d, s) ACPI_MOVE_32_TO_16(d, s)
|
||||
|
||||
#elif ACPI_MACHINE_WIDTH == 64
|
||||
#define ACPI_MOVE_SIZE_TO_16(d, s) ACPI_MOVE_64_TO_16(d, s)
|
||||
|
||||
#else
|
||||
#error unknown ACPI_MACHINE_WIDTH
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Fast power-of-two math macros for non-optimized compilers
|
||||
*/
|
||||
#define _ACPI_DIV(value, power_of2) ((u32) ((value) >> (power_of2)))
|
||||
#define _ACPI_MUL(value, power_of2) ((u32) ((value) << (power_of2)))
|
||||
#define _ACPI_MOD(value, divisor) ((u32) ((value) & ((divisor) -1)))
|
||||
#define _ACPI_DIV(value, power_of2) ((u32) ((value) >> (power_of2)))
|
||||
#define _ACPI_MUL(value, power_of2) ((u32) ((value) << (power_of2)))
|
||||
#define _ACPI_MOD(value, divisor) ((u32) ((value) & ((divisor) -1)))
|
||||
|
||||
#define ACPI_DIV_2(a) _ACPI_DIV(a, 1)
|
||||
#define ACPI_MUL_2(a) _ACPI_MUL(a, 1)
|
||||
@ -238,12 +226,12 @@
|
||||
/*
|
||||
* Rounding macros (Power of two boundaries only)
|
||||
*/
|
||||
#define ACPI_ROUND_DOWN(value, boundary) (((acpi_size)(value)) & \
|
||||
(~(((acpi_size) boundary)-1)))
|
||||
#define ACPI_ROUND_DOWN(value, boundary) (((acpi_size)(value)) & \
|
||||
(~(((acpi_size) boundary)-1)))
|
||||
|
||||
#define ACPI_ROUND_UP(value, boundary) ((((acpi_size)(value)) + \
|
||||
(((acpi_size) boundary)-1)) & \
|
||||
(~(((acpi_size) boundary)-1)))
|
||||
#define ACPI_ROUND_UP(value, boundary) ((((acpi_size)(value)) + \
|
||||
(((acpi_size) boundary)-1)) & \
|
||||
(~(((acpi_size) boundary)-1)))
|
||||
|
||||
/* Note: sizeof(acpi_size) evaluates to either 4 or 8 (32- vs 64-bit mode) */
|
||||
|
||||
@ -264,7 +252,7 @@
|
||||
|
||||
#define ACPI_ROUND_UP_TO(value, boundary) (((value) + ((boundary)-1)) / (boundary))
|
||||
|
||||
#define ACPI_IS_MISALIGNED(value) (((acpi_size) value) & (sizeof(acpi_size)-1))
|
||||
#define ACPI_IS_MISALIGNED(value) (((acpi_size) value) & (sizeof(acpi_size)-1))
|
||||
|
||||
/*
|
||||
* Bitmask creation
|
||||
@ -355,7 +343,6 @@
|
||||
* Ascii error messages can be configured out
|
||||
*/
|
||||
#ifndef ACPI_NO_ERROR_MESSAGES
|
||||
|
||||
/*
|
||||
* Error reporting. Callers module and line number are inserted by AE_INFO,
|
||||
* the plist contains a set of parens to allow variable-length lists.
|
||||
@ -375,18 +362,15 @@
|
||||
#define ACPI_WARN_PREDEFINED(plist)
|
||||
#define ACPI_INFO_PREDEFINED(plist)
|
||||
|
||||
#endif /* ACPI_NO_ERROR_MESSAGES */
|
||||
#endif /* ACPI_NO_ERROR_MESSAGES */
|
||||
|
||||
/*
|
||||
* Debug macros that are conditionally compiled
|
||||
*/
|
||||
#ifdef ACPI_DEBUG_OUTPUT
|
||||
|
||||
/*
|
||||
* Function entry tracing
|
||||
*/
|
||||
#ifdef CONFIG_ACPI_DEBUG_FUNC_TRACE
|
||||
|
||||
#define ACPI_FUNCTION_TRACE(a) ACPI_FUNCTION_NAME(a) \
|
||||
acpi_ut_trace(ACPI_DEBUG_PARAMETERS)
|
||||
#define ACPI_FUNCTION_TRACE_PTR(a, b) ACPI_FUNCTION_NAME(a) \
|
||||
@ -464,45 +448,19 @@
|
||||
|
||||
#endif /* ACPI_SIMPLE_RETURN_MACROS */
|
||||
|
||||
#else /* !CONFIG_ACPI_DEBUG_FUNC_TRACE */
|
||||
|
||||
#define ACPI_FUNCTION_TRACE(a)
|
||||
#define ACPI_FUNCTION_TRACE_PTR(a,b)
|
||||
#define ACPI_FUNCTION_TRACE_U32(a,b)
|
||||
#define ACPI_FUNCTION_TRACE_STR(a,b)
|
||||
#define ACPI_FUNCTION_EXIT
|
||||
#define ACPI_FUNCTION_STATUS_EXIT(s)
|
||||
#define ACPI_FUNCTION_VALUE_EXIT(s)
|
||||
#define ACPI_FUNCTION_TRACE(a)
|
||||
#define ACPI_FUNCTION_ENTRY()
|
||||
|
||||
#define return_VOID return
|
||||
#define return_ACPI_STATUS(s) return(s)
|
||||
#define return_VALUE(s) return(s)
|
||||
#define return_UINT8(s) return(s)
|
||||
#define return_UINT32(s) return(s)
|
||||
#define return_PTR(s) return(s)
|
||||
|
||||
#endif /* CONFIG_ACPI_DEBUG_FUNC_TRACE */
|
||||
|
||||
/* Conditional execution */
|
||||
|
||||
#define ACPI_DEBUG_EXEC(a) a
|
||||
#define ACPI_NORMAL_EXEC(a)
|
||||
|
||||
#define ACPI_DEBUG_DEFINE(a) a;
|
||||
#define ACPI_DEBUG_ONLY_MEMBERS(a) a;
|
||||
#define _VERBOSE_STRUCTURES
|
||||
|
||||
/* Stack and buffer dumping */
|
||||
/* Various object display routines for debug */
|
||||
|
||||
#define ACPI_DUMP_STACK_ENTRY(a) acpi_ex_dump_operand((a), 0)
|
||||
#define ACPI_DUMP_OPERANDS(a, b, c) acpi_ex_dump_operands(a, b, c)
|
||||
|
||||
#define ACPI_DUMP_OPERANDS(a, b ,c) acpi_ex_dump_operands(a, b, c)
|
||||
#define ACPI_DUMP_ENTRY(a, b) acpi_ns_dump_entry (a, b)
|
||||
#define ACPI_DUMP_PATHNAME(a, b, c, d) acpi_ns_dump_pathname(a, b, c, d)
|
||||
#define ACPI_DUMP_RESOURCE_LIST(a) acpi_rs_dump_resource_list(a)
|
||||
#define ACPI_DUMP_BUFFER(a, b) acpi_ut_dump_buffer((u8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT)
|
||||
#define ACPI_DUMP_BUFFER(a, b) acpi_ut_debug_dump_buffer((u8 *) a, b, DB_BYTE_DISPLAY, _COMPONENT)
|
||||
|
||||
#else
|
||||
/*
|
||||
@ -510,25 +468,23 @@
|
||||
* leaving no executable debug code!
|
||||
*/
|
||||
#define ACPI_DEBUG_EXEC(a)
|
||||
#define ACPI_NORMAL_EXEC(a) a;
|
||||
|
||||
#define ACPI_DEBUG_DEFINE(a) do { } while(0)
|
||||
#define ACPI_DEBUG_ONLY_MEMBERS(a) do { } while(0)
|
||||
#define ACPI_FUNCTION_TRACE(a) do { } while(0)
|
||||
#define ACPI_FUNCTION_TRACE_PTR(a, b) do { } while(0)
|
||||
#define ACPI_FUNCTION_TRACE_U32(a, b) do { } while(0)
|
||||
#define ACPI_FUNCTION_TRACE_STR(a, b) do { } while(0)
|
||||
#define ACPI_FUNCTION_EXIT do { } while(0)
|
||||
#define ACPI_FUNCTION_STATUS_EXIT(s) do { } while(0)
|
||||
#define ACPI_FUNCTION_VALUE_EXIT(s) do { } while(0)
|
||||
#define ACPI_FUNCTION_ENTRY() do { } while(0)
|
||||
#define ACPI_DUMP_STACK_ENTRY(a) do { } while(0)
|
||||
#define ACPI_DUMP_OPERANDS(a, b, c) do { } while(0)
|
||||
#define ACPI_DUMP_ENTRY(a, b) do { } while(0)
|
||||
#define ACPI_DUMP_TABLES(a, b) do { } while(0)
|
||||
#define ACPI_DUMP_PATHNAME(a, b, c, d) do { } while(0)
|
||||
#define ACPI_DUMP_RESOURCE_LIST(a) do { } while(0)
|
||||
#define ACPI_DUMP_BUFFER(a, b) do { } while(0)
|
||||
#define ACPI_DEBUG_ONLY_MEMBERS(a)
|
||||
#define ACPI_FUNCTION_TRACE(a)
|
||||
#define ACPI_FUNCTION_TRACE_PTR(a, b)
|
||||
#define ACPI_FUNCTION_TRACE_U32(a, b)
|
||||
#define ACPI_FUNCTION_TRACE_STR(a, b)
|
||||
#define ACPI_FUNCTION_EXIT
|
||||
#define ACPI_FUNCTION_STATUS_EXIT(s)
|
||||
#define ACPI_FUNCTION_VALUE_EXIT(s)
|
||||
#define ACPI_FUNCTION_ENTRY()
|
||||
#define ACPI_DUMP_STACK_ENTRY(a)
|
||||
#define ACPI_DUMP_OPERANDS(a, b, c)
|
||||
#define ACPI_DUMP_ENTRY(a, b)
|
||||
#define ACPI_DUMP_TABLES(a, b)
|
||||
#define ACPI_DUMP_PATHNAME(a, b, c, d)
|
||||
#define ACPI_DUMP_BUFFER(a, b)
|
||||
#define ACPI_DEBUG_PRINT(pl)
|
||||
#define ACPI_DEBUG_PRINT_RAW(pl)
|
||||
|
||||
#define return_VOID return
|
||||
#define return_ACPI_STATUS(s) return(s)
|
||||
@ -556,18 +512,6 @@
|
||||
#define ACPI_DEBUGGER_EXEC(a)
|
||||
#endif
|
||||
|
||||
#ifdef ACPI_DEBUG_OUTPUT
|
||||
/*
|
||||
* 1) Set name to blanks
|
||||
* 2) Copy the object name
|
||||
*/
|
||||
#define ACPI_ADD_OBJECT_NAME(a,b) ACPI_MEMSET (a->common.name, ' ', sizeof (a->common.name));\
|
||||
ACPI_STRNCPY (a->common.name, acpi_gbl_ns_type_names[b], sizeof (a->common.name))
|
||||
#else
|
||||
|
||||
#define ACPI_ADD_OBJECT_NAME(a,b)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Memory allocation tracking (DEBUG ONLY)
|
||||
*/
|
||||
@ -578,13 +522,13 @@
|
||||
/* Memory allocation */
|
||||
|
||||
#ifndef ACPI_ALLOCATE
|
||||
#define ACPI_ALLOCATE(a) acpi_ut_allocate((acpi_size)(a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_ALLOCATE(a) acpi_ut_allocate((acpi_size) (a), ACPI_MEM_PARAMETERS)
|
||||
#endif
|
||||
#ifndef ACPI_ALLOCATE_ZEROED
|
||||
#define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed((acpi_size)(a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed((acpi_size) (a), ACPI_MEM_PARAMETERS)
|
||||
#endif
|
||||
#ifndef ACPI_FREE
|
||||
#define ACPI_FREE(a) acpio_os_free(a)
|
||||
#define ACPI_FREE(a) acpi_os_free(a)
|
||||
#endif
|
||||
#define ACPI_MEM_TRACKING(a)
|
||||
|
||||
@ -592,16 +536,25 @@
|
||||
|
||||
/* Memory allocation */
|
||||
|
||||
#define ACPI_ALLOCATE(a) acpi_ut_allocate_and_track((acpi_size)(a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed_and_track((acpi_size)(a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_ALLOCATE(a) acpi_ut_allocate_and_track((acpi_size) (a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_ALLOCATE_ZEROED(a) acpi_ut_allocate_zeroed_and_track((acpi_size) (a), ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_FREE(a) acpi_ut_free_and_track(a, ACPI_MEM_PARAMETERS)
|
||||
#define ACPI_MEM_TRACKING(a) a
|
||||
|
||||
#endif /* ACPI_DBG_TRACK_ALLOCATIONS */
|
||||
|
||||
/* Preemption point */
|
||||
#ifndef ACPI_PREEMPTION_POINT
|
||||
#define ACPI_PREEMPTION_POINT() /* no preemption */
|
||||
#endif
|
||||
/*
|
||||
* Macros used for ACPICA utilities only
|
||||
*/
|
||||
|
||||
/* Generate a UUID */
|
||||
|
||||
#define ACPI_INIT_UUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
|
||||
(a) & 0xFF, ((a) >> 8) & 0xFF, ((a) >> 16) & 0xFF, ((a) >> 24) & 0xFF, \
|
||||
(b) & 0xFF, ((b) >> 8) & 0xFF, \
|
||||
(c) & 0xFF, ((c) >> 8) & 0xFF, \
|
||||
(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)
|
||||
|
||||
#define ACPI_IS_OCTAL_DIGIT(d) (((char)(d) >= '0') && ((char)(d) <= '7'))
|
||||
|
||||
#endif /* ACMACROS_H */
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Name: acobject.h - Definition of union acpi_operand_object (Internal object only)
|
||||
@ -179,7 +178,7 @@ struct acpi_object_method {
|
||||
union acpi_operand_object *mutex;
|
||||
u8 *aml_start;
|
||||
union {
|
||||
ACPI_INTERNAL_METHOD implementation;
|
||||
acpi_internal_method implementation;
|
||||
union acpi_operand_object *handler;
|
||||
} dispatch;
|
||||
|
||||
@ -198,7 +197,7 @@ struct acpi_object_method {
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Objects that can be notified. All share a common notify_info area.
|
||||
* Objects that can be notified. All share a common notify_info area.
|
||||
*
|
||||
*****************************************************************************/
|
||||
|
||||
@ -235,7 +234,7 @@ ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_NOTIFY_INFO};
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Fields. All share a common header/info field.
|
||||
* Fields. All share a common header/info field.
|
||||
*
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
@ -54,7 +54,7 @@
|
||||
#define _UNK 0x6B
|
||||
|
||||
/*
|
||||
* Reserved ASCII characters. Do not use any of these for
|
||||
* Reserved ASCII characters. Do not use any of these for
|
||||
* internal opcodes, since they are used to differentiate
|
||||
* name strings from AML opcodes
|
||||
*/
|
||||
@ -63,7 +63,7 @@
|
||||
#define _PFX 0x6D
|
||||
|
||||
/*
|
||||
* All AML opcodes and the parse-time arguments for each. Used by the AML
|
||||
* All AML opcodes and the parse-time arguments for each. Used by the AML
|
||||
* parser Each list is compressed into a 32-bit number and stored in the
|
||||
* master opcode table (in psopcode.c).
|
||||
*/
|
||||
@ -193,7 +193,7 @@
|
||||
#define ARGP_ZERO_OP ARG_NONE
|
||||
|
||||
/*
|
||||
* All AML opcodes and the runtime arguments for each. Used by the AML
|
||||
* All AML opcodes and the runtime arguments for each. Used by the AML
|
||||
* interpreter Each list is compressed into a 32-bit number and stored
|
||||
* in the master opcode table (in psopcode.c).
|
||||
*
|
||||
|
||||
@ -150,8 +150,7 @@ u8 acpi_ps_has_completed_scope(struct acpi_parse_state *parser_state);
|
||||
|
||||
void
|
||||
acpi_ps_pop_scope(struct acpi_parse_state *parser_state,
|
||||
union acpi_parse_object **op,
|
||||
u32 * arg_list, u32 * arg_count);
|
||||
union acpi_parse_object **op, u32 *arg_list, u32 *arg_count);
|
||||
|
||||
acpi_status
|
||||
acpi_ps_push_scope(struct acpi_parse_state *parser_state,
|
||||
|
||||
@ -150,8 +150,7 @@ enum acpi_return_package_types {
|
||||
* is saved here (rather than in a separate table) in order to minimize the
|
||||
* overall size of the stored data.
|
||||
*/
|
||||
static const union acpi_predefined_info predefined_names[] =
|
||||
{
|
||||
static const union acpi_predefined_info predefined_names[] = {
|
||||
{{"_AC0", 0, ACPI_RTYPE_INTEGER}},
|
||||
{{"_AC1", 0, ACPI_RTYPE_INTEGER}},
|
||||
{{"_AC2", 0, ACPI_RTYPE_INTEGER}},
|
||||
@ -538,7 +537,8 @@ static const union acpi_predefined_info predefined_names[] =
|
||||
|
||||
/* Acpi 1.0 defined _WAK with no return value. Later, it was changed to return a package */
|
||||
|
||||
{{"_WAK", 1, ACPI_RTYPE_NONE | ACPI_RTYPE_INTEGER | ACPI_RTYPE_PACKAGE}},
|
||||
{{"_WAK", 1,
|
||||
ACPI_RTYPE_NONE | ACPI_RTYPE_INTEGER | ACPI_RTYPE_PACKAGE}},
|
||||
{{{ACPI_PTYPE1_FIXED, ACPI_RTYPE_INTEGER, 2,0}, 0,0}}, /* Fixed-length (2 Int), but is optional */
|
||||
|
||||
/* _WDG/_WED are MS extensions defined by "Windows Instrumentation" */
|
||||
@ -551,11 +551,12 @@ static const union acpi_predefined_info predefined_names[] =
|
||||
};
|
||||
|
||||
#if 0
|
||||
|
||||
/* This is an internally implemented control method, no need to check */
|
||||
{{"_OSI", 1, ACPI_RTYPE_INTEGER}},
|
||||
{ {
|
||||
"_OSI", 1, ACPI_RTYPE_INTEGER}},
|
||||
|
||||
/* TBD: */
|
||||
|
||||
_PRT - currently ignore reversed entries. attempt to fix here?
|
||||
think about possibly fixing package elements like _BIF, etc.
|
||||
#endif
|
||||
|
||||
@ -53,7 +53,7 @@
|
||||
****************************************************************************/
|
||||
|
||||
/*
|
||||
* Walk state - current state of a parse tree walk. Used for both a leisurely
|
||||
* Walk state - current state of a parse tree walk. Used for both a leisurely
|
||||
* stroll through the tree (for whatever reason), and for control method
|
||||
* execution.
|
||||
*/
|
||||
|
||||
@ -69,6 +69,22 @@ extern const char *acpi_gbl_siz_decode[];
|
||||
extern const char *acpi_gbl_trs_decode[];
|
||||
extern const char *acpi_gbl_ttp_decode[];
|
||||
extern const char *acpi_gbl_typ_decode[];
|
||||
extern const char *acpi_gbl_ppc_decode[];
|
||||
extern const char *acpi_gbl_ior_decode[];
|
||||
extern const char *acpi_gbl_dts_decode[];
|
||||
extern const char *acpi_gbl_ct_decode[];
|
||||
extern const char *acpi_gbl_sbt_decode[];
|
||||
extern const char *acpi_gbl_am_decode[];
|
||||
extern const char *acpi_gbl_sm_decode[];
|
||||
extern const char *acpi_gbl_wm_decode[];
|
||||
extern const char *acpi_gbl_cph_decode[];
|
||||
extern const char *acpi_gbl_cpo_decode[];
|
||||
extern const char *acpi_gbl_dp_decode[];
|
||||
extern const char *acpi_gbl_ed_decode[];
|
||||
extern const char *acpi_gbl_bpb_decode[];
|
||||
extern const char *acpi_gbl_sb_decode[];
|
||||
extern const char *acpi_gbl_fc_decode[];
|
||||
extern const char *acpi_gbl_pt_decode[];
|
||||
#endif
|
||||
|
||||
/* Types for Resource descriptor entries */
|
||||
@ -79,14 +95,14 @@ extern const char *acpi_gbl_typ_decode[];
|
||||
#define ACPI_SMALL_VARIABLE_LENGTH 3
|
||||
|
||||
typedef
|
||||
acpi_status(*acpi_walk_aml_callback) (u8 * aml,
|
||||
acpi_status(*acpi_walk_aml_callback) (u8 *aml,
|
||||
u32 length,
|
||||
u32 offset,
|
||||
u8 resource_index, void **context);
|
||||
|
||||
typedef
|
||||
acpi_status(*acpi_pkg_callback) (u8 object_type,
|
||||
union acpi_operand_object * source_object,
|
||||
union acpi_operand_object *source_object,
|
||||
union acpi_generic_state * state,
|
||||
void *context);
|
||||
|
||||
@ -202,7 +218,9 @@ extern const u8 _acpi_ctype[];
|
||||
#define ACPI_IS_PRINT(c) (_acpi_ctype[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP | _ACPI_DI | _ACPI_SP | _ACPI_PU))
|
||||
#define ACPI_IS_ALPHA(c) (_acpi_ctype[(unsigned char)(c)] & (_ACPI_LO | _ACPI_UP))
|
||||
|
||||
#endif /* ACPI_USE_SYSTEM_CLIBRARY */
|
||||
#endif /* !ACPI_USE_SYSTEM_CLIBRARY */
|
||||
|
||||
#define ACPI_IS_ASCII(c) ((c) < 0x80)
|
||||
|
||||
/*
|
||||
* utcopy - Object construction and conversion interfaces
|
||||
@ -210,11 +228,11 @@ extern const u8 _acpi_ctype[];
|
||||
acpi_status
|
||||
acpi_ut_build_simple_object(union acpi_operand_object *obj,
|
||||
union acpi_object *user_obj,
|
||||
u8 * data_space, u32 * buffer_space_used);
|
||||
u8 *data_space, u32 *buffer_space_used);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_build_package_object(union acpi_operand_object *obj,
|
||||
u8 * buffer, u32 * space_used);
|
||||
u8 *buffer, u32 *space_used);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *obj,
|
||||
@ -287,9 +305,10 @@ acpi_ut_ptr_exit(u32 line_number,
|
||||
const char *function_name,
|
||||
const char *module_name, u32 component_id, u8 *ptr);
|
||||
|
||||
void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id);
|
||||
void
|
||||
acpi_ut_debug_dump_buffer(u8 *buffer, u32 count, u32 display, u32 component_id);
|
||||
|
||||
void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display);
|
||||
void acpi_ut_dump_buffer(u8 *buffer, u32 count, u32 display, u32 offset);
|
||||
|
||||
void acpi_ut_report_error(char *module_name, u32 line_number);
|
||||
|
||||
@ -337,15 +356,19 @@ acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
|
||||
*/
|
||||
acpi_status
|
||||
acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
|
||||
struct acpica_device_id **return_id);
|
||||
struct acpi_pnp_device_id ** return_id);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
|
||||
struct acpica_device_id **return_id);
|
||||
struct acpi_pnp_device_id ** return_id);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_execute_SUB(struct acpi_namespace_node *device_node,
|
||||
struct acpi_pnp_device_id **return_id);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
|
||||
struct acpica_device_id_list **return_cid_list);
|
||||
struct acpi_pnp_device_id_list ** return_cid_list);
|
||||
|
||||
/*
|
||||
* utlock - reader/writer locks
|
||||
@ -479,15 +502,19 @@ acpi_ut_walk_package_tree(union acpi_operand_object *source_object,
|
||||
|
||||
void acpi_ut_strupr(char *src_string);
|
||||
|
||||
void acpi_ut_strlwr(char *src_string);
|
||||
|
||||
int acpi_ut_stricmp(char *string1, char *string2);
|
||||
|
||||
void acpi_ut_print_string(char *string, u8 max_length);
|
||||
|
||||
u8 acpi_ut_valid_acpi_name(u32 name);
|
||||
|
||||
acpi_name acpi_ut_repair_name(char *name);
|
||||
void acpi_ut_repair_name(char *name);
|
||||
|
||||
u8 acpi_ut_valid_acpi_char(char character, u32 position);
|
||||
|
||||
acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 * ret_integer);
|
||||
acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer);
|
||||
|
||||
/* Values for Base above (16=Hex, 10=Decimal) */
|
||||
|
||||
@ -508,12 +535,12 @@ acpi_ut_display_init_pathname(u8 type,
|
||||
* utresrc
|
||||
*/
|
||||
acpi_status
|
||||
acpi_ut_walk_aml_resources(u8 * aml,
|
||||
acpi_ut_walk_aml_resources(u8 *aml,
|
||||
acpi_size aml_length,
|
||||
acpi_walk_aml_callback user_function,
|
||||
void **context);
|
||||
|
||||
acpi_status acpi_ut_validate_resource(void *aml, u8 * return_index);
|
||||
acpi_status acpi_ut_validate_resource(void *aml, u8 *return_index);
|
||||
|
||||
u32 acpi_ut_get_descriptor_length(void *aml);
|
||||
|
||||
@ -524,8 +551,7 @@ u8 acpi_ut_get_resource_header_length(void *aml);
|
||||
u8 acpi_ut_get_resource_type(void *aml);
|
||||
|
||||
acpi_status
|
||||
acpi_ut_get_resource_end_tag(union acpi_operand_object *obj_desc,
|
||||
u8 ** end_tag);
|
||||
acpi_ut_get_resource_end_tag(union acpi_operand_object *obj_desc, u8 **end_tag);
|
||||
|
||||
/*
|
||||
* utmutex - mutex support
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: amlresrc.h - AML resource descriptors
|
||||
|
||||
@ -280,7 +280,7 @@ acpi_ds_exec_end_control_op(struct acpi_walk_state * walk_state,
|
||||
|
||||
/*
|
||||
* Get the return value and save as the last result
|
||||
* value. This is the only place where walk_state->return_desc
|
||||
* value. This is the only place where walk_state->return_desc
|
||||
* is set to anything other than zero!
|
||||
*/
|
||||
walk_state->return_desc = walk_state->operands[0];
|
||||
|
||||
@ -277,7 +277,7 @@ acpi_ds_create_buffer_field(union acpi_parse_object *op,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Process all named fields in a field declaration. Names are
|
||||
* DESCRIPTION: Process all named fields in a field declaration. Names are
|
||||
* entered into the namespace.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -170,7 +170,7 @@ acpi_ds_create_method_mutex(union acpi_operand_object *method_desc)
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
|
||||
* DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
|
||||
* increments the thread count, and waits at the method semaphore
|
||||
* for clearance to execute.
|
||||
*
|
||||
@ -444,7 +444,7 @@ acpi_ds_call_control_method(struct acpi_thread_state *thread,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Restart a method that was preempted by another (nested) method
|
||||
* invocation. Handle the return value (if any) from the callee.
|
||||
* invocation. Handle the return value (if any) from the callee.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -530,7 +530,7 @@ acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
|
||||
*
|
||||
* RETURN: None
|
||||
*
|
||||
* DESCRIPTION: Terminate a control method. Delete everything that the method
|
||||
* DESCRIPTION: Terminate a control method. Delete everything that the method
|
||||
* created, delete all locals and arguments, and delete the parse
|
||||
* tree if requested.
|
||||
*
|
||||
|
||||
@ -76,7 +76,7 @@ acpi_ds_method_data_get_type(u16 opcode,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Initialize the data structures that hold the method's arguments
|
||||
* and locals. The data struct is an array of namespace nodes for
|
||||
* and locals. The data struct is an array of namespace nodes for
|
||||
* each - this allows ref_of and de_ref_of to work properly for these
|
||||
* special data types.
|
||||
*
|
||||
@ -129,7 +129,7 @@ void acpi_ds_method_data_init(struct acpi_walk_state *walk_state)
|
||||
*
|
||||
* RETURN: None
|
||||
*
|
||||
* DESCRIPTION: Delete method locals and arguments. Arguments are only
|
||||
* DESCRIPTION: Delete method locals and arguments. Arguments are only
|
||||
* deleted if this method was called from another method.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -183,7 +183,7 @@ void acpi_ds_method_data_delete_all(struct acpi_walk_state *walk_state)
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Initialize arguments for a method. The parameter list is a list
|
||||
* DESCRIPTION: Initialize arguments for a method. The parameter list is a list
|
||||
* of ACPI operand objects, either null terminated or whose length
|
||||
* is defined by max_param_count.
|
||||
*
|
||||
@ -401,7 +401,7 @@ acpi_ds_method_data_get_value(u8 type,
|
||||
* This means that either 1) The expected argument was
|
||||
* not passed to the method, or 2) A local variable
|
||||
* was referenced by the method (via the ASL)
|
||||
* before it was initialized. Either case is an error.
|
||||
* before it was initialized. Either case is an error.
|
||||
*/
|
||||
|
||||
/* If slack enabled, init the local_x/arg_x to an Integer of value zero */
|
||||
@ -465,7 +465,7 @@ acpi_ds_method_data_get_value(u8 type,
|
||||
*
|
||||
* RETURN: None
|
||||
*
|
||||
* DESCRIPTION: Delete the entry at Opcode:Index. Inserts
|
||||
* DESCRIPTION: Delete the entry at Opcode:Index. Inserts
|
||||
* a null into the stack slot after the object is deleted.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -523,7 +523,7 @@ acpi_ds_method_data_delete_value(u8 type,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Store a value in an Arg or Local. The obj_desc is installed
|
||||
* DESCRIPTION: Store a value in an Arg or Local. The obj_desc is installed
|
||||
* as the new value for the Arg or Local and the reference count
|
||||
* for obj_desc is incremented.
|
||||
*
|
||||
@ -566,7 +566,7 @@ acpi_ds_store_object_to_local(u8 type,
|
||||
|
||||
/*
|
||||
* If the reference count on the object is more than one, we must
|
||||
* take a copy of the object before we store. A reference count
|
||||
* take a copy of the object before we store. A reference count
|
||||
* of exactly 1 means that the object was just created during the
|
||||
* evaluation of an expression, and we can safely use it since it
|
||||
* is not used anywhere else.
|
||||
|
||||
@ -293,7 +293,7 @@ acpi_ds_build_internal_buffer_obj(struct acpi_walk_state *walk_state,
|
||||
|
||||
/*
|
||||
* Second arg is the buffer data (optional) byte_list can be either
|
||||
* individual bytes or a string initializer. In either case, a
|
||||
* individual bytes or a string initializer. In either case, a
|
||||
* byte_list appears in the AML.
|
||||
*/
|
||||
arg = op->common.value.arg; /* skip first arg */
|
||||
@ -568,7 +568,7 @@ acpi_ds_create_node(struct acpi_walk_state *walk_state,
|
||||
|
||||
/*
|
||||
* Because of the execution pass through the non-control-method
|
||||
* parts of the table, we can arrive here twice. Only init
|
||||
* parts of the table, we can arrive here twice. Only init
|
||||
* the named object node the first time through
|
||||
*/
|
||||
if (acpi_ns_get_attached_object(node)) {
|
||||
@ -618,7 +618,7 @@ acpi_ds_create_node(struct acpi_walk_state *walk_state,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Initialize a namespace object from a parser Op and its
|
||||
* associated arguments. The namespace object is a more compact
|
||||
* associated arguments. The namespace object is a more compact
|
||||
* representation of the Op and its arguments.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -649,7 +649,8 @@ acpi_ds_eval_data_object_operands(struct acpi_walk_state *walk_state,
|
||||
((op->common.parent->common.aml_opcode != AML_PACKAGE_OP) &&
|
||||
(op->common.parent->common.aml_opcode !=
|
||||
AML_VAR_PACKAGE_OP)
|
||||
&& (op->common.parent->common.aml_opcode != AML_NAME_OP))) {
|
||||
&& (op->common.parent->common.aml_opcode !=
|
||||
AML_NAME_OP))) {
|
||||
walk_state->result_obj = obj_desc;
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,7 +61,7 @@ ACPI_MODULE_NAME("dsutils")
|
||||
*
|
||||
* RETURN: None.
|
||||
*
|
||||
* DESCRIPTION: Clear and remove a reference on an implicit return value. Used
|
||||
* DESCRIPTION: Clear and remove a reference on an implicit return value. Used
|
||||
* to delete "stale" return values (if enabled, the return value
|
||||
* from every operator is saved at least momentarily, in case the
|
||||
* parent method exits.)
|
||||
@ -107,7 +107,7 @@ void acpi_ds_clear_implicit_return(struct acpi_walk_state *walk_state)
|
||||
*
|
||||
* DESCRIPTION: Implements the optional "implicit return". We save the result
|
||||
* of every ASL operator and control method invocation in case the
|
||||
* parent method exit. Before storing a new return value, we
|
||||
* parent method exit. Before storing a new return value, we
|
||||
* delete the previous return value.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -198,7 +198,7 @@ acpi_ds_is_result_used(union acpi_parse_object * op,
|
||||
*
|
||||
* If there is no parent, or the parent is a scope_op, we are executing
|
||||
* at the method level. An executing method typically has no parent,
|
||||
* since each method is parsed separately. A method invoked externally
|
||||
* since each method is parsed separately. A method invoked externally
|
||||
* via execute_control_method has a scope_op as the parent.
|
||||
*/
|
||||
if ((!op->common.parent) ||
|
||||
@ -223,7 +223,7 @@ acpi_ds_is_result_used(union acpi_parse_object * op,
|
||||
}
|
||||
|
||||
/*
|
||||
* Decide what to do with the result based on the parent. If
|
||||
* Decide what to do with the result based on the parent. If
|
||||
* the parent opcode will not use the result, delete the object.
|
||||
* Otherwise leave it as is, it will be deleted when it is used
|
||||
* as an operand later.
|
||||
@ -266,7 +266,7 @@ acpi_ds_is_result_used(union acpi_parse_object * op,
|
||||
|
||||
/*
|
||||
* These opcodes allow term_arg(s) as operands and therefore
|
||||
* the operands can be method calls. The result is used.
|
||||
* the operands can be method calls. The result is used.
|
||||
*/
|
||||
goto result_used;
|
||||
|
||||
@ -284,7 +284,7 @@ acpi_ds_is_result_used(union acpi_parse_object * op,
|
||||
AML_BANK_FIELD_OP)) {
|
||||
/*
|
||||
* These opcodes allow term_arg(s) as operands and therefore
|
||||
* the operands can be method calls. The result is used.
|
||||
* the operands can be method calls. The result is used.
|
||||
*/
|
||||
goto result_used;
|
||||
}
|
||||
@ -329,9 +329,9 @@ acpi_ds_is_result_used(union acpi_parse_object * op,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Used after interpretation of an opcode. If there is an internal
|
||||
* DESCRIPTION: Used after interpretation of an opcode. If there is an internal
|
||||
* result descriptor, check if the parent opcode will actually use
|
||||
* this result. If not, delete the result now so that it will
|
||||
* this result. If not, delete the result now so that it will
|
||||
* not become orphaned.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -376,7 +376,7 @@ acpi_ds_delete_result_if_not_used(union acpi_parse_object *op,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Resolve all operands to their values. Used to prepare
|
||||
* DESCRIPTION: Resolve all operands to their values. Used to prepare
|
||||
* arguments to a control method invocation (a call from one
|
||||
* method to another.)
|
||||
*
|
||||
@ -391,7 +391,7 @@ acpi_status acpi_ds_resolve_operands(struct acpi_walk_state *walk_state)
|
||||
|
||||
/*
|
||||
* Attempt to resolve each of the valid operands
|
||||
* Method arguments are passed by reference, not by value. This means
|
||||
* Method arguments are passed by reference, not by value. This means
|
||||
* that the actual objects are passed, not copies of the objects.
|
||||
*/
|
||||
for (i = 0; i < walk_state->num_operands; i++) {
|
||||
@ -451,7 +451,7 @@ void acpi_ds_clear_operands(struct acpi_walk_state *walk_state)
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Translate a parse tree object that is an argument to an AML
|
||||
* opcode to the equivalent interpreter object. This may include
|
||||
* opcode to the equivalent interpreter object. This may include
|
||||
* looking up a name or entering a new name into the internal
|
||||
* namespace.
|
||||
*
|
||||
@ -496,9 +496,9 @@ acpi_ds_create_operand(struct acpi_walk_state *walk_state,
|
||||
/*
|
||||
* Special handling for buffer_field declarations. This is a deferred
|
||||
* opcode that unfortunately defines the field name as the last
|
||||
* parameter instead of the first. We get here when we are performing
|
||||
* parameter instead of the first. We get here when we are performing
|
||||
* the deferred execution, so the actual name of the field is already
|
||||
* in the namespace. We don't want to attempt to look it up again
|
||||
* in the namespace. We don't want to attempt to look it up again
|
||||
* because we may be executing in a different scope than where the
|
||||
* actual opcode exists.
|
||||
*/
|
||||
@ -560,7 +560,8 @@ acpi_ds_create_operand(struct acpi_walk_state *walk_state,
|
||||
* indicate this to the interpreter, set the
|
||||
* object to the root
|
||||
*/
|
||||
obj_desc = ACPI_CAST_PTR(union
|
||||
obj_desc =
|
||||
ACPI_CAST_PTR(union
|
||||
acpi_operand_object,
|
||||
acpi_gbl_root_node);
|
||||
status = AE_OK;
|
||||
@ -604,8 +605,8 @@ acpi_ds_create_operand(struct acpi_walk_state *walk_state,
|
||||
/*
|
||||
* If the name is null, this means that this is an
|
||||
* optional result parameter that was not specified
|
||||
* in the original ASL. Create a Zero Constant for a
|
||||
* placeholder. (Store to a constant is a Noop.)
|
||||
* in the original ASL. Create a Zero Constant for a
|
||||
* placeholder. (Store to a constant is a Noop.)
|
||||
*/
|
||||
opcode = AML_ZERO_OP; /* Has no arguments! */
|
||||
|
||||
|
||||
@ -57,7 +57,7 @@ ACPI_MODULE_NAME("dswexec")
|
||||
/*
|
||||
* Dispatch table for opcode classes
|
||||
*/
|
||||
static ACPI_EXECUTE_OP acpi_gbl_op_type_dispatch[] = {
|
||||
static acpi_execute_op acpi_gbl_op_type_dispatch[] = {
|
||||
acpi_ex_opcode_0A_0T_1R,
|
||||
acpi_ex_opcode_1A_0T_0R,
|
||||
acpi_ex_opcode_1A_0T_1R,
|
||||
@ -204,7 +204,7 @@ acpi_ds_get_predicate_value(struct acpi_walk_state *walk_state,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Descending callback used during the execution of control
|
||||
* methods. This is where most operators and operands are
|
||||
* methods. This is where most operators and operands are
|
||||
* dispatched to the interpreter.
|
||||
*
|
||||
****************************************************************************/
|
||||
@ -297,7 +297,7 @@ acpi_ds_exec_begin_op(struct acpi_walk_state *walk_state,
|
||||
if (walk_state->walk_type & ACPI_WALK_METHOD) {
|
||||
/*
|
||||
* Found a named object declaration during method execution;
|
||||
* we must enter this object into the namespace. The created
|
||||
* we must enter this object into the namespace. The created
|
||||
* object is temporary and will be deleted upon completion of
|
||||
* the execution of this method.
|
||||
*
|
||||
@ -348,7 +348,7 @@ acpi_ds_exec_begin_op(struct acpi_walk_state *walk_state,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Ascending callback used during the execution of control
|
||||
* methods. The only thing we really need to do here is to
|
||||
* methods. The only thing we really need to do here is to
|
||||
* notice the beginning of IF, ELSE, and WHILE blocks.
|
||||
*
|
||||
****************************************************************************/
|
||||
@ -432,7 +432,7 @@ acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state)
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
/*
|
||||
* Dispatch the request to the appropriate interpreter handler
|
||||
* routine. There is one routine per opcode "type" based upon the
|
||||
* routine. There is one routine per opcode "type" based upon the
|
||||
* number of opcode arguments and return type.
|
||||
*/
|
||||
status =
|
||||
|
||||
@ -254,7 +254,7 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
|
||||
acpi_ut_get_type_name(node->type),
|
||||
acpi_ut_get_node_name(node)));
|
||||
|
||||
return (AE_AML_OPERAND_TYPE);
|
||||
return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -602,7 +602,7 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
|
||||
region_space,
|
||||
walk_state);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return (status);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
acpi_ex_exit_interpreter();
|
||||
|
||||
@ -51,8 +51,9 @@
|
||||
ACPI_MODULE_NAME("dswstate")
|
||||
|
||||
/* Local prototypes */
|
||||
static acpi_status acpi_ds_result_stack_push(struct acpi_walk_state *ws);
|
||||
static acpi_status acpi_ds_result_stack_pop(struct acpi_walk_state *ws);
|
||||
static acpi_status
|
||||
acpi_ds_result_stack_push(struct acpi_walk_state *walk_state);
|
||||
static acpi_status acpi_ds_result_stack_pop(struct acpi_walk_state *walk_state);
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
@ -347,7 +348,7 @@ acpi_ds_obj_stack_push(void *object, struct acpi_walk_state * walk_state)
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
|
||||
* DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
|
||||
* deleted by this routine.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -491,7 +492,7 @@ acpi_ds_push_walk_state(struct acpi_walk_state *walk_state,
|
||||
* RETURN: A walk_state object popped from the thread's stack
|
||||
*
|
||||
* DESCRIPTION: Remove and return the walkstate object that is at the head of
|
||||
* the walk stack for the given walk list. NULL indicates that
|
||||
* the walk stack for the given walk list. NULL indicates that
|
||||
* the list is empty.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -531,14 +532,17 @@ struct acpi_walk_state *acpi_ds_pop_walk_state(struct acpi_thread_state *thread)
|
||||
*
|
||||
* RETURN: Pointer to the new walk state.
|
||||
*
|
||||
* DESCRIPTION: Allocate and initialize a new walk state. The current walk
|
||||
* DESCRIPTION: Allocate and initialize a new walk state. The current walk
|
||||
* state is set to this new state.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id, union acpi_parse_object
|
||||
*origin, union acpi_operand_object
|
||||
*method_desc, struct acpi_thread_state
|
||||
struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id,
|
||||
union acpi_parse_object
|
||||
*origin,
|
||||
union acpi_operand_object
|
||||
*method_desc,
|
||||
struct acpi_thread_state
|
||||
*thread)
|
||||
{
|
||||
struct acpi_walk_state *walk_state;
|
||||
@ -653,7 +657,7 @@ acpi_ds_init_aml_walk(struct acpi_walk_state *walk_state,
|
||||
/*
|
||||
* Setup the current scope.
|
||||
* Find a Named Op that has a namespace node associated with it.
|
||||
* search upwards from this Op. Current scope is the first
|
||||
* search upwards from this Op. Current scope is the first
|
||||
* Op with a namespace node.
|
||||
*/
|
||||
extra_op = parser_state->start_op;
|
||||
@ -704,13 +708,13 @@ void acpi_ds_delete_walk_state(struct acpi_walk_state *walk_state)
|
||||
ACPI_FUNCTION_TRACE_PTR(ds_delete_walk_state, walk_state);
|
||||
|
||||
if (!walk_state) {
|
||||
return;
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
if (walk_state->descriptor_type != ACPI_DESC_TYPE_WALK) {
|
||||
ACPI_ERROR((AE_INFO, "%p is not a valid walk state",
|
||||
walk_state));
|
||||
return;
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
/* There should not be any open scopes */
|
||||
|
||||
@ -89,7 +89,8 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
|
||||
/* Set the mask bit only if there are references to this GPE */
|
||||
|
||||
if (gpe_event_info->runtime_count) {
|
||||
ACPI_SET_BIT(gpe_register_info->enable_for_run, (u8)register_bit);
|
||||
ACPI_SET_BIT(gpe_register_info->enable_for_run,
|
||||
(u8)register_bit);
|
||||
}
|
||||
|
||||
return_ACPI_STATUS(AE_OK);
|
||||
@ -106,8 +107,7 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
|
||||
* DESCRIPTION: Clear a GPE of stale events and enable it.
|
||||
*
|
||||
******************************************************************************/
|
||||
acpi_status
|
||||
acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
|
||||
acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
|
||||
{
|
||||
acpi_status status;
|
||||
|
||||
@ -131,8 +131,8 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
|
||||
}
|
||||
|
||||
/* Enable the requested GPE */
|
||||
status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
|
||||
|
||||
status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
@ -150,7 +150,8 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
acpi_status
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
|
||||
@ -191,7 +192,8 @@ acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
acpi_status
|
||||
acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
|
||||
@ -208,7 +210,8 @@ acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_i
|
||||
|
||||
status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
status = acpi_hw_low_set_gpe(gpe_event_info,
|
||||
status =
|
||||
acpi_hw_low_set_gpe(gpe_event_info,
|
||||
ACPI_GPE_DISABLE);
|
||||
}
|
||||
|
||||
@ -306,7 +309,8 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
|
||||
|
||||
/* A Non-NULL gpe_device means this is a GPE Block Device */
|
||||
|
||||
obj_desc = acpi_ns_get_attached_object((struct acpi_namespace_node *)
|
||||
obj_desc =
|
||||
acpi_ns_get_attached_object((struct acpi_namespace_node *)
|
||||
gpe_device);
|
||||
if (!obj_desc || !obj_desc->device.gpe_block) {
|
||||
return (NULL);
|
||||
|
||||
@ -486,7 +486,8 @@ acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status,
|
||||
"Could not enable GPE 0x%02X",
|
||||
gpe_index + gpe_block->block_base_number));
|
||||
gpe_index +
|
||||
gpe_block->block_base_number));
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
@ -374,7 +374,8 @@ acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
gpe_event_info->dispatch.handler = NULL;
|
||||
gpe_event_info->flags &=
|
||||
~ACPI_GPE_DISPATCH_MASK;
|
||||
} else if ((gpe_event_info->
|
||||
} else
|
||||
if ((gpe_event_info->
|
||||
flags & ACPI_GPE_DISPATCH_MASK) ==
|
||||
ACPI_GPE_DISPATCH_NOTIFY) {
|
||||
|
||||
|
||||
@ -227,8 +227,7 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
|
||||
|
||||
/* Install a handler for this PCI root bridge */
|
||||
|
||||
status =
|
||||
acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
|
||||
status = acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
if (status == AE_SAME_HANDLER) {
|
||||
/*
|
||||
@ -350,8 +349,8 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
|
||||
static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpica_device_id *hid;
|
||||
struct acpica_device_id_list *cid;
|
||||
struct acpi_pnp_device_id *hid;
|
||||
struct acpi_pnp_device_id_list *cid;
|
||||
u32 i;
|
||||
u8 match;
|
||||
|
||||
|
||||
@ -398,7 +398,7 @@ ACPI_EXPORT_SYMBOL(acpi_install_exception_handler)
|
||||
*
|
||||
******************************************************************************/
|
||||
acpi_status
|
||||
acpi_install_global_event_handler(ACPI_GBL_EVENT_HANDLER handler, void *context)
|
||||
acpi_install_global_event_handler(acpi_gbl_event_handler handler, void *context)
|
||||
{
|
||||
acpi_status status;
|
||||
|
||||
|
||||
@ -221,7 +221,8 @@ acpi_setup_gpe_for_wake(acpi_handle wake_device,
|
||||
if (wake_device == ACPI_ROOT_OBJECT) {
|
||||
device_node = acpi_gbl_root_node;
|
||||
} else {
|
||||
device_node = ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
|
||||
device_node =
|
||||
ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
|
||||
}
|
||||
|
||||
/* Validate WakeDevice is of type Device */
|
||||
@ -324,7 +325,8 @@ ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
|
||||
acpi_status
|
||||
acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
struct acpi_gpe_event_info *gpe_event_info;
|
||||
@ -567,7 +569,7 @@ acpi_install_gpe_block(acpi_handle gpe_device,
|
||||
|
||||
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return (status);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
node = acpi_ns_validate_handle(gpe_device);
|
||||
@ -650,7 +652,7 @@ acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
|
||||
|
||||
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return (status);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
node = acpi_ns_validate_handle(gpe_device);
|
||||
@ -694,8 +696,7 @@ ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
|
||||
* the FADT-defined gpe blocks. Otherwise, the GPE block device.
|
||||
*
|
||||
******************************************************************************/
|
||||
acpi_status
|
||||
acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
|
||||
acpi_status acpi_get_gpe_device(u32 index, acpi_handle * gpe_device)
|
||||
{
|
||||
struct acpi_gpe_device_info info;
|
||||
acpi_status status;
|
||||
|
||||
@ -516,8 +516,8 @@ acpi_ex_convert_to_string(union acpi_operand_object * obj_desc,
|
||||
string_length--;
|
||||
}
|
||||
|
||||
return_desc = acpi_ut_create_string_object((acpi_size)
|
||||
string_length);
|
||||
return_desc =
|
||||
acpi_ut_create_string_object((acpi_size) string_length);
|
||||
if (!return_desc) {
|
||||
return_ACPI_STATUS(AE_NO_MEMORY);
|
||||
}
|
||||
|
||||
@ -78,7 +78,7 @@ acpi_status acpi_ex_create_alias(struct acpi_walk_state *walk_state)
|
||||
(target_node->type == ACPI_TYPE_LOCAL_METHOD_ALIAS)) {
|
||||
/*
|
||||
* Dereference an existing alias so that we don't create a chain
|
||||
* of aliases. With this code, we guarantee that an alias is
|
||||
* of aliases. With this code, we guarantee that an alias is
|
||||
* always exactly one level of indirection away from the
|
||||
* actual aliased name.
|
||||
*/
|
||||
@ -90,7 +90,7 @@ acpi_status acpi_ex_create_alias(struct acpi_walk_state *walk_state)
|
||||
/*
|
||||
* For objects that can never change (i.e., the NS node will
|
||||
* permanently point to the same object), we can simply attach
|
||||
* the object to the new NS node. For other objects (such as
|
||||
* the object to the new NS node. For other objects (such as
|
||||
* Integers, buffers, etc.), we have to point the Alias node
|
||||
* to the original Node.
|
||||
*/
|
||||
@ -139,7 +139,7 @@ acpi_status acpi_ex_create_alias(struct acpi_walk_state *walk_state)
|
||||
|
||||
/*
|
||||
* The new alias assumes the type of the target, and it points
|
||||
* to the same object. The reference count of the object has an
|
||||
* to the same object. The reference count of the object has an
|
||||
* additional reference to prevent deletion out from under either the
|
||||
* target node or the alias Node
|
||||
*/
|
||||
@ -243,8 +243,7 @@ acpi_status acpi_ex_create_mutex(struct acpi_walk_state *walk_state)
|
||||
|
||||
/* Init object and attach to NS node */
|
||||
|
||||
obj_desc->mutex.sync_level =
|
||||
(u8) walk_state->operands[1]->integer.value;
|
||||
obj_desc->mutex.sync_level = (u8)walk_state->operands[1]->integer.value;
|
||||
obj_desc->mutex.node =
|
||||
(struct acpi_namespace_node *)walk_state->operands[0];
|
||||
|
||||
|
||||
@ -145,10 +145,10 @@ acpi_ex_do_debug_object(union acpi_operand_object *source_desc,
|
||||
case ACPI_TYPE_BUFFER:
|
||||
|
||||
acpi_os_printf("[0x%.2X]\n", (u32)source_desc->buffer.length);
|
||||
acpi_ut_dump_buffer2(source_desc->buffer.pointer,
|
||||
(source_desc->buffer.length < 256) ?
|
||||
source_desc->buffer.length : 256,
|
||||
DB_BYTE_DISPLAY);
|
||||
acpi_ut_dump_buffer(source_desc->buffer.pointer,
|
||||
(source_desc->buffer.length < 256) ?
|
||||
source_desc->buffer.length : 256,
|
||||
DB_BYTE_DISPLAY, 0);
|
||||
break;
|
||||
|
||||
case ACPI_TYPE_STRING:
|
||||
@ -190,7 +190,7 @@ acpi_ex_do_debug_object(union acpi_operand_object *source_desc,
|
||||
|
||||
acpi_os_printf("Table Index 0x%X\n",
|
||||
source_desc->reference.value);
|
||||
return;
|
||||
return_VOID;
|
||||
|
||||
default:
|
||||
break;
|
||||
|
||||
@ -464,7 +464,8 @@ void acpi_ex_dump_operand(union acpi_operand_object *obj_desc, u32 depth)
|
||||
|
||||
ACPI_FUNCTION_NAME(ex_dump_operand)
|
||||
|
||||
if (!((ACPI_LV_EXEC & acpi_dbg_level)
|
||||
if (!
|
||||
((ACPI_LV_EXEC & acpi_dbg_level)
|
||||
&& (_COMPONENT & acpi_dbg_layer))) {
|
||||
return;
|
||||
}
|
||||
@ -777,7 +778,7 @@ acpi_ex_dump_operands(union acpi_operand_object **operands,
|
||||
* PARAMETERS: title - Descriptive text
|
||||
* value - Value to be displayed
|
||||
*
|
||||
* DESCRIPTION: Object dump output formatting functions. These functions
|
||||
* DESCRIPTION: Object dump output formatting functions. These functions
|
||||
* reduce the number of format strings required and keeps them
|
||||
* all in one place for easy modification.
|
||||
*
|
||||
@ -810,7 +811,8 @@ void acpi_ex_dump_namespace_node(struct acpi_namespace_node *node, u32 flags)
|
||||
ACPI_FUNCTION_ENTRY();
|
||||
|
||||
if (!flags) {
|
||||
if (!((ACPI_LV_OBJECTS & acpi_dbg_level)
|
||||
if (!
|
||||
((ACPI_LV_OBJECTS & acpi_dbg_level)
|
||||
&& (_COMPONENT & acpi_dbg_layer))) {
|
||||
return;
|
||||
}
|
||||
@ -940,10 +942,11 @@ acpi_ex_dump_package_obj(union acpi_operand_object *obj_desc,
|
||||
acpi_os_printf("[Buffer] Length %.2X = ",
|
||||
obj_desc->buffer.length);
|
||||
if (obj_desc->buffer.length) {
|
||||
acpi_ut_dump_buffer(ACPI_CAST_PTR
|
||||
(u8, obj_desc->buffer.pointer),
|
||||
obj_desc->buffer.length,
|
||||
DB_DWORD_DISPLAY, _COMPONENT);
|
||||
acpi_ut_debug_dump_buffer(ACPI_CAST_PTR
|
||||
(u8,
|
||||
obj_desc->buffer.pointer),
|
||||
obj_desc->buffer.length,
|
||||
DB_DWORD_DISPLAY, _COMPONENT);
|
||||
} else {
|
||||
acpi_os_printf("\n");
|
||||
}
|
||||
@ -996,7 +999,8 @@ acpi_ex_dump_object_descriptor(union acpi_operand_object *obj_desc, u32 flags)
|
||||
}
|
||||
|
||||
if (!flags) {
|
||||
if (!((ACPI_LV_OBJECTS & acpi_dbg_level)
|
||||
if (!
|
||||
((ACPI_LV_OBJECTS & acpi_dbg_level)
|
||||
&& (_COMPONENT & acpi_dbg_layer))) {
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
@ -59,7 +59,7 @@ ACPI_MODULE_NAME("exfield")
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Read from a named field. Returns either an Integer or a
|
||||
* DESCRIPTION: Read from a named field. Returns either an Integer or a
|
||||
* Buffer, depending on the size of the field.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -149,7 +149,7 @@ acpi_ex_read_data_from_field(struct acpi_walk_state *walk_state,
|
||||
* Allocate a buffer for the contents of the field.
|
||||
*
|
||||
* If the field is larger than the current integer width, create
|
||||
* a BUFFER to hold it. Otherwise, use an INTEGER. This allows
|
||||
* a BUFFER to hold it. Otherwise, use an INTEGER. This allows
|
||||
* the use of arithmetic operators on the returned value if the
|
||||
* field size is equal or smaller than an Integer.
|
||||
*
|
||||
|
||||
@ -54,8 +54,7 @@ ACPI_MODULE_NAME("exfldio")
|
||||
/* Local prototypes */
|
||||
static acpi_status
|
||||
acpi_ex_field_datum_io(union acpi_operand_object *obj_desc,
|
||||
u32 field_datum_byte_offset,
|
||||
u64 *value, u32 read_write);
|
||||
u32 field_datum_byte_offset, u64 *value, u32 read_write);
|
||||
|
||||
static u8
|
||||
acpi_ex_register_overflow(union acpi_operand_object *obj_desc, u64 value);
|
||||
@ -155,7 +154,7 @@ acpi_ex_setup_region(union acpi_operand_object *obj_desc,
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Validate the request. The entire request from the byte offset for a
|
||||
* Validate the request. The entire request from the byte offset for a
|
||||
* length of one field datum (access width) must fit within the region.
|
||||
* (Region length is specified in bytes)
|
||||
*/
|
||||
@ -183,7 +182,7 @@ acpi_ex_setup_region(union acpi_operand_object *obj_desc,
|
||||
obj_desc->common_field.access_byte_width) {
|
||||
/*
|
||||
* This is the case where the access_type (acc_word, etc.) is wider
|
||||
* than the region itself. For example, a region of length one
|
||||
* than the region itself. For example, a region of length one
|
||||
* byte, and a field with Dword access specified.
|
||||
*/
|
||||
ACPI_ERROR((AE_INFO,
|
||||
@ -321,7 +320,7 @@ acpi_ex_access_region(union acpi_operand_object *obj_desc,
|
||||
*
|
||||
* DESCRIPTION: Check if a value is out of range of the field being written.
|
||||
* Used to check if the values written to Index and Bank registers
|
||||
* are out of range. Normally, the value is simply truncated
|
||||
* are out of range. Normally, the value is simply truncated
|
||||
* to fit the field, but this case is most likely a serious
|
||||
* coding error in the ASL.
|
||||
*
|
||||
@ -370,7 +369,7 @@ acpi_ex_register_overflow(union acpi_operand_object *obj_desc, u64 value)
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Read or Write a single datum of a field. The field_type is
|
||||
* DESCRIPTION: Read or Write a single datum of a field. The field_type is
|
||||
* demultiplexed here to handle the different types of fields
|
||||
* (buffer_field, region_field, index_field, bank_field)
|
||||
*
|
||||
@ -860,7 +859,7 @@ acpi_ex_insert_into_field(union acpi_operand_object *obj_desc,
|
||||
ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length);
|
||||
/*
|
||||
* We must have a buffer that is at least as long as the field
|
||||
* we are writing to. This is because individual fields are
|
||||
* we are writing to. This is because individual fields are
|
||||
* indivisible and partial writes are not supported -- as per
|
||||
* the ACPI specification.
|
||||
*/
|
||||
@ -875,7 +874,7 @@ acpi_ex_insert_into_field(union acpi_operand_object *obj_desc,
|
||||
|
||||
/*
|
||||
* Copy the original data to the new buffer, starting
|
||||
* at Byte zero. All unused (upper) bytes of the
|
||||
* at Byte zero. All unused (upper) bytes of the
|
||||
* buffer will be 0.
|
||||
*/
|
||||
ACPI_MEMCPY((char *)new_buffer, (char *)buffer, buffer_length);
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes
|
||||
@ -254,7 +253,7 @@ acpi_ex_do_concatenate(union acpi_operand_object *operand0,
|
||||
ACPI_FUNCTION_TRACE(ex_do_concatenate);
|
||||
|
||||
/*
|
||||
* Convert the second operand if necessary. The first operand
|
||||
* Convert the second operand if necessary. The first operand
|
||||
* determines the type of the second operand, (See the Data Types
|
||||
* section of the ACPI specification.) Both object types are
|
||||
* guaranteed to be either Integer/String/Buffer by the operand
|
||||
@ -573,7 +572,7 @@ acpi_ex_do_logical_op(u16 opcode,
|
||||
ACPI_FUNCTION_TRACE(ex_do_logical_op);
|
||||
|
||||
/*
|
||||
* Convert the second operand if necessary. The first operand
|
||||
* Convert the second operand if necessary. The first operand
|
||||
* determines the type of the second operand, (See the Data Types
|
||||
* section of the ACPI 3.0+ specification.) Both object types are
|
||||
* guaranteed to be either Integer/String/Buffer by the operand
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exmutex - ASL Mutex Acquire/Release functions
|
||||
@ -305,7 +304,7 @@ acpi_status acpi_ex_release_mutex_object(union acpi_operand_object *obj_desc)
|
||||
ACPI_FUNCTION_TRACE(ex_release_mutex_object);
|
||||
|
||||
if (obj_desc->mutex.acquisition_depth == 0) {
|
||||
return (AE_NOT_ACQUIRED);
|
||||
return_ACPI_STATUS(AE_NOT_ACQUIRED);
|
||||
}
|
||||
|
||||
/* Match multiple Acquires with multiple Releases */
|
||||
@ -462,7 +461,7 @@ void acpi_ex_release_all_mutexes(struct acpi_thread_state *thread)
|
||||
union acpi_operand_object *next = thread->acquired_mutex_list;
|
||||
union acpi_operand_object *obj_desc;
|
||||
|
||||
ACPI_FUNCTION_ENTRY();
|
||||
ACPI_FUNCTION_NAME(ex_release_all_mutexes);
|
||||
|
||||
/* Traverse the list of owned mutexes, releasing each one */
|
||||
|
||||
@ -474,6 +473,10 @@ void acpi_ex_release_all_mutexes(struct acpi_thread_state *thread)
|
||||
obj_desc->mutex.next = NULL;
|
||||
obj_desc->mutex.acquisition_depth = 0;
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
|
||||
"Force-releasing held mutex: %p\n",
|
||||
obj_desc));
|
||||
|
||||
/* Release the mutex, special case for Global Lock */
|
||||
|
||||
if (obj_desc == acpi_gbl_global_lock_mutex) {
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exnames - interpreter/scanner name load/execute
|
||||
@ -53,8 +52,7 @@ ACPI_MODULE_NAME("exnames")
|
||||
/* Local prototypes */
|
||||
static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs);
|
||||
|
||||
static acpi_status
|
||||
acpi_ex_name_segment(u8 ** in_aml_address, char *name_string);
|
||||
static acpi_status acpi_ex_name_segment(u8 **in_aml_address, char *name_string);
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
@ -64,7 +62,7 @@ acpi_ex_name_segment(u8 ** in_aml_address, char *name_string);
|
||||
* (-1)==root, 0==none
|
||||
* num_name_segs - count of 4-character name segments
|
||||
*
|
||||
* RETURN: A pointer to the allocated string segment. This segment must
|
||||
* RETURN: A pointer to the allocated string segment. This segment must
|
||||
* be deleted by the caller.
|
||||
*
|
||||
* DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
|
||||
@ -178,7 +176,8 @@ static acpi_status acpi_ex_name_segment(u8 ** in_aml_address, char *name_string)
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "Bytes from stream:\n"));
|
||||
|
||||
for (index = 0; (index < ACPI_NAME_SIZE)
|
||||
for (index = 0;
|
||||
(index < ACPI_NAME_SIZE)
|
||||
&& (acpi_ut_valid_acpi_char(*aml_address, 0)); index++) {
|
||||
char_buf[index] = *aml_address++;
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "%c\n", char_buf[index]));
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exoparg1 - AML execution - opcodes with 1 argument
|
||||
@ -606,7 +605,7 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
|
||||
}
|
||||
|
||||
/*
|
||||
* Set result to ONES (TRUE) if Value == 0. Note:
|
||||
* Set result to ONES (TRUE) if Value == 0. Note:
|
||||
* return_desc->Integer.Value is initially == 0 (FALSE) from above.
|
||||
*/
|
||||
if (!operand[0]->integer.value) {
|
||||
@ -618,7 +617,7 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
|
||||
case AML_INCREMENT_OP: /* Increment (Operand) */
|
||||
|
||||
/*
|
||||
* Create a new integer. Can't just get the base integer and
|
||||
* Create a new integer. Can't just get the base integer and
|
||||
* increment it because it may be an Arg or Field.
|
||||
*/
|
||||
return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
|
||||
@ -686,7 +685,7 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
|
||||
|
||||
/*
|
||||
* Note: The operand is not resolved at this point because we want to
|
||||
* get the associated object, not its value. For example, we don't
|
||||
* get the associated object, not its value. For example, we don't
|
||||
* want to resolve a field_unit to its value, we want the actual
|
||||
* field_unit object.
|
||||
*/
|
||||
@ -727,7 +726,7 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
|
||||
|
||||
/*
|
||||
* The type of the base object must be integer, buffer, string, or
|
||||
* package. All others are not supported.
|
||||
* package. All others are not supported.
|
||||
*
|
||||
* NOTE: Integer is not specifically supported by the ACPI spec,
|
||||
* but is supported implicitly via implicit operand conversion.
|
||||
@ -965,7 +964,7 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
|
||||
case ACPI_TYPE_PACKAGE:
|
||||
|
||||
/*
|
||||
* Return the referenced element of the package. We must
|
||||
* Return the referenced element of the package. We must
|
||||
* add another reference to the referenced object, however.
|
||||
*/
|
||||
return_desc =
|
||||
|
||||
@ -123,7 +123,7 @@ acpi_status acpi_ex_opcode_2A_0T_0R(struct acpi_walk_state *walk_state)
|
||||
/*
|
||||
* Dispatch the notify to the appropriate handler
|
||||
* NOTE: the request is queued for execution after this method
|
||||
* completes. The notify handlers are NOT invoked synchronously
|
||||
* completes. The notify handlers are NOT invoked synchronously
|
||||
* from this thread -- because handlers may in turn run other
|
||||
* control methods.
|
||||
*/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exoparg3 - AML execution - opcodes with 3 arguments
|
||||
@ -158,7 +157,7 @@ acpi_status acpi_ex_opcode_3A_1T_1R(struct acpi_walk_state *walk_state)
|
||||
case AML_MID_OP: /* Mid (Source[0], Index[1], Length[2], Result[3]) */
|
||||
|
||||
/*
|
||||
* Create the return object. The Source operand is guaranteed to be
|
||||
* Create the return object. The Source operand is guaranteed to be
|
||||
* either a String or a Buffer, so just use its type.
|
||||
*/
|
||||
return_desc = acpi_ut_create_internal_object((operand[0])->
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exoparg6 - AML execution - opcodes with 6 arguments
|
||||
@ -198,7 +197,7 @@ acpi_ex_do_match(u32 match_op,
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
return logical_result;
|
||||
return (logical_result);
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
@ -269,7 +268,7 @@ acpi_status acpi_ex_opcode_6A_0T_1R(struct acpi_walk_state * walk_state)
|
||||
* and the next should be examined.
|
||||
*
|
||||
* Upon finding a match, the loop will terminate via "break" at
|
||||
* the bottom. If it terminates "normally", match_value will be
|
||||
* the bottom. If it terminates "normally", match_value will be
|
||||
* ACPI_UINT64_MAX (Ones) (its initial value) indicating that no
|
||||
* match was found.
|
||||
*/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
|
||||
@ -78,8 +77,8 @@ acpi_ex_generate_access(u32 field_bit_offset,
|
||||
* any_acc keyword.
|
||||
*
|
||||
* NOTE: Need to have the region_length in order to check for boundary
|
||||
* conditions (end-of-region). However, the region_length is a deferred
|
||||
* operation. Therefore, to complete this implementation, the generation
|
||||
* conditions (end-of-region). However, the region_length is a deferred
|
||||
* operation. Therefore, to complete this implementation, the generation
|
||||
* of this access width must be deferred until the region length has
|
||||
* been evaluated.
|
||||
*
|
||||
@ -308,7 +307,7 @@ acpi_ex_decode_field_access(union acpi_operand_object *obj_desc,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Initialize the areas of the field object that are common
|
||||
* to the various types of fields. Note: This is very "sensitive"
|
||||
* to the various types of fields. Note: This is very "sensitive"
|
||||
* code because we are solving the general case for field
|
||||
* alignment.
|
||||
*
|
||||
@ -336,13 +335,13 @@ acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc,
|
||||
obj_desc->common_field.bit_length = field_bit_length;
|
||||
|
||||
/*
|
||||
* Decode the access type so we can compute offsets. The access type gives
|
||||
* Decode the access type so we can compute offsets. The access type gives
|
||||
* two pieces of information - the width of each field access and the
|
||||
* necessary byte_alignment (address granularity) of the access.
|
||||
*
|
||||
* For any_acc, the access_bit_width is the largest width that is both
|
||||
* necessary and possible in an attempt to access the whole field in one
|
||||
* I/O operation. However, for any_acc, the byte_alignment is always one
|
||||
* I/O operation. However, for any_acc, the byte_alignment is always one
|
||||
* byte.
|
||||
*
|
||||
* For all Buffer Fields, the byte_alignment is always one byte.
|
||||
@ -363,7 +362,7 @@ acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc,
|
||||
|
||||
/*
|
||||
* base_byte_offset is the address of the start of the field within the
|
||||
* region. It is the byte address of the first *datum* (field-width data
|
||||
* region. It is the byte address of the first *datum* (field-width data
|
||||
* unit) of the field. (i.e., the first datum that contains at least the
|
||||
* first *bit* of the field.)
|
||||
*
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exregion - ACPI default op_region (address space) handlers
|
||||
@ -202,7 +201,7 @@ acpi_ex_system_memory_space_handler(u32 function,
|
||||
* Perform the memory read or write
|
||||
*
|
||||
* Note: For machines that do not support non-aligned transfers, the target
|
||||
* address was checked for alignment above. We do not attempt to break the
|
||||
* address was checked for alignment above. We do not attempt to break the
|
||||
* transfer up into smaller (byte-size) chunks because the AML specifically
|
||||
* asked for a transfer width that the hardware may require.
|
||||
*/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exresnte - AML Interpreter object resolution
|
||||
@ -58,8 +57,8 @@ ACPI_MODULE_NAME("exresnte")
|
||||
* PARAMETERS: object_ptr - Pointer to a location that contains
|
||||
* a pointer to a NS node, and will receive a
|
||||
* pointer to the resolved object.
|
||||
* walk_state - Current state. Valid only if executing AML
|
||||
* code. NULL if simply resolving an object
|
||||
* walk_state - Current state. Valid only if executing AML
|
||||
* code. NULL if simply resolving an object
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
@ -67,7 +66,7 @@ ACPI_MODULE_NAME("exresnte")
|
||||
*
|
||||
* Note: for some of the data types, the pointer attached to the Node
|
||||
* can be either a pointer to an actual internal object or a pointer into the
|
||||
* AML stream itself. These types are currently:
|
||||
* AML stream itself. These types are currently:
|
||||
*
|
||||
* ACPI_TYPE_INTEGER
|
||||
* ACPI_TYPE_STRING
|
||||
@ -89,7 +88,7 @@ acpi_ex_resolve_node_to_value(struct acpi_namespace_node **object_ptr,
|
||||
ACPI_FUNCTION_TRACE(ex_resolve_node_to_value);
|
||||
|
||||
/*
|
||||
* The stack pointer points to a struct acpi_namespace_node (Node). Get the
|
||||
* The stack pointer points to a struct acpi_namespace_node (Node). Get the
|
||||
* object that is attached to the Node.
|
||||
*/
|
||||
node = *object_ptr;
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exresolv - AML Interpreter object resolution
|
||||
@ -327,7 +326,7 @@ acpi_ex_resolve_object_to_value(union acpi_operand_object **stack_ptr,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Return the base object and type. Traverse a reference list if
|
||||
* DESCRIPTION: Return the base object and type. Traverse a reference list if
|
||||
* necessary to get to the base object.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exresop - AML Interpreter operand/object resolution
|
||||
@ -87,7 +86,7 @@ acpi_ex_check_object_type(acpi_object_type type_needed,
|
||||
if (type_needed == ACPI_TYPE_LOCAL_REFERENCE) {
|
||||
/*
|
||||
* Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
|
||||
* objects and thus allow them to be targets. (As per the ACPI
|
||||
* objects and thus allow them to be targets. (As per the ACPI
|
||||
* specification, a store to a constant is a noop.)
|
||||
*/
|
||||
if ((this_type == ACPI_TYPE_INTEGER) &&
|
||||
@ -337,7 +336,8 @@ acpi_ex_resolve_operands(u16 opcode,
|
||||
if ((opcode == AML_STORE_OP) &&
|
||||
((*stack_ptr)->common.type ==
|
||||
ACPI_TYPE_LOCAL_REFERENCE)
|
||||
&& ((*stack_ptr)->reference.class == ACPI_REFCLASS_INDEX)) {
|
||||
&& ((*stack_ptr)->reference.class ==
|
||||
ACPI_REFCLASS_INDEX)) {
|
||||
goto next_operand;
|
||||
}
|
||||
break;
|
||||
@ -638,7 +638,7 @@ acpi_ex_resolve_operands(u16 opcode,
|
||||
if (acpi_gbl_enable_interpreter_slack) {
|
||||
/*
|
||||
* Enable original behavior of Store(), allowing any and all
|
||||
* objects as the source operand. The ACPI spec does not
|
||||
* objects as the source operand. The ACPI spec does not
|
||||
* allow this, however.
|
||||
*/
|
||||
break;
|
||||
|
||||
@ -374,7 +374,7 @@ acpi_ex_store_object_to_index(union acpi_operand_object *source_desc,
|
||||
* with the input value.
|
||||
*
|
||||
* When storing into an object the data is converted to the
|
||||
* target object type then stored in the object. This means
|
||||
* target object type then stored in the object. This means
|
||||
* that the target object type (for an initialized target) will
|
||||
* not be changed by a store operation.
|
||||
*
|
||||
@ -491,7 +491,7 @@ acpi_ex_store_object_to_node(union acpi_operand_object *source_desc,
|
||||
acpi_ut_get_object_type_name(source_desc),
|
||||
source_desc, node));
|
||||
|
||||
/* No conversions for all other types. Just attach the source object */
|
||||
/* No conversions for all other types. Just attach the source object */
|
||||
|
||||
status = acpi_ns_attach_object(node, source_desc,
|
||||
source_desc->common.type);
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exstoren - AML Interpreter object store support,
|
||||
@ -61,7 +60,7 @@ ACPI_MODULE_NAME("exstoren")
|
||||
*
|
||||
* RETURN: Status, resolved object in source_desc_ptr.
|
||||
*
|
||||
* DESCRIPTION: Resolve an object. If the object is a reference, dereference
|
||||
* DESCRIPTION: Resolve an object. If the object is a reference, dereference
|
||||
* it and return the actual object in the source_desc_ptr.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -93,7 +92,7 @@ acpi_ex_resolve_object(union acpi_operand_object **source_desc_ptr,
|
||||
|
||||
/*
|
||||
* Stores into a Field/Region or into a Integer/Buffer/String
|
||||
* are all essentially the same. This case handles the
|
||||
* are all essentially the same. This case handles the
|
||||
* "interchangeable" types Integer, String, and Buffer.
|
||||
*/
|
||||
if (source_desc->common.type == ACPI_TYPE_LOCAL_REFERENCE) {
|
||||
@ -167,7 +166,7 @@ acpi_ex_resolve_object(union acpi_operand_object **source_desc_ptr,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: "Store" an object to another object. This may include
|
||||
* DESCRIPTION: "Store" an object to another object. This may include
|
||||
* converting the source type to the target type (implicit
|
||||
* conversion), and a copy of the value of the source to
|
||||
* the target.
|
||||
@ -178,14 +177,14 @@ acpi_ex_resolve_object(union acpi_operand_object **source_desc_ptr,
|
||||
* with the input value.
|
||||
*
|
||||
* When storing into an object the data is converted to the
|
||||
* target object type then stored in the object. This means
|
||||
* target object type then stored in the object. This means
|
||||
* that the target object type (for an initialized target) will
|
||||
* not be changed by a store operation.
|
||||
*
|
||||
* This module allows destination types of Number, String,
|
||||
* Buffer, and Package.
|
||||
*
|
||||
* Assumes parameters are already validated. NOTE: source_desc
|
||||
* Assumes parameters are already validated. NOTE: source_desc
|
||||
* resolution (from a reference object) must be performed by
|
||||
* the caller if necessary.
|
||||
*
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exstorob - AML Interpreter object store support, store to object
|
||||
@ -108,7 +107,7 @@ acpi_ex_store_buffer_to_buffer(union acpi_operand_object *source_desc,
|
||||
#ifdef ACPI_OBSOLETE_BEHAVIOR
|
||||
/*
|
||||
* NOTE: ACPI versions up to 3.0 specified that the buffer must be
|
||||
* truncated if the string is smaller than the buffer. However, "other"
|
||||
* truncated if the string is smaller than the buffer. However, "other"
|
||||
* implementations of ACPI never did this and thus became the defacto
|
||||
* standard. ACPI 3.0A changes this behavior such that the buffer
|
||||
* is no longer truncated.
|
||||
@ -117,7 +116,7 @@ acpi_ex_store_buffer_to_buffer(union acpi_operand_object *source_desc,
|
||||
/*
|
||||
* OBSOLETE BEHAVIOR:
|
||||
* If the original source was a string, we must truncate the buffer,
|
||||
* according to the ACPI spec. Integer-to-Buffer and Buffer-to-Buffer
|
||||
* according to the ACPI spec. Integer-to-Buffer and Buffer-to-Buffer
|
||||
* copy must not truncate the original buffer.
|
||||
*/
|
||||
if (original_src_type == ACPI_TYPE_STRING) {
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exsystem - Interface to OS services
|
||||
@ -59,7 +58,7 @@ ACPI_MODULE_NAME("exsystem")
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Implements a semaphore wait with a check to see if the
|
||||
* semaphore is available immediately. If it is not, the
|
||||
* semaphore is available immediately. If it is not, the
|
||||
* interpreter is released before waiting.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -104,7 +103,7 @@ acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Implements a mutex wait with a check to see if the
|
||||
* mutex is available immediately. If it is not, the
|
||||
* mutex is available immediately. If it is not, the
|
||||
* interpreter is released before waiting.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -152,7 +151,7 @@ acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
|
||||
* DESCRIPTION: Suspend running thread for specified amount of time.
|
||||
* Note: ACPI specification requires that Stall() does not
|
||||
* relinquish the processor, and delays longer than 100 usec
|
||||
* should use Sleep() instead. We allow stalls up to 255 usec
|
||||
* should use Sleep() instead. We allow stalls up to 255 usec
|
||||
* for compatibility with other interpreters and existing BIOSs.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -254,7 +253,7 @@ acpi_status acpi_ex_system_signal_event(union acpi_operand_object * obj_desc)
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Provides an access point to perform synchronization operations
|
||||
* within the AML. This operation is a request to wait for an
|
||||
* within the AML. This operation is a request to wait for an
|
||||
* event.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: exutils - interpreter/scanner utilities
|
||||
@ -45,12 +44,12 @@
|
||||
/*
|
||||
* DEFINE_AML_GLOBALS is tested in amlcode.h
|
||||
* to determine whether certain global names should be "defined" or only
|
||||
* "declared" in the current compilation. This enhances maintainability
|
||||
* "declared" in the current compilation. This enhances maintainability
|
||||
* by enabling a single header file to embody all knowledge of the names
|
||||
* in question.
|
||||
*
|
||||
* Exactly one module of any executable should #define DEFINE_GLOBALS
|
||||
* before #including the header files which use this convention. The
|
||||
* before #including the header files which use this convention. The
|
||||
* names in question will be defined and initialized in that module,
|
||||
* and declared as extern in all other modules which #include those
|
||||
* header files.
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: hwacpi - ACPI Hardware Initialization/Mode Interface
|
||||
@ -136,7 +135,7 @@ acpi_status acpi_hw_set_mode(u32 mode)
|
||||
*
|
||||
* RETURN: SYS_MODE_ACPI or SYS_MODE_LEGACY
|
||||
*
|
||||
* DESCRIPTION: Return current operating state of system. Determined by
|
||||
* DESCRIPTION: Return current operating state of system. Determined by
|
||||
* querying the SCI_EN bit.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: hwgpe - Low level GPE enable/disable/clear functions
|
||||
@ -339,7 +338,8 @@ acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
|
||||
acpi_status
|
||||
acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
struct acpi_gpe_block_info *gpe_block, void *context)
|
||||
struct acpi_gpe_block_info * gpe_block,
|
||||
void *context)
|
||||
{
|
||||
u32 i;
|
||||
acpi_status status;
|
||||
|
||||
@ -259,7 +259,7 @@ acpi_hw_process_pci_list(struct acpi_pci_id *pci_id,
|
||||
status = acpi_hw_get_pci_device_info(pci_id, info->device,
|
||||
&bus_number, &is_bridge);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return_ACPI_STATUS(status);
|
||||
return (status);
|
||||
}
|
||||
|
||||
info = info->next;
|
||||
@ -271,7 +271,7 @@ acpi_hw_process_pci_list(struct acpi_pci_id *pci_id,
|
||||
pci_id->segment, pci_id->bus, pci_id->device,
|
||||
pci_id->function, status, bus_number, is_bridge));
|
||||
|
||||
return_ACPI_STATUS(AE_OK);
|
||||
return (AE_OK);
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* Module Name: hwregs - Read/write access functions for the various ACPI
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Name: hwtimer.c - ACPI Power Management Timer Interface
|
||||
@ -101,8 +100,7 @@ acpi_status acpi_get_timer(u32 * ticks)
|
||||
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
||||
}
|
||||
|
||||
status =
|
||||
acpi_hw_read(ticks, &acpi_gbl_FADT.xpm_timer_block);
|
||||
status = acpi_hw_read(ticks, &acpi_gbl_FADT.xpm_timer_block);
|
||||
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
@ -129,7 +127,7 @@ ACPI_EXPORT_SYMBOL(acpi_get_timer)
|
||||
* a versatile and accurate timer.
|
||||
*
|
||||
* Note that this function accommodates only a single timer
|
||||
* rollover. Thus for 24-bit timers, this function should only
|
||||
* rollover. Thus for 24-bit timers, this function should only
|
||||
* be used for calculating durations less than ~4.6 seconds
|
||||
* (~20 minutes for 32-bit timers) -- calculations below:
|
||||
*
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: hwvalid - I/O request validation
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* Module Name: hwxface - Public ACPICA hardware interfaces
|
||||
|
||||
@ -49,8 +49,7 @@
|
||||
ACPI_MODULE_NAME("hwxfsleep")
|
||||
|
||||
/* Local prototypes */
|
||||
static acpi_status
|
||||
acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id);
|
||||
static acpi_status acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id);
|
||||
|
||||
/*
|
||||
* Dispatch table used to efficiently branch to the various sleep
|
||||
@ -234,8 +233,7 @@ ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
|
||||
* function.
|
||||
*
|
||||
******************************************************************************/
|
||||
static acpi_status
|
||||
acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id)
|
||||
static acpi_status acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id)
|
||||
{
|
||||
acpi_status status;
|
||||
struct acpi_sleep_functions *sleep_functions =
|
||||
@ -369,8 +367,7 @@ acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
|
||||
return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
|
||||
}
|
||||
|
||||
status =
|
||||
acpi_hw_sleep_dispatch(sleep_state, ACPI_SLEEP_FUNCTION_ID);
|
||||
status = acpi_hw_sleep_dispatch(sleep_state, ACPI_SLEEP_FUNCTION_ID);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
@ -396,8 +393,7 @@ acpi_status acpi_leave_sleep_state_prep(u8 sleep_state)
|
||||
ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep);
|
||||
|
||||
status =
|
||||
acpi_hw_sleep_dispatch(sleep_state,
|
||||
ACPI_WAKE_PREP_FUNCTION_ID);
|
||||
acpi_hw_sleep_dispatch(sleep_state, ACPI_WAKE_PREP_FUNCTION_ID);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
|
||||
@ -110,11 +110,11 @@ acpi_status acpi_ns_root_initialize(void)
|
||||
status = acpi_ns_lookup(NULL, init_val->name, init_val->type,
|
||||
ACPI_IMODE_LOAD_PASS2,
|
||||
ACPI_NS_NO_UPSEARCH, NULL, &new_node);
|
||||
|
||||
if (ACPI_FAILURE(status) || (!new_node)) { /* Must be on same line for code converter */
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status,
|
||||
"Could not create predefined name %s",
|
||||
init_val->name));
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -179,8 +179,7 @@ acpi_status acpi_ns_root_initialize(void)
|
||||
|
||||
/* Build an object around the static string */
|
||||
|
||||
obj_desc->string.length =
|
||||
(u32) ACPI_STRLEN(val);
|
||||
obj_desc->string.length = (u32)ACPI_STRLEN(val);
|
||||
obj_desc->string.pointer = val;
|
||||
obj_desc->common.flags |= AOPOBJ_STATIC_POINTER;
|
||||
break;
|
||||
|
||||
@ -332,7 +332,7 @@ void acpi_ns_delete_children(struct acpi_namespace_node *parent_node)
|
||||
*
|
||||
* RETURN: None.
|
||||
*
|
||||
* DESCRIPTION: Delete a subtree of the namespace. This includes all objects
|
||||
* DESCRIPTION: Delete a subtree of the namespace. This includes all objects
|
||||
* stored within the subtree.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -418,7 +418,7 @@ void acpi_ns_delete_namespace_subtree(struct acpi_namespace_node *parent_node)
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Delete entries within the namespace that are owned by a
|
||||
* specific ID. Used to delete entire ACPI tables. All
|
||||
* specific ID. Used to delete entire ACPI tables. All
|
||||
* reference counts are updated.
|
||||
*
|
||||
* MUTEX: Locks namespace during deletion walk.
|
||||
|
||||
@ -209,14 +209,6 @@ acpi_ns_dump_one_object(acpi_handle obj_handle,
|
||||
"Invalid ACPI Object Type 0x%08X", type));
|
||||
}
|
||||
|
||||
if (!acpi_ut_valid_acpi_name(this_node->name.integer)) {
|
||||
this_node->name.integer =
|
||||
acpi_ut_repair_name(this_node->name.ascii);
|
||||
|
||||
ACPI_WARNING((AE_INFO, "Invalid ACPI Name %08X",
|
||||
this_node->name.integer));
|
||||
}
|
||||
|
||||
acpi_os_printf("%4.4s", acpi_ut_get_node_name(this_node));
|
||||
}
|
||||
|
||||
@ -700,7 +692,7 @@ void acpi_ns_dump_entry(acpi_handle handle, u32 debug_level)
|
||||
*
|
||||
* PARAMETERS: search_base - Root of subtree to be dumped, or
|
||||
* NS_ALL to dump the entire namespace
|
||||
* max_depth - Maximum depth of dump. Use INT_MAX
|
||||
* max_depth - Maximum depth of dump. Use INT_MAX
|
||||
* for an effectively unlimited depth.
|
||||
*
|
||||
* RETURN: None
|
||||
|
||||
@ -96,8 +96,8 @@ acpi_status acpi_ns_initialize_objects(void)
|
||||
/* Walk entire namespace from the supplied root */
|
||||
|
||||
status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
|
||||
ACPI_UINT32_MAX, acpi_ns_init_one_object, NULL,
|
||||
&info, NULL);
|
||||
ACPI_UINT32_MAX, acpi_ns_init_one_object,
|
||||
NULL, &info, NULL);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
|
||||
}
|
||||
|
||||
@ -80,8 +80,8 @@ acpi_ns_load_table(u32 table_index, struct acpi_namespace_node *node)
|
||||
|
||||
/*
|
||||
* Parse the table and load the namespace with all named
|
||||
* objects found within. Control methods are NOT parsed
|
||||
* at this time. In fact, the control methods cannot be
|
||||
* objects found within. Control methods are NOT parsed
|
||||
* at this time. In fact, the control methods cannot be
|
||||
* parsed until the entire namespace is loaded, because
|
||||
* if a control method makes a forward reference (call)
|
||||
* to another control method, we can't continue parsing
|
||||
@ -122,7 +122,7 @@ acpi_ns_load_table(u32 table_index, struct acpi_namespace_node *node)
|
||||
}
|
||||
|
||||
/*
|
||||
* Now we can parse the control methods. We always parse
|
||||
* Now we can parse the control methods. We always parse
|
||||
* them here for a sanity check, and if configured for
|
||||
* just-in-time parsing, we delete the control method
|
||||
* parse trees.
|
||||
@ -166,7 +166,7 @@ acpi_status acpi_ns_load_namespace(void)
|
||||
}
|
||||
|
||||
/*
|
||||
* Load the namespace. The DSDT is required,
|
||||
* Load the namespace. The DSDT is required,
|
||||
* but the SSDT and PSDT tables are optional.
|
||||
*/
|
||||
status = acpi_ns_load_table_by_type(ACPI_TABLE_ID_DSDT);
|
||||
@ -283,7 +283,7 @@ static acpi_status acpi_ns_delete_subtree(acpi_handle start_handle)
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Shrinks the namespace, typically in response to an undocking
|
||||
* event. Deletes an entire subtree starting from (and
|
||||
* event. Deletes an entire subtree starting from (and
|
||||
* including) the given handle.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -195,7 +195,7 @@ acpi_size acpi_ns_get_pathname_length(struct acpi_namespace_node *node)
|
||||
ACPI_ERROR((AE_INFO,
|
||||
"Invalid Namespace Node (%p) while traversing namespace",
|
||||
next_node));
|
||||
return 0;
|
||||
return (0);
|
||||
}
|
||||
size += ACPI_PATH_SEGMENT_LENGTH;
|
||||
next_node = next_node->parent;
|
||||
|
||||
@ -61,7 +61,7 @@ ACPI_MODULE_NAME("nsobject")
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Record the given object as the value associated with the
|
||||
* name whose acpi_handle is passed. If Object is NULL
|
||||
* name whose acpi_handle is passed. If Object is NULL
|
||||
* and Type is ACPI_TYPE_ANY, set the name as having no value.
|
||||
* Note: Future may require that the Node->Flags field be passed
|
||||
* as a parameter.
|
||||
@ -133,7 +133,7 @@ acpi_ns_attach_object(struct acpi_namespace_node *node,
|
||||
((struct acpi_namespace_node *)object)->object) {
|
||||
/*
|
||||
* Value passed is a name handle and that name has a
|
||||
* non-null value. Use that name's value and type.
|
||||
* non-null value. Use that name's value and type.
|
||||
*/
|
||||
obj_desc = ((struct acpi_namespace_node *)object)->object;
|
||||
object_type = ((struct acpi_namespace_node *)object)->type;
|
||||
@ -321,7 +321,7 @@ union acpi_operand_object *acpi_ns_get_secondary_object(union
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Low-level attach data. Create and attach a Data object.
|
||||
* DESCRIPTION: Low-level attach data. Create and attach a Data object.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -377,7 +377,7 @@ acpi_ns_attach_data(struct acpi_namespace_node *node,
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Low-level detach data. Delete the data node, but the caller
|
||||
* DESCRIPTION: Low-level detach data. Delete the data node, but the caller
|
||||
* is responsible for the actual data.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -168,11 +168,11 @@ acpi_ns_parse_table(u32 table_index, struct acpi_namespace_node *start_node)
|
||||
/*
|
||||
* AML Parse, pass 1
|
||||
*
|
||||
* In this pass, we load most of the namespace. Control methods
|
||||
* are not parsed until later. A parse tree is not created. Instead,
|
||||
* each Parser Op subtree is deleted when it is finished. This saves
|
||||
* In this pass, we load most of the namespace. Control methods
|
||||
* are not parsed until later. A parse tree is not created. Instead,
|
||||
* each Parser Op subtree is deleted when it is finished. This saves
|
||||
* a great deal of memory, and allows a small cache of parse objects
|
||||
* to service the entire parse. The second pass of the parse then
|
||||
* to service the entire parse. The second pass of the parse then
|
||||
* performs another complete parse of the AML.
|
||||
*/
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "**** Start pass 1\n"));
|
||||
|
||||
@ -314,22 +314,7 @@ acpi_ns_search_and_enter(u32 target_name,
|
||||
* this problem, and we want to be able to enable ACPI support for them,
|
||||
* even though there are a few bad names.
|
||||
*/
|
||||
if (!acpi_ut_valid_acpi_name(target_name)) {
|
||||
target_name =
|
||||
acpi_ut_repair_name(ACPI_CAST_PTR(char, &target_name));
|
||||
|
||||
/* Report warning only if in strict mode or debug mode */
|
||||
|
||||
if (!acpi_gbl_enable_interpreter_slack) {
|
||||
ACPI_WARNING((AE_INFO,
|
||||
"Found bad character(s) in name, repaired: [%4.4s]\n",
|
||||
ACPI_CAST_PTR(char, &target_name)));
|
||||
} else {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
||||
"Found bad character(s) in name, repaired: [%4.4s]\n",
|
||||
ACPI_CAST_PTR(char, &target_name)));
|
||||
}
|
||||
}
|
||||
acpi_ut_repair_name(ACPI_CAST_PTR(char, &target_name));
|
||||
|
||||
/* Try to find the name in the namespace level specified by the caller */
|
||||
|
||||
|
||||
@ -530,7 +530,7 @@ acpi_ns_externalize_name(u32 internal_name_length,
|
||||
((num_segments > 0) ? (num_segments - 1) : 0) + 1;
|
||||
|
||||
/*
|
||||
* Check to see if we're still in bounds. If not, there's a problem
|
||||
* Check to see if we're still in bounds. If not, there's a problem
|
||||
* with internal_name (invalid format).
|
||||
*/
|
||||
if (required_length > internal_name_length) {
|
||||
@ -557,10 +557,14 @@ acpi_ns_externalize_name(u32 internal_name_length,
|
||||
(*converted_name)[j++] = '.';
|
||||
}
|
||||
|
||||
(*converted_name)[j++] = internal_name[names_index++];
|
||||
(*converted_name)[j++] = internal_name[names_index++];
|
||||
(*converted_name)[j++] = internal_name[names_index++];
|
||||
(*converted_name)[j++] = internal_name[names_index++];
|
||||
/* Copy and validate the 4-char name segment */
|
||||
|
||||
ACPI_MOVE_NAME(&(*converted_name)[j],
|
||||
&internal_name[names_index]);
|
||||
acpi_ut_repair_name(&(*converted_name)[j]);
|
||||
|
||||
j += ACPI_NAME_SIZE;
|
||||
names_index += ACPI_NAME_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
@ -681,7 +685,7 @@ u32 acpi_ns_opens_scope(acpi_object_type type)
|
||||
* \ (backslash) and ^ (carat) prefixes, and the
|
||||
* . (period) to separate segments are supported.
|
||||
* prefix_node - Root of subtree to be searched, or NS_ALL for the
|
||||
* root of the name space. If Name is fully
|
||||
* root of the name space. If Name is fully
|
||||
* qualified (first s8 is '\'), the passed value
|
||||
* of Scope will not be accessed.
|
||||
* flags - Used to indicate whether to perform upsearch or
|
||||
@ -689,7 +693,7 @@ u32 acpi_ns_opens_scope(acpi_object_type type)
|
||||
* return_node - Where the Node is returned
|
||||
*
|
||||
* DESCRIPTION: Look up a name relative to a given scope and return the
|
||||
* corresponding Node. NOTE: Scope can be null.
|
||||
* corresponding Node. NOTE: Scope can be null.
|
||||
*
|
||||
* MUTEX: Locks namespace
|
||||
*
|
||||
|
||||
@ -60,8 +60,8 @@ ACPI_MODULE_NAME("nswalk")
|
||||
* RETURN: struct acpi_namespace_node - Pointer to the NEXT child or NULL if
|
||||
* none is found.
|
||||
*
|
||||
* DESCRIPTION: Return the next peer node within the namespace. If Handle
|
||||
* is valid, Scope is ignored. Otherwise, the first node
|
||||
* DESCRIPTION: Return the next peer node within the namespace. If Handle
|
||||
* is valid, Scope is ignored. Otherwise, the first node
|
||||
* within Scope is returned.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -97,8 +97,8 @@ struct acpi_namespace_node *acpi_ns_get_next_node(struct acpi_namespace_node
|
||||
* RETURN: struct acpi_namespace_node - Pointer to the NEXT child or NULL if
|
||||
* none is found.
|
||||
*
|
||||
* DESCRIPTION: Return the next peer node within the namespace. If Handle
|
||||
* is valid, Scope is ignored. Otherwise, the first node
|
||||
* DESCRIPTION: Return the next peer node within the namespace. If Handle
|
||||
* is valid, Scope is ignored. Otherwise, the first node
|
||||
* within Scope is returned.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -305,7 +305,7 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
||||
|
||||
/*
|
||||
* Depth first search: Attempt to go down another level in the
|
||||
* namespace if we are allowed to. Don't go any further if we have
|
||||
* namespace if we are allowed to. Don't go any further if we have
|
||||
* reached the caller specified maximum depth or if the user
|
||||
* function has specified that the maximum depth has been reached.
|
||||
*/
|
||||
|
||||
@ -61,16 +61,16 @@ static void acpi_ns_resolve_references(struct acpi_evaluate_info *info);
|
||||
* PARAMETERS: handle - Object handle (optional)
|
||||
* pathname - Object pathname (optional)
|
||||
* external_params - List of parameters to pass to method,
|
||||
* terminated by NULL. May be NULL
|
||||
* terminated by NULL. May be NULL
|
||||
* if no parameters are being passed.
|
||||
* return_buffer - Where to put method's return value (if
|
||||
* any). If NULL, no value is returned.
|
||||
* any). If NULL, no value is returned.
|
||||
* return_type - Expected type of return object
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Find and evaluate the given object, passing the given
|
||||
* parameters if necessary. One of "Handle" or "Pathname" must
|
||||
* parameters if necessary. One of "Handle" or "Pathname" must
|
||||
* be valid (non-null)
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -155,15 +155,15 @@ ACPI_EXPORT_SYMBOL(acpi_evaluate_object_typed)
|
||||
* PARAMETERS: handle - Object handle (optional)
|
||||
* pathname - Object pathname (optional)
|
||||
* external_params - List of parameters to pass to method,
|
||||
* terminated by NULL. May be NULL
|
||||
* terminated by NULL. May be NULL
|
||||
* if no parameters are being passed.
|
||||
* return_buffer - Where to put method's return value (if
|
||||
* any). If NULL, no value is returned.
|
||||
* any). If NULL, no value is returned.
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Find and evaluate the given object, passing the given
|
||||
* parameters if necessary. One of "Handle" or "Pathname" must
|
||||
* parameters if necessary. One of "Handle" or "Pathname" must
|
||||
* be valid (non-null)
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -542,15 +542,15 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
|
||||
acpi_status status;
|
||||
struct acpi_namespace_node *node;
|
||||
u32 flags;
|
||||
struct acpica_device_id *hid;
|
||||
struct acpica_device_id_list *cid;
|
||||
struct acpi_pnp_device_id *hid;
|
||||
struct acpi_pnp_device_id_list *cid;
|
||||
u32 i;
|
||||
u8 found;
|
||||
int no_match;
|
||||
|
||||
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return (status);
|
||||
return_ACPI_STATUS(status);
|
||||
}
|
||||
|
||||
node = acpi_ns_validate_handle(obj_handle);
|
||||
@ -656,7 +656,7 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
|
||||
* DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
|
||||
* starting (and ending) at the object specified by start_handle.
|
||||
* The user_function is called whenever an object of type
|
||||
* Device is found. If the user function returns
|
||||
* Device is found. If the user function returns
|
||||
* a non-zero value, the search is terminated immediately and this
|
||||
* value is returned to the caller.
|
||||
*
|
||||
|
||||
@ -53,8 +53,8 @@
|
||||
ACPI_MODULE_NAME("nsxfname")
|
||||
|
||||
/* Local prototypes */
|
||||
static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
|
||||
struct acpica_device_id *source,
|
||||
static char *acpi_ns_copy_device_id(struct acpi_pnp_device_id *dest,
|
||||
struct acpi_pnp_device_id *source,
|
||||
char *string_area);
|
||||
|
||||
/******************************************************************************
|
||||
@ -69,8 +69,8 @@ static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: This routine will search for a caller specified name in the
|
||||
* name space. The caller can restrict the search region by
|
||||
* specifying a non NULL parent. The parent value is itself a
|
||||
* name space. The caller can restrict the search region by
|
||||
* specifying a non NULL parent. The parent value is itself a
|
||||
* namespace handle.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -149,7 +149,7 @@ ACPI_EXPORT_SYMBOL(acpi_get_handle)
|
||||
* RETURN: Pointer to a string containing the fully qualified Name.
|
||||
*
|
||||
* DESCRIPTION: This routine returns the fully qualified name associated with
|
||||
* the Handle parameter. This and the acpi_pathname_to_handle are
|
||||
* the Handle parameter. This and the acpi_pathname_to_handle are
|
||||
* complementary functions.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -202,8 +202,7 @@ acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
|
||||
|
||||
/* Just copy the ACPI name from the Node and zero terminate it */
|
||||
|
||||
ACPI_STRNCPY(buffer->pointer, acpi_ut_get_node_name(node),
|
||||
ACPI_NAME_SIZE);
|
||||
ACPI_MOVE_NAME(buffer->pointer, acpi_ut_get_node_name(node));
|
||||
((char *)buffer->pointer)[ACPI_NAME_SIZE] = 0;
|
||||
status = AE_OK;
|
||||
|
||||
@ -219,20 +218,21 @@ ACPI_EXPORT_SYMBOL(acpi_get_name)
|
||||
*
|
||||
* FUNCTION: acpi_ns_copy_device_id
|
||||
*
|
||||
* PARAMETERS: dest - Pointer to the destination DEVICE_ID
|
||||
* source - Pointer to the source DEVICE_ID
|
||||
* PARAMETERS: dest - Pointer to the destination PNP_DEVICE_ID
|
||||
* source - Pointer to the source PNP_DEVICE_ID
|
||||
* string_area - Pointer to where to copy the dest string
|
||||
*
|
||||
* RETURN: Pointer to the next string area
|
||||
*
|
||||
* DESCRIPTION: Copy a single DEVICE_ID, including the string data.
|
||||
* DESCRIPTION: Copy a single PNP_DEVICE_ID, including the string data.
|
||||
*
|
||||
******************************************************************************/
|
||||
static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
|
||||
struct acpica_device_id *source,
|
||||
static char *acpi_ns_copy_device_id(struct acpi_pnp_device_id *dest,
|
||||
struct acpi_pnp_device_id *source,
|
||||
char *string_area)
|
||||
{
|
||||
/* Create the destination DEVICE_ID */
|
||||
|
||||
/* Create the destination PNP_DEVICE_ID */
|
||||
|
||||
dest->string = string_area;
|
||||
dest->length = source->length;
|
||||
@ -256,8 +256,8 @@ static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
|
||||
* namespace node and possibly by running several standard
|
||||
* control methods (Such as in the case of a device.)
|
||||
*
|
||||
* For Device and Processor objects, run the Device _HID, _UID, _CID, _STA,
|
||||
* _ADR, _sx_w, and _sx_d methods.
|
||||
* For Device and Processor objects, run the Device _HID, _UID, _CID, _SUB,
|
||||
* _STA, _ADR, _sx_w, and _sx_d methods.
|
||||
*
|
||||
* Note: Allocates the return buffer, must be freed by the caller.
|
||||
*
|
||||
@ -269,9 +269,10 @@ acpi_get_object_info(acpi_handle handle,
|
||||
{
|
||||
struct acpi_namespace_node *node;
|
||||
struct acpi_device_info *info;
|
||||
struct acpica_device_id_list *cid_list = NULL;
|
||||
struct acpica_device_id *hid = NULL;
|
||||
struct acpica_device_id *uid = NULL;
|
||||
struct acpi_pnp_device_id_list *cid_list = NULL;
|
||||
struct acpi_pnp_device_id *hid = NULL;
|
||||
struct acpi_pnp_device_id *uid = NULL;
|
||||
struct acpi_pnp_device_id *sub = NULL;
|
||||
char *next_id_string;
|
||||
acpi_object_type type;
|
||||
acpi_name name;
|
||||
@ -316,7 +317,7 @@ acpi_get_object_info(acpi_handle handle,
|
||||
if ((type == ACPI_TYPE_DEVICE) || (type == ACPI_TYPE_PROCESSOR)) {
|
||||
/*
|
||||
* Get extra info for ACPI Device/Processor objects only:
|
||||
* Run the Device _HID, _UID, and _CID methods.
|
||||
* Run the Device _HID, _UID, _SUB, and _CID methods.
|
||||
*
|
||||
* Note: none of these methods are required, so they may or may
|
||||
* not be present for this device. The Info->Valid bitfield is used
|
||||
@ -339,6 +340,14 @@ acpi_get_object_info(acpi_handle handle,
|
||||
valid |= ACPI_VALID_UID;
|
||||
}
|
||||
|
||||
/* Execute the Device._SUB method */
|
||||
|
||||
status = acpi_ut_execute_SUB(node, &sub);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
info_size += sub->length;
|
||||
valid |= ACPI_VALID_SUB;
|
||||
}
|
||||
|
||||
/* Execute the Device._CID method */
|
||||
|
||||
status = acpi_ut_execute_CID(node, &cid_list);
|
||||
@ -348,7 +357,7 @@ acpi_get_object_info(acpi_handle handle,
|
||||
|
||||
info_size +=
|
||||
(cid_list->list_size -
|
||||
sizeof(struct acpica_device_id_list));
|
||||
sizeof(struct acpi_pnp_device_id_list));
|
||||
valid |= ACPI_VALID_CID;
|
||||
}
|
||||
}
|
||||
@ -418,16 +427,17 @@ acpi_get_object_info(acpi_handle handle,
|
||||
next_id_string = ACPI_CAST_PTR(char, info->compatible_id_list.ids);
|
||||
if (cid_list) {
|
||||
|
||||
/* Point past the CID DEVICE_ID array */
|
||||
/* Point past the CID PNP_DEVICE_ID array */
|
||||
|
||||
next_id_string +=
|
||||
((acpi_size) cid_list->count *
|
||||
sizeof(struct acpica_device_id));
|
||||
sizeof(struct acpi_pnp_device_id));
|
||||
}
|
||||
|
||||
/*
|
||||
* Copy the HID, UID, and CIDs to the return buffer. The variable-length
|
||||
* strings are copied to the reserved area at the end of the buffer.
|
||||
* Copy the HID, UID, SUB, and CIDs to the return buffer.
|
||||
* The variable-length strings are copied to the reserved area
|
||||
* at the end of the buffer.
|
||||
*
|
||||
* For HID and CID, check if the ID is a PCI Root Bridge.
|
||||
*/
|
||||
@ -445,6 +455,11 @@ acpi_get_object_info(acpi_handle handle,
|
||||
uid, next_id_string);
|
||||
}
|
||||
|
||||
if (sub) {
|
||||
next_id_string = acpi_ns_copy_device_id(&info->subsystem_id,
|
||||
sub, next_id_string);
|
||||
}
|
||||
|
||||
if (cid_list) {
|
||||
info->compatible_id_list.count = cid_list->count;
|
||||
info->compatible_id_list.list_size = cid_list->list_size;
|
||||
@ -481,6 +496,9 @@ acpi_get_object_info(acpi_handle handle,
|
||||
if (uid) {
|
||||
ACPI_FREE(uid);
|
||||
}
|
||||
if (sub) {
|
||||
ACPI_FREE(sub);
|
||||
}
|
||||
if (cid_list) {
|
||||
ACPI_FREE(cid_list);
|
||||
}
|
||||
|
||||
@ -220,8 +220,8 @@ ACPI_EXPORT_SYMBOL(acpi_get_parent)
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Return the next peer object within the namespace. If Handle is
|
||||
* valid, Scope is ignored. Otherwise, the first object within
|
||||
* DESCRIPTION: Return the next peer object within the namespace. If Handle is
|
||||
* valid, Scope is ignored. Otherwise, the first object within
|
||||
* Scope is returned.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -120,7 +120,7 @@ acpi_ps_get_next_package_length(struct acpi_parse_state *parser_state)
|
||||
* RETURN: Pointer to end-of-package +1
|
||||
*
|
||||
* DESCRIPTION: Get next package length and return a pointer past the end of
|
||||
* the package. Consumes the package length field
|
||||
* the package. Consumes the package length field
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -147,8 +147,8 @@ u8 *acpi_ps_get_next_package_end(struct acpi_parse_state *parser_state)
|
||||
* RETURN: Pointer to the start of the name string (pointer points into
|
||||
* the AML.
|
||||
*
|
||||
* DESCRIPTION: Get next raw namestring within the AML stream. Handles all name
|
||||
* prefix characters. Set parser state to point past the string.
|
||||
* DESCRIPTION: Get next raw namestring within the AML stream. Handles all name
|
||||
* prefix characters. Set parser state to point past the string.
|
||||
* (Name is consumed from the AML.)
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -220,7 +220,7 @@ char *acpi_ps_get_next_namestring(struct acpi_parse_state *parser_state)
|
||||
*
|
||||
* DESCRIPTION: Get next name (if method call, return # of required args).
|
||||
* Names are looked up in the internal namespace to determine
|
||||
* if the name represents a control method. If a method
|
||||
* if the name represents a control method. If a method
|
||||
* is found, the number of arguments to the method is returned.
|
||||
* This information is critical for parsing to continue correctly.
|
||||
*
|
||||
|
||||
@ -133,18 +133,46 @@ static acpi_status acpi_ps_get_aml_opcode(struct acpi_walk_state *walk_state)
|
||||
|
||||
case AML_CLASS_UNKNOWN:
|
||||
|
||||
/* The opcode is unrecognized. Just skip unknown opcodes */
|
||||
/* The opcode is unrecognized. Complain and skip unknown opcodes */
|
||||
|
||||
ACPI_ERROR((AE_INFO,
|
||||
"Found unknown opcode 0x%X at AML address %p offset 0x%X, ignoring",
|
||||
walk_state->opcode, walk_state->parser_state.aml,
|
||||
walk_state->aml_offset));
|
||||
if (walk_state->pass_number == 2) {
|
||||
ACPI_ERROR((AE_INFO,
|
||||
"Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring",
|
||||
walk_state->opcode,
|
||||
(u32)(walk_state->aml_offset +
|
||||
sizeof(struct acpi_table_header))));
|
||||
|
||||
ACPI_DUMP_BUFFER(walk_state->parser_state.aml, 128);
|
||||
ACPI_DUMP_BUFFER(walk_state->parser_state.aml - 16, 48);
|
||||
|
||||
/* Assume one-byte bad opcode */
|
||||
#ifdef ACPI_ASL_COMPILER
|
||||
/*
|
||||
* This is executed for the disassembler only. Output goes
|
||||
* to the disassembled ASL output file.
|
||||
*/
|
||||
acpi_os_printf
|
||||
("/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n",
|
||||
walk_state->opcode,
|
||||
(u32)(walk_state->aml_offset +
|
||||
sizeof(struct acpi_table_header)));
|
||||
|
||||
/* Dump the context surrounding the invalid opcode */
|
||||
|
||||
acpi_ut_dump_buffer(((u8 *)walk_state->parser_state.
|
||||
aml - 16), 48, DB_BYTE_DISPLAY,
|
||||
walk_state->aml_offset +
|
||||
sizeof(struct acpi_table_header) -
|
||||
16);
|
||||
acpi_os_printf(" */\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Increment past one-byte or two-byte opcode */
|
||||
|
||||
walk_state->parser_state.aml++;
|
||||
if (walk_state->opcode > 0xFF) { /* Can only happen if first byte is 0x5B */
|
||||
walk_state->parser_state.aml++;
|
||||
}
|
||||
|
||||
return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
|
||||
|
||||
default:
|
||||
@ -519,11 +547,18 @@ acpi_ps_get_arguments(struct acpi_walk_state *walk_state,
|
||||
if ((op_info->class ==
|
||||
AML_CLASS_EXECUTE) && (!arg)) {
|
||||
ACPI_WARNING((AE_INFO,
|
||||
"Detected an unsupported executable opcode "
|
||||
"at module-level: [0x%.4X] at table offset 0x%.4X",
|
||||
op->common.aml_opcode,
|
||||
(u32)((aml_op_start - walk_state->parser_state.aml_start)
|
||||
+ sizeof(struct acpi_table_header))));
|
||||
"Unsupported module-level executable opcode "
|
||||
"0x%.2X at table offset 0x%.4X",
|
||||
op->common.
|
||||
aml_opcode,
|
||||
(u32)
|
||||
(ACPI_PTR_DIFF
|
||||
(aml_op_start,
|
||||
walk_state->
|
||||
parser_state.
|
||||
aml_start) +
|
||||
sizeof(struct
|
||||
acpi_table_header))));
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -843,8 +878,6 @@ acpi_ps_complete_op(struct acpi_walk_state *walk_state,
|
||||
*op = NULL;
|
||||
}
|
||||
|
||||
ACPI_PREEMPTION_POINT();
|
||||
|
||||
return_ACPI_STATUS(AE_OK);
|
||||
}
|
||||
|
||||
|
||||
@ -59,7 +59,7 @@ static const u8 acpi_gbl_argument_count[] =
|
||||
*
|
||||
* DESCRIPTION: Opcode table. Each entry contains <opcode, type, name, operands>
|
||||
* The name is a simple ascii string, the operand specifier is an
|
||||
* ascii string with one letter per operand. The letter specifies
|
||||
* ascii string with one letter per operand. The letter specifies
|
||||
* the operand type.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -183,7 +183,7 @@ static const u8 acpi_gbl_argument_count[] =
|
||||
******************************************************************************/
|
||||
|
||||
/*
|
||||
* Master Opcode information table. A summary of everything we know about each
|
||||
* Master Opcode information table. A summary of everything we know about each
|
||||
* opcode, all in one place.
|
||||
*/
|
||||
const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES] = {
|
||||
@ -392,10 +392,12 @@ const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES] = {
|
||||
AML_FLAGS_EXEC_1A_0T_1R | AML_NO_OPERAND_RESOLVE),
|
||||
/* 38 */ ACPI_OP("LAnd", ARGP_LAND_OP, ARGI_LAND_OP, ACPI_TYPE_ANY,
|
||||
AML_CLASS_EXECUTE, AML_TYPE_EXEC_2A_0T_1R,
|
||||
AML_FLAGS_EXEC_2A_0T_1R | AML_LOGICAL_NUMERIC | AML_CONSTANT),
|
||||
AML_FLAGS_EXEC_2A_0T_1R | AML_LOGICAL_NUMERIC |
|
||||
AML_CONSTANT),
|
||||
/* 39 */ ACPI_OP("LOr", ARGP_LOR_OP, ARGI_LOR_OP, ACPI_TYPE_ANY,
|
||||
AML_CLASS_EXECUTE, AML_TYPE_EXEC_2A_0T_1R,
|
||||
AML_FLAGS_EXEC_2A_0T_1R | AML_LOGICAL_NUMERIC | AML_CONSTANT),
|
||||
AML_FLAGS_EXEC_2A_0T_1R | AML_LOGICAL_NUMERIC |
|
||||
AML_CONSTANT),
|
||||
/* 3A */ ACPI_OP("LNot", ARGP_LNOT_OP, ARGI_LNOT_OP, ACPI_TYPE_ANY,
|
||||
AML_CLASS_EXECUTE, AML_TYPE_EXEC_1A_0T_1R,
|
||||
AML_FLAGS_EXEC_1A_0T_1R | AML_CONSTANT),
|
||||
@ -495,7 +497,8 @@ const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES] = {
|
||||
AML_NSNODE | AML_NAMED | AML_DEFER),
|
||||
/* 59 */ ACPI_OP("Field", ARGP_FIELD_OP, ARGI_FIELD_OP, ACPI_TYPE_ANY,
|
||||
AML_CLASS_NAMED_OBJECT, AML_TYPE_NAMED_FIELD,
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE | AML_FIELD),
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE |
|
||||
AML_FIELD),
|
||||
/* 5A */ ACPI_OP("Device", ARGP_DEVICE_OP, ARGI_DEVICE_OP,
|
||||
ACPI_TYPE_DEVICE, AML_CLASS_NAMED_OBJECT,
|
||||
AML_TYPE_NAMED_NO_OBJ,
|
||||
@ -519,12 +522,13 @@ const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES] = {
|
||||
/* 5E */ ACPI_OP("IndexField", ARGP_INDEX_FIELD_OP, ARGI_INDEX_FIELD_OP,
|
||||
ACPI_TYPE_ANY, AML_CLASS_NAMED_OBJECT,
|
||||
AML_TYPE_NAMED_FIELD,
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE | AML_FIELD),
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE |
|
||||
AML_FIELD),
|
||||
/* 5F */ ACPI_OP("BankField", ARGP_BANK_FIELD_OP, ARGI_BANK_FIELD_OP,
|
||||
ACPI_TYPE_LOCAL_BANK_FIELD, AML_CLASS_NAMED_OBJECT,
|
||||
AML_TYPE_NAMED_FIELD,
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE | AML_FIELD |
|
||||
AML_DEFER),
|
||||
ACPI_TYPE_LOCAL_BANK_FIELD,
|
||||
AML_CLASS_NAMED_OBJECT, AML_TYPE_NAMED_FIELD,
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE |
|
||||
AML_FIELD | AML_DEFER),
|
||||
|
||||
/* Internal opcodes that map to invalid AML opcodes */
|
||||
|
||||
@ -632,7 +636,8 @@ const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES] = {
|
||||
/* 7D */ ACPI_OP("[EvalSubTree]", ARGP_SCOPE_OP, ARGI_SCOPE_OP,
|
||||
ACPI_TYPE_ANY, AML_CLASS_NAMED_OBJECT,
|
||||
AML_TYPE_NAMED_NO_OBJ,
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE | AML_NSNODE),
|
||||
AML_HAS_ARGS | AML_NSOBJECT | AML_NSOPCODE |
|
||||
AML_NSNODE),
|
||||
|
||||
/* ACPI 3.0 opcodes */
|
||||
|
||||
@ -695,7 +700,7 @@ static const u8 acpi_gbl_short_op_index[256] = {
|
||||
|
||||
/*
|
||||
* This table is indexed by the second opcode of the extended opcode
|
||||
* pair. It returns an index into the opcode table (acpi_gbl_aml_op_info)
|
||||
* pair. It returns an index into the opcode table (acpi_gbl_aml_op_info)
|
||||
*/
|
||||
static const u8 acpi_gbl_long_op_index[NUM_EXTENDED_OPCODE] = {
|
||||
/* 0 1 2 3 4 5 6 7 */
|
||||
|
||||
@ -43,9 +43,9 @@
|
||||
|
||||
/*
|
||||
* Parse the AML and build an operation tree as most interpreters,
|
||||
* like Perl, do. Parsing is done by hand rather than with a YACC
|
||||
* like Perl, do. Parsing is done by hand rather than with a YACC
|
||||
* generated parser to tightly constrain stack and dynamic memory
|
||||
* usage. At the same time, parsing is kept flexible and the code
|
||||
* usage. At the same time, parsing is kept flexible and the code
|
||||
* fairly compact by parsing based on a list of AML opcode
|
||||
* templates in aml_op_info[]
|
||||
*/
|
||||
@ -379,7 +379,7 @@ acpi_ps_next_parse_state(struct acpi_walk_state *walk_state,
|
||||
case AE_CTRL_FALSE:
|
||||
/*
|
||||
* Either an IF/WHILE Predicate was false or we encountered a BREAK
|
||||
* opcode. In both cases, we do not execute the rest of the
|
||||
* opcode. In both cases, we do not execute the rest of the
|
||||
* package; We simply close out the parent (finishing the walk of
|
||||
* this branch of the tree) and continue execution at the parent
|
||||
* level.
|
||||
@ -459,8 +459,9 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
|
||||
|
||||
/* Executing a control method - additional cleanup */
|
||||
|
||||
acpi_ds_terminate_control_method(
|
||||
walk_state->method_desc, walk_state);
|
||||
acpi_ds_terminate_control_method(walk_state->
|
||||
method_desc,
|
||||
walk_state);
|
||||
}
|
||||
|
||||
acpi_ds_delete_walk_state(walk_state);
|
||||
@ -487,7 +488,7 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
|
||||
acpi_gbl_current_walk_list = thread;
|
||||
|
||||
/*
|
||||
* Execute the walk loop as long as there is a valid Walk State. This
|
||||
* Execute the walk loop as long as there is a valid Walk State. This
|
||||
* handles nested control method invocations without recursion.
|
||||
*/
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "State=%p\n", walk_state));
|
||||
|
||||
@ -108,7 +108,7 @@ void acpi_ps_init_op(union acpi_parse_object *op, u16 opcode)
|
||||
* RETURN: Pointer to the new Op, null on failure
|
||||
*
|
||||
* DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on
|
||||
* opcode. A cache of opcodes is available for the pure
|
||||
* opcode. A cache of opcodes is available for the pure
|
||||
* GENERIC_OP, since this is by far the most commonly used.
|
||||
*
|
||||
******************************************************************************/
|
||||
@ -164,7 +164,7 @@ union acpi_parse_object *acpi_ps_alloc_op(u16 opcode)
|
||||
*
|
||||
* RETURN: None.
|
||||
*
|
||||
* DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list
|
||||
* DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list
|
||||
* or actually free it.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -457,6 +457,15 @@ acpi_rs_get_list_length(u8 * aml_buffer,
|
||||
* Get the number of vendor data bytes
|
||||
*/
|
||||
extra_struct_bytes = resource_length;
|
||||
|
||||
/*
|
||||
* There is already one byte included in the minimum
|
||||
* descriptor size. If there are extra struct bytes,
|
||||
* subtract one from the count.
|
||||
*/
|
||||
if (extra_struct_bytes) {
|
||||
extra_struct_bytes--;
|
||||
}
|
||||
break;
|
||||
|
||||
case ACPI_RESOURCE_NAME_END_TAG:
|
||||
@ -601,7 +610,7 @@ acpi_rs_get_pci_routing_table_length(union acpi_operand_object *package_object,
|
||||
/*
|
||||
* Calculate the size of the return buffer.
|
||||
* The base size is the number of elements * the sizes of the
|
||||
* structures. Additional space for the strings is added below.
|
||||
* structures. Additional space for the strings is added below.
|
||||
* The minus one is to subtract the size of the u8 Source[1]
|
||||
* member because it is added below.
|
||||
*
|
||||
@ -664,8 +673,7 @@ acpi_rs_get_pci_routing_table_length(union acpi_operand_object *package_object,
|
||||
(*sub_object_list)->string.
|
||||
length + 1);
|
||||
} else {
|
||||
temp_size_needed +=
|
||||
acpi_ns_get_pathname_length((*sub_object_list)->reference.node);
|
||||
temp_size_needed += acpi_ns_get_pathname_length((*sub_object_list)->reference.node);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user