Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6
* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6: (68 commits) ACPI: replace kmalloc+memset with kzalloc ACPI: Add support for acpi_load_table/acpi_unload_table_id fbdev: update after backlight argument change ACPI: video: Add dev argument for backlight_device_register ACPI: Implement acpi_video_get_next_level() ACPI: Kconfig - depend on PM rather than selecting it ACPI: fix NULL check in drivers/acpi/osl.c ACPI: make drivers/acpi/ec.c:ec_ecdt static ACPI: prevent processor module from loading on failures ACPI: fix single linked list manipulation ACPI: ibm_acpi: allow clean removal ACPI: fix git automerge failure ACPI: ibm_acpi: respond to workqueue update ACPI: dock: add uevent to indicate change in device status ACPI: ec: Lindent once again ACPI: ec: Change #define to enums there possible. ACPI: ec: Style changes. ACPI: ec: Acquire Global Lock under EC mutex. ACPI: ec: Drop udelay() from poll mode. Loop by reading status field instead. ACPI: ec: Rename gpe_bit to gpe ...
This commit is contained in:
commit
18ed1c0513
|
@ -398,26 +398,68 @@ Temperature sensors -- /proc/acpi/ibm/thermal
|
|||
|
||||
Most ThinkPads include six or more separate temperature sensors but
|
||||
only expose the CPU temperature through the standard ACPI methods.
|
||||
This feature shows readings from up to eight different sensors. Some
|
||||
readings may not be valid, e.g. may show large negative values. For
|
||||
example, on the X40, a typical output may be:
|
||||
|
||||
temperatures: 42 42 45 41 36 -128 33 -128
|
||||
|
||||
Thomas Gruber took his R51 apart and traced all six active sensors in
|
||||
his laptop (the location of sensors may vary on other models):
|
||||
|
||||
1: CPU
|
||||
2: Mini PCI Module
|
||||
3: HDD
|
||||
4: GPU
|
||||
5: Battery
|
||||
6: N/A
|
||||
7: Battery
|
||||
8: N/A
|
||||
This feature shows readings from up to eight different sensors on older
|
||||
ThinkPads, and it has experimental support for up to sixteen different
|
||||
sensors on newer ThinkPads. Readings from sensors that are not available
|
||||
return -128.
|
||||
|
||||
No commands can be written to this file.
|
||||
|
||||
EXPERIMENTAL: The 16-sensors feature is marked EXPERIMENTAL because the
|
||||
implementation directly accesses hardware registers and may not work as
|
||||
expected. USE WITH CAUTION! To use this feature, you need to supply the
|
||||
experimental=1 parameter when loading the module. When EXPERIMENTAL
|
||||
mode is enabled, reading the first 8 sensors on newer ThinkPads will
|
||||
also use an new experimental thermal sensor access mode.
|
||||
|
||||
For example, on the X40, a typical output may be:
|
||||
temperatures: 42 42 45 41 36 -128 33 -128
|
||||
|
||||
EXPERIMENTAL: On the T43/p, a typical output may be:
|
||||
temperatures: 48 48 36 52 38 -128 31 -128 48 52 48 -128 -128 -128 -128 -128
|
||||
|
||||
The mapping of thermal sensors to physical locations varies depending on
|
||||
system-board model (and thus, on ThinkPad model).
|
||||
|
||||
http://thinkwiki.org/wiki/Thermal_Sensors is a public wiki page that
|
||||
tries to track down these locations for various models.
|
||||
|
||||
Most (newer?) models seem to follow this pattern:
|
||||
|
||||
1: CPU
|
||||
2: (depends on model)
|
||||
3: (depends on model)
|
||||
4: GPU
|
||||
5: Main battery: main sensor
|
||||
6: Bay battery: main sensor
|
||||
7: Main battery: secondary sensor
|
||||
8: Bay battery: secondary sensor
|
||||
9-15: (depends on model)
|
||||
|
||||
For the R51 (source: Thomas Gruber):
|
||||
2: Mini-PCI
|
||||
3: Internal HDD
|
||||
|
||||
For the T43, T43/p (source: Shmidoax/Thinkwiki.org)
|
||||
http://thinkwiki.org/wiki/Thermal_Sensors#ThinkPad_T43.2C_T43p
|
||||
2: System board, left side (near PCMCIA slot), reported as HDAPS temp
|
||||
3: PCMCIA slot
|
||||
9: MCH (northbridge) to DRAM Bus
|
||||
10: ICH (southbridge), under Mini-PCI card, under touchpad
|
||||
11: Power regulator, underside of system board, below F2 key
|
||||
|
||||
The A31 has a very atypical layout for the thermal sensors
|
||||
(source: Milos Popovic, http://thinkwiki.org/wiki/Thermal_Sensors#ThinkPad_A31)
|
||||
1: CPU
|
||||
2: Main Battery: main sensor
|
||||
3: Power Converter
|
||||
4: Bay Battery: main sensor
|
||||
5: MCH (northbridge)
|
||||
6: PCMCIA/ambient
|
||||
7: Main Battery: secondary sensor
|
||||
8: Bay Battery: secondary sensor
|
||||
|
||||
|
||||
EXPERIMENTAL: Embedded controller register dump -- /proc/acpi/ibm/ecdump
|
||||
------------------------------------------------------------------------
|
||||
|
||||
|
@ -529,27 +571,57 @@ directly accesses hardware registers and may not work as expected. USE
|
|||
WITH CAUTION! To use this feature, you need to supply the
|
||||
experimental=1 parameter when loading the module.
|
||||
|
||||
This feature attempts to show the current fan speed. The speed is read
|
||||
directly from the hardware registers of the embedded controller. This
|
||||
is known to work on later R, T and X series ThinkPads but may show a
|
||||
bogus value on other models.
|
||||
This feature attempts to show the current fan speed, control mode and
|
||||
other fan data that might be available. The speed is read directly
|
||||
from the hardware registers of the embedded controller. This is known
|
||||
to work on later R, T and X series ThinkPads but may show a bogus
|
||||
value on other models.
|
||||
|
||||
Most ThinkPad fans work in "levels". Level 0 stops the fan. The higher
|
||||
the level, the higher the fan speed, although adjacent levels often map
|
||||
to the same fan speed. 7 is the highest level, where the fan reaches
|
||||
the maximum recommended speed. Level "auto" means the EC changes the
|
||||
fan level according to some internal algorithm, usually based on
|
||||
readings from the thermal sensors. Level "disengaged" means the EC
|
||||
disables the speed-locked closed-loop fan control, and drives the fan as
|
||||
fast as it can go, which might exceed hardware limits, so use this level
|
||||
with caution.
|
||||
|
||||
The fan usually ramps up or down slowly from one speed to another,
|
||||
and it is normal for the EC to take several seconds to react to fan
|
||||
commands.
|
||||
|
||||
The fan may be enabled or disabled with the following commands:
|
||||
|
||||
echo enable >/proc/acpi/ibm/fan
|
||||
echo disable >/proc/acpi/ibm/fan
|
||||
|
||||
WARNING WARNING WARNING: do not leave the fan disabled unless you are
|
||||
monitoring the temperature sensor readings and you are ready to enable
|
||||
it if necessary to avoid overheating.
|
||||
Placing a fan on level 0 is the same as disabling it. Enabling a fan
|
||||
will try to place it in a safe level if it is too slow or disabled.
|
||||
|
||||
The fan only runs if it's enabled *and* the various temperature
|
||||
sensors which control it read high enough. On the X40, this seems to
|
||||
depend on the CPU and HDD temperatures. Specifically, the fan is
|
||||
turned on when either the CPU temperature climbs to 56 degrees or the
|
||||
HDD temperature climbs to 46 degrees. The fan is turned off when the
|
||||
CPU temperature drops to 49 degrees and the HDD temperature drops to
|
||||
41 degrees. These thresholds cannot currently be controlled.
|
||||
WARNING WARNING WARNING: do not leave the fan disabled unless you are
|
||||
monitoring all of the temperature sensor readings and you are ready to
|
||||
enable it if necessary to avoid overheating.
|
||||
|
||||
An enabled fan in level "auto" may stop spinning if the EC decides the
|
||||
ThinkPad is cool enough and doesn't need the extra airflow. This is
|
||||
normal, and the EC will spin the fan up if the varios thermal readings
|
||||
rise too much.
|
||||
|
||||
On the X40, this seems to depend on the CPU and HDD temperatures.
|
||||
Specifically, the fan is turned on when either the CPU temperature
|
||||
climbs to 56 degrees or the HDD temperature climbs to 46 degrees. The
|
||||
fan is turned off when the CPU temperature drops to 49 degrees and the
|
||||
HDD temperature drops to 41 degrees. These thresholds cannot
|
||||
currently be controlled.
|
||||
|
||||
The fan level can be controlled with the command:
|
||||
|
||||
echo 'level <level>' > /proc/acpi/ibm/thermal
|
||||
|
||||
Where <level> is an integer from 0 to 7, or one of the words "auto"
|
||||
or "disengaged" (without the quotes). Not all ThinkPads support the
|
||||
"auto" and "disengaged" levels.
|
||||
|
||||
On the X31 and X40 (and ONLY on those models), the fan speed can be
|
||||
controlled to a certain degree. Once the fan is running, it can be
|
||||
|
@ -562,12 +634,9 @@ about 3700 to about 7350. Values outside this range either do not have
|
|||
any effect or the fan speed eventually settles somewhere in that
|
||||
range. The fan cannot be stopped or started with this command.
|
||||
|
||||
On the 570, temperature readings are not available through this
|
||||
feature and the fan control works a little differently. The fan speed
|
||||
is reported in levels from 0 (off) to 7 (max) and can be controlled
|
||||
with the following command:
|
||||
|
||||
echo 'level <level>' > /proc/acpi/ibm/thermal
|
||||
The ThinkPad's ACPI DSDT code will reprogram the fan on its own when
|
||||
certain conditions are met. It will override any fan programming done
|
||||
through ibm-acpi.
|
||||
|
||||
EXPERIMENTAL: WAN -- /proc/acpi/ibm/wan
|
||||
---------------------------------------
|
||||
|
@ -601,6 +670,26 @@ example:
|
|||
|
||||
modprobe ibm_acpi hotkey=enable,0xffff video=auto_disable
|
||||
|
||||
The ibm-acpi kernel driver can be programmed to revert the fan level
|
||||
to a safe setting if userspace does not issue one of the fan commands:
|
||||
"enable", "disable", "level" or "watchdog" within a configurable
|
||||
ammount of time. To do this, use the "watchdog" command.
|
||||
|
||||
echo 'watchdog <interval>' > /proc/acpi/ibm/fan
|
||||
|
||||
Interval is the ammount of time in seconds to wait for one of the
|
||||
above mentioned fan commands before reseting the fan level to a safe
|
||||
one. If set to zero, the watchdog is disabled (default). When the
|
||||
watchdog timer runs out, it does the exact equivalent of the "enable"
|
||||
fan command.
|
||||
|
||||
Note that the watchdog timer stops after it enables the fan. It will
|
||||
be rearmed again automatically (using the same interval) when one of
|
||||
the above mentioned fan commands is received. The fan watchdog is,
|
||||
therefore, not suitable to protect against fan mode changes made
|
||||
through means other than the "enable", "disable", and "level" fan
|
||||
commands.
|
||||
|
||||
|
||||
Example Configuration
|
||||
---------------------
|
||||
|
|
|
@ -1400,6 +1400,15 @@ W: http://www.ia64-linux.org/
|
|||
T: git kernel.org:/pub/scm/linux/kernel/git/aegl/linux-2.6.git
|
||||
S: Maintained
|
||||
|
||||
IBM ACPI EXTRAS DRIVER
|
||||
P: Henrique de Moraes Holschuh
|
||||
M: ibm-acpi@hmh.eng.br
|
||||
L: ibm-acpi-devel@lists.sourceforge.net
|
||||
W: http://ibm-acpi.sourceforge.net
|
||||
W: http://thinkwiki.org/wiki/Ibm-acpi
|
||||
T: git repo.or.cz/linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git
|
||||
S: Maintained
|
||||
|
||||
SN-IA64 (Itanium) SUB-PLATFORM
|
||||
P: Jes Sorensen
|
||||
M: jes@sgi.com
|
||||
|
|
|
@ -1327,3 +1327,25 @@ static int __init setup_acpi_sci(char *s)
|
|||
return 0;
|
||||
}
|
||||
early_param("acpi_sci", setup_acpi_sci);
|
||||
|
||||
int __acpi_acquire_global_lock(unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1));
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return (new < 3) ? -1 : 0;
|
||||
}
|
||||
|
||||
int __acpi_release_global_lock(unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = old & ~0x3;
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return old & 0x1;
|
||||
}
|
||||
|
|
|
@ -276,12 +276,10 @@ acpi_cpufreq_cpu_init (
|
|||
|
||||
dprintk("acpi_cpufreq_cpu_init\n");
|
||||
|
||||
data = kmalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
|
||||
if (!data)
|
||||
return (-ENOMEM);
|
||||
|
||||
memset(data, 0, sizeof(struct cpufreq_acpi_io));
|
||||
|
||||
acpi_io_data[cpu] = data;
|
||||
|
||||
result = acpi_processor_register_performance(&data->acpi_data, cpu);
|
||||
|
|
|
@ -11,7 +11,7 @@ config ACPI
|
|||
bool "ACPI Support"
|
||||
depends on IA64 || X86
|
||||
depends on PCI
|
||||
select PM
|
||||
depends on PM
|
||||
default y
|
||||
---help---
|
||||
Advanced Configuration and Power Interface (ACPI) support for
|
||||
|
@ -97,6 +97,7 @@ config ACPI_BATTERY
|
|||
|
||||
config ACPI_BUTTON
|
||||
tristate "Button"
|
||||
depends on INPUT
|
||||
default y
|
||||
help
|
||||
This driver handles events on the power, sleep and lid buttons.
|
||||
|
@ -172,6 +173,7 @@ config ACPI_NUMA
|
|||
config ACPI_ASUS
|
||||
tristate "ASUS/Medion Laptop Extras"
|
||||
depends on X86
|
||||
select BACKLIGHT_CLASS_DEVICE
|
||||
---help---
|
||||
This driver provides support for extra features of ACPI-compatible
|
||||
ASUS laptops. As some of Medion laptops are made by ASUS, it may also
|
||||
|
@ -200,6 +202,7 @@ config ACPI_ASUS
|
|||
config ACPI_IBM
|
||||
tristate "IBM ThinkPad Laptop Extras"
|
||||
depends on X86
|
||||
select BACKLIGHT_CLASS_DEVICE
|
||||
---help---
|
||||
This is a Linux ACPI driver for the IBM ThinkPad laptops. It adds
|
||||
support for Fn-Fx key combinations, Bluetooth control, video
|
||||
|
@ -222,9 +225,21 @@ config ACPI_IBM_DOCK
|
|||
|
||||
If you are not sure, say N here.
|
||||
|
||||
config ACPI_IBM_BAY
|
||||
bool "Legacy Removable Bay Support"
|
||||
depends on ACPI_IBM
|
||||
depends on ACPI_BAY=n
|
||||
default n
|
||||
---help---
|
||||
Allows the ibm_acpi driver to handle removable bays.
|
||||
This support is obsoleted by CONFIG_ACPI_BAY.
|
||||
|
||||
If you are not sure, say N here.
|
||||
|
||||
config ACPI_TOSHIBA
|
||||
tristate "Toshiba Laptop Extras"
|
||||
depends on X86
|
||||
select BACKLIGHT_CLASS_DEVICE
|
||||
---help---
|
||||
This driver adds support for access to certain system settings
|
||||
on "legacy free" Toshiba laptops. These laptops can be recognized by
|
||||
|
|
|
@ -109,7 +109,7 @@ static struct proc_dir_entry *acpi_ac_dir;
|
|||
|
||||
static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_ac *ac = (struct acpi_ac *)seq->private;
|
||||
struct acpi_ac *ac = seq->private;
|
||||
|
||||
|
||||
if (!ac)
|
||||
|
@ -187,7 +187,7 @@ static int acpi_ac_remove_fs(struct acpi_device *device)
|
|||
|
||||
static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_ac *ac = (struct acpi_ac *)data;
|
||||
struct acpi_ac *ac = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
|
||||
|
@ -221,10 +221,9 @@ static int acpi_ac_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL);
|
||||
ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
|
||||
if (!ac)
|
||||
return -ENOMEM;
|
||||
memset(ac, 0, sizeof(struct acpi_ac));
|
||||
|
||||
ac->device = device;
|
||||
strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
|
||||
|
@ -269,7 +268,7 @@ static int acpi_ac_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
ac = (struct acpi_ac *)acpi_driver_data(device);
|
||||
ac = acpi_driver_data(device);
|
||||
|
||||
status = acpi_remove_notify_handler(device->handle,
|
||||
ACPI_ALL_NOTIFY, acpi_ac_notify);
|
||||
|
|
|
@ -395,10 +395,9 @@ static int acpi_memory_device_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
|
||||
mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
|
||||
if (!mem_device)
|
||||
return -ENOMEM;
|
||||
memset(mem_device, 0, sizeof(struct acpi_memory_device));
|
||||
|
||||
INIT_LIST_HEAD(&mem_device->res_list);
|
||||
mem_device->device = device;
|
||||
|
@ -429,7 +428,7 @@ static int acpi_memory_device_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
|
||||
mem_device = acpi_driver_data(device);
|
||||
kfree(mem_device);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -35,6 +35,7 @@
|
|||
#include <linux/init.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/backlight.h>
|
||||
#include <acpi/acpi_drivers.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
@ -402,6 +403,8 @@ static struct model_data model_conf[END_MODEL] = {
|
|||
/* procdir we use */
|
||||
static struct proc_dir_entry *asus_proc_dir;
|
||||
|
||||
static struct backlight_device *asus_backlight_device;
|
||||
|
||||
/*
|
||||
* This header is made available to allow proper configuration given model,
|
||||
* revision number , ... this info cannot go in struct asus_hotk because it is
|
||||
|
@ -779,7 +782,7 @@ proc_write_lcd(struct file *file, const char __user * buffer,
|
|||
return rv;
|
||||
}
|
||||
|
||||
static int read_brightness(void)
|
||||
static int read_brightness(struct backlight_device *bd)
|
||||
{
|
||||
int value;
|
||||
|
||||
|
@ -801,9 +804,10 @@ static int read_brightness(void)
|
|||
/*
|
||||
* Change the brightness level
|
||||
*/
|
||||
static void set_brightness(int value)
|
||||
static int set_brightness(int value)
|
||||
{
|
||||
acpi_status status = 0;
|
||||
int ret = 0;
|
||||
|
||||
/* SPLV laptop */
|
||||
if (hotk->methods->brightness_set) {
|
||||
|
@ -811,11 +815,12 @@ static void set_brightness(int value)
|
|||
value, NULL))
|
||||
printk(KERN_WARNING
|
||||
"Asus ACPI: Error changing brightness\n");
|
||||
return;
|
||||
ret = -EIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* No SPLV method if we are here, act as appropriate */
|
||||
value -= read_brightness();
|
||||
value -= read_brightness(NULL);
|
||||
while (value != 0) {
|
||||
status = acpi_evaluate_object(NULL, (value > 0) ?
|
||||
hotk->methods->brightness_up :
|
||||
|
@ -825,15 +830,22 @@ static void set_brightness(int value)
|
|||
if (ACPI_FAILURE(status))
|
||||
printk(KERN_WARNING
|
||||
"Asus ACPI: Error changing brightness\n");
|
||||
ret = -EIO;
|
||||
}
|
||||
return;
|
||||
out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int set_brightness_status(struct backlight_device *bd)
|
||||
{
|
||||
return set_brightness(bd->props->brightness);
|
||||
}
|
||||
|
||||
static int
|
||||
proc_read_brn(char *page, char **start, off_t off, int count, int *eof,
|
||||
void *data)
|
||||
{
|
||||
return sprintf(page, "%d\n", read_brightness());
|
||||
return sprintf(page, "%d\n", read_brightness(NULL));
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -1134,7 +1146,7 @@ static int asus_hotk_get_info(void)
|
|||
if (ACPI_FAILURE(status))
|
||||
printk(KERN_WARNING " Couldn't get the DSDT table header\n");
|
||||
else
|
||||
asus_info = (struct acpi_table_header *)dsdt.pointer;
|
||||
asus_info = dsdt.pointer;
|
||||
|
||||
/* We have to write 0 on init this far for all ASUS models */
|
||||
if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
|
||||
|
@ -1156,7 +1168,7 @@ static int asus_hotk_get_info(void)
|
|||
* asus_model_match() and try something completely different.
|
||||
*/
|
||||
if (buffer.pointer) {
|
||||
model = (union acpi_object *)buffer.pointer;
|
||||
model = buffer.pointer;
|
||||
switch (model->type) {
|
||||
case ACPI_TYPE_STRING:
|
||||
string = model->string.pointer;
|
||||
|
@ -1252,11 +1264,9 @@ static int asus_hotk_add(struct acpi_device *device)
|
|||
printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
|
||||
ASUS_ACPI_VERSION);
|
||||
|
||||
hotk =
|
||||
(struct asus_hotk *)kmalloc(sizeof(struct asus_hotk), GFP_KERNEL);
|
||||
hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
|
||||
if (!hotk)
|
||||
return -ENOMEM;
|
||||
memset(hotk, 0, sizeof(struct asus_hotk));
|
||||
|
||||
hotk->handle = device->handle;
|
||||
strcpy(acpi_device_name(device), ACPI_HOTK_DEVICE_NAME);
|
||||
|
@ -1333,6 +1343,26 @@ static int asus_hotk_remove(struct acpi_device *device, int type)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static struct backlight_properties asus_backlight_data = {
|
||||
.owner = THIS_MODULE,
|
||||
.get_brightness = read_brightness,
|
||||
.update_status = set_brightness_status,
|
||||
.max_brightness = 15,
|
||||
};
|
||||
|
||||
static void __exit asus_acpi_exit(void)
|
||||
{
|
||||
if (asus_backlight_device)
|
||||
backlight_device_unregister(asus_backlight_device);
|
||||
|
||||
acpi_bus_unregister_driver(&asus_hotk_driver);
|
||||
remove_proc_entry(PROC_ASUS, acpi_root_dir);
|
||||
|
||||
kfree(asus_info);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static int __init asus_acpi_init(void)
|
||||
{
|
||||
int result;
|
||||
|
@ -1370,18 +1400,16 @@ static int __init asus_acpi_init(void)
|
|||
return result;
|
||||
}
|
||||
|
||||
asus_backlight_device = backlight_device_register("asus",NULL,NULL,
|
||||
&asus_backlight_data);
|
||||
if (IS_ERR(asus_backlight_device)) {
|
||||
printk(KERN_ERR "Could not register asus backlight device\n");
|
||||
asus_backlight_device = NULL;
|
||||
asus_acpi_exit();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit asus_acpi_exit(void)
|
||||
{
|
||||
acpi_bus_unregister_driver(&asus_hotk_driver);
|
||||
remove_proc_entry(PROC_ASUS, acpi_root_dir);
|
||||
|
||||
kfree(asus_info);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
module_init(asus_acpi_init);
|
||||
module_exit(asus_acpi_exit);
|
||||
|
|
|
@ -149,7 +149,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
package = (union acpi_object *)buffer.pointer;
|
||||
package = buffer.pointer;
|
||||
|
||||
/* Extract Package Data */
|
||||
|
||||
|
@ -160,12 +160,11 @@ acpi_battery_get_info(struct acpi_battery *battery,
|
|||
goto end;
|
||||
}
|
||||
|
||||
data.pointer = kmalloc(data.length, GFP_KERNEL);
|
||||
data.pointer = kzalloc(data.length, GFP_KERNEL);
|
||||
if (!data.pointer) {
|
||||
result = -ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
memset(data.pointer, 0, data.length);
|
||||
|
||||
status = acpi_extract_package(package, &format, &data);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
|
@ -179,7 +178,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
|
|||
kfree(buffer.pointer);
|
||||
|
||||
if (!result)
|
||||
(*bif) = (struct acpi_battery_info *)data.pointer;
|
||||
(*bif) = data.pointer;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
@ -209,7 +208,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
package = (union acpi_object *)buffer.pointer;
|
||||
package = buffer.pointer;
|
||||
|
||||
/* Extract Package Data */
|
||||
|
||||
|
@ -220,12 +219,11 @@ acpi_battery_get_status(struct acpi_battery *battery,
|
|||
goto end;
|
||||
}
|
||||
|
||||
data.pointer = kmalloc(data.length, GFP_KERNEL);
|
||||
data.pointer = kzalloc(data.length, GFP_KERNEL);
|
||||
if (!data.pointer) {
|
||||
result = -ENOMEM;
|
||||
goto end;
|
||||
}
|
||||
memset(data.pointer, 0, data.length);
|
||||
|
||||
status = acpi_extract_package(package, &format, &data);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
|
@ -239,7 +237,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
|
|||
kfree(buffer.pointer);
|
||||
|
||||
if (!result)
|
||||
(*bst) = (struct acpi_battery_status *)data.pointer;
|
||||
(*bst) = data.pointer;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
@ -334,7 +332,7 @@ static struct proc_dir_entry *acpi_battery_dir;
|
|||
static int acpi_battery_read_info(struct seq_file *seq, void *offset)
|
||||
{
|
||||
int result = 0;
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
struct acpi_battery_info *bif = NULL;
|
||||
char *units = "?";
|
||||
|
||||
|
@ -418,7 +416,7 @@ static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
|
|||
static int acpi_battery_read_state(struct seq_file *seq, void *offset)
|
||||
{
|
||||
int result = 0;
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
struct acpi_battery_status *bst = NULL;
|
||||
char *units = "?";
|
||||
|
||||
|
@ -494,7 +492,7 @@ static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
char *units = "?";
|
||||
|
||||
|
||||
|
@ -531,8 +529,8 @@ acpi_battery_write_alarm(struct file *file,
|
|||
{
|
||||
int result = 0;
|
||||
char alarm_string[12] = { '\0' };
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_battery *battery = (struct acpi_battery *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_battery *battery = m->private;
|
||||
|
||||
|
||||
if (!battery || (count > sizeof(alarm_string) - 1))
|
||||
|
@ -658,7 +656,7 @@ static int acpi_battery_remove_fs(struct acpi_device *device)
|
|||
|
||||
static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_battery *battery = (struct acpi_battery *)data;
|
||||
struct acpi_battery *battery = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
|
||||
|
@ -694,10 +692,9 @@ static int acpi_battery_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);
|
||||
battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
|
||||
if (!battery)
|
||||
return -ENOMEM;
|
||||
memset(battery, 0, sizeof(struct acpi_battery));
|
||||
|
||||
battery->device = device;
|
||||
strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
|
||||
|
@ -742,7 +739,7 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
battery = (struct acpi_battery *)acpi_driver_data(device);
|
||||
battery = acpi_driver_data(device);
|
||||
|
||||
status = acpi_remove_notify_handler(device->handle,
|
||||
ACPI_ALL_NOTIFY,
|
||||
|
|
|
@ -29,6 +29,7 @@
|
|||
#include <linux/types.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/input.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
#include <acpi/acpi_drivers.h>
|
||||
|
||||
|
@ -62,7 +63,7 @@
|
|||
#define _COMPONENT ACPI_BUTTON_COMPONENT
|
||||
ACPI_MODULE_NAME("acpi_button")
|
||||
|
||||
MODULE_AUTHOR("Paul Diefenbaugh");
|
||||
MODULE_AUTHOR("Paul Diefenbaugh");
|
||||
MODULE_DESCRIPTION(ACPI_BUTTON_DRIVER_NAME);
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
|
@ -78,12 +79,14 @@ static struct acpi_driver acpi_button_driver = {
|
|||
.ops = {
|
||||
.add = acpi_button_add,
|
||||
.remove = acpi_button_remove,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
struct acpi_button {
|
||||
struct acpi_device *device; /* Fixed button kludge */
|
||||
u8 type;
|
||||
unsigned int type;
|
||||
struct input_dev *input;
|
||||
char phys[32]; /* for input device */
|
||||
unsigned long pushed;
|
||||
};
|
||||
|
||||
|
@ -109,8 +112,7 @@ static struct proc_dir_entry *acpi_button_dir;
|
|||
|
||||
static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_button *button = (struct acpi_button *)seq->private;
|
||||
|
||||
struct acpi_button *button = seq->private;
|
||||
|
||||
if (!button || !button->device)
|
||||
return 0;
|
||||
|
@ -128,22 +130,17 @@ static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_button *button = (struct acpi_button *)seq->private;
|
||||
struct acpi_button *button = seq->private;
|
||||
acpi_status status;
|
||||
unsigned long state;
|
||||
|
||||
|
||||
if (!button || !button->device)
|
||||
return 0;
|
||||
|
||||
status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
seq_printf(seq, "state: unsupported\n");
|
||||
} else {
|
||||
seq_printf(seq, "state: %s\n",
|
||||
(state ? "open" : "closed"));
|
||||
}
|
||||
|
||||
seq_printf(seq, "state: %s\n",
|
||||
ACPI_FAILURE(status) ? "unsupported" :
|
||||
(state ? "open" : "closed"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -159,8 +156,7 @@ static struct proc_dir_entry *acpi_lid_dir;
|
|||
static int acpi_button_add_fs(struct acpi_device *device)
|
||||
{
|
||||
struct proc_dir_entry *entry = NULL;
|
||||
struct acpi_button *button = NULL;
|
||||
|
||||
struct acpi_button *button;
|
||||
|
||||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
@ -228,10 +224,8 @@ static int acpi_button_add_fs(struct acpi_device *device)
|
|||
|
||||
static int acpi_button_remove_fs(struct acpi_device *device)
|
||||
{
|
||||
struct acpi_button *button = NULL;
|
||||
struct acpi_button *button = acpi_driver_data(device);
|
||||
|
||||
|
||||
button = acpi_driver_data(device);
|
||||
if (acpi_device_dir(device)) {
|
||||
if (button->type == ACPI_BUTTON_TYPE_LID)
|
||||
remove_proc_entry(ACPI_BUTTON_FILE_STATE,
|
||||
|
@ -253,14 +247,34 @@ static int acpi_button_remove_fs(struct acpi_device *device)
|
|||
|
||||
static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_button *button = (struct acpi_button *)data;
|
||||
|
||||
struct acpi_button *button = data;
|
||||
struct input_dev *input;
|
||||
|
||||
if (!button || !button->device)
|
||||
return;
|
||||
|
||||
switch (event) {
|
||||
case ACPI_BUTTON_NOTIFY_STATUS:
|
||||
input = button->input;
|
||||
|
||||
if (button->type == ACPI_BUTTON_TYPE_LID) {
|
||||
struct acpi_handle *handle = button->device->handle;
|
||||
unsigned long state;
|
||||
|
||||
if (!ACPI_FAILURE(acpi_evaluate_integer(handle, "_LID",
|
||||
NULL, &state)))
|
||||
input_report_switch(input, SW_LID, !state);
|
||||
|
||||
} else {
|
||||
int keycode = test_bit(KEY_SLEEP, input->keybit) ?
|
||||
KEY_SLEEP : KEY_POWER;
|
||||
|
||||
input_report_key(input, keycode, 1);
|
||||
input_sync(input);
|
||||
input_report_key(input, keycode, 0);
|
||||
}
|
||||
input_sync(input);
|
||||
|
||||
acpi_bus_generate_event(button->device, event,
|
||||
++button->pushed);
|
||||
break;
|
||||
|
@ -275,8 +289,7 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
|
|||
|
||||
static acpi_status acpi_button_notify_fixed(void *data)
|
||||
{
|
||||
struct acpi_button *button = (struct acpi_button *)data;
|
||||
|
||||
struct acpi_button *button = data;
|
||||
|
||||
if (!button)
|
||||
return AE_BAD_PARAMETER;
|
||||
|
@ -286,24 +299,75 @@ static acpi_status acpi_button_notify_fixed(void *data)
|
|||
return AE_OK;
|
||||
}
|
||||
|
||||
static int acpi_button_install_notify_handlers(struct acpi_button *button)
|
||||
{
|
||||
acpi_status status;
|
||||
|
||||
switch (button->type) {
|
||||
case ACPI_BUTTON_TYPE_POWERF:
|
||||
status =
|
||||
acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
||||
acpi_button_notify_fixed,
|
||||
button);
|
||||
break;
|
||||
case ACPI_BUTTON_TYPE_SLEEPF:
|
||||
status =
|
||||
acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
||||
acpi_button_notify_fixed,
|
||||
button);
|
||||
break;
|
||||
default:
|
||||
status = acpi_install_notify_handler(button->device->handle,
|
||||
ACPI_DEVICE_NOTIFY,
|
||||
acpi_button_notify,
|
||||
button);
|
||||
break;
|
||||
}
|
||||
|
||||
return ACPI_FAILURE(status) ? -ENODEV : 0;
|
||||
}
|
||||
|
||||
static void acpi_button_remove_notify_handlers(struct acpi_button *button)
|
||||
{
|
||||
switch (button->type) {
|
||||
case ACPI_BUTTON_TYPE_POWERF:
|
||||
acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
||||
acpi_button_notify_fixed);
|
||||
break;
|
||||
case ACPI_BUTTON_TYPE_SLEEPF:
|
||||
acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
||||
acpi_button_notify_fixed);
|
||||
break;
|
||||
default:
|
||||
acpi_remove_notify_handler(button->device->handle,
|
||||
ACPI_DEVICE_NOTIFY,
|
||||
acpi_button_notify);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int acpi_button_add(struct acpi_device *device)
|
||||
{
|
||||
int result = 0;
|
||||
acpi_status status = AE_OK;
|
||||
struct acpi_button *button = NULL;
|
||||
|
||||
int error;
|
||||
struct acpi_button *button;
|
||||
struct input_dev *input;
|
||||
|
||||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
|
||||
button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
|
||||
if (!button)
|
||||
return -ENOMEM;
|
||||
memset(button, 0, sizeof(struct acpi_button));
|
||||
|
||||
button->device = device;
|
||||
acpi_driver_data(device) = button;
|
||||
|
||||
button->input = input = input_allocate_device();
|
||||
if (!input) {
|
||||
error = -ENOMEM;
|
||||
goto err_free_button;
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine the button type (via hid), as fixed-feature buttons
|
||||
* need to be handled a bit differently than generic-space.
|
||||
|
@ -338,39 +402,48 @@ static int acpi_button_add(struct acpi_device *device)
|
|||
} else {
|
||||
printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
|
||||
acpi_device_hid(device));
|
||||
result = -ENODEV;
|
||||
goto end;
|
||||
error = -ENODEV;
|
||||
goto err_free_input;
|
||||
}
|
||||
|
||||
result = acpi_button_add_fs(device);
|
||||
if (result)
|
||||
goto end;
|
||||
error = acpi_button_add_fs(device);
|
||||
if (error)
|
||||
goto err_free_input;
|
||||
|
||||
error = acpi_button_install_notify_handlers(button);
|
||||
if (error)
|
||||
goto err_remove_fs;
|
||||
|
||||
snprintf(button->phys, sizeof(button->phys),
|
||||
"%s/button/input0", acpi_device_hid(device));
|
||||
|
||||
input->name = acpi_device_name(device);
|
||||
input->phys = button->phys;
|
||||
input->id.bustype = BUS_HOST;
|
||||
input->id.product = button->type;
|
||||
|
||||
switch (button->type) {
|
||||
case ACPI_BUTTON_TYPE_POWER:
|
||||
case ACPI_BUTTON_TYPE_POWERF:
|
||||
status =
|
||||
acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
||||
acpi_button_notify_fixed,
|
||||
button);
|
||||
input->evbit[0] = BIT(EV_KEY);
|
||||
set_bit(KEY_POWER, input->keybit);
|
||||
break;
|
||||
|
||||
case ACPI_BUTTON_TYPE_SLEEP:
|
||||
case ACPI_BUTTON_TYPE_SLEEPF:
|
||||
status =
|
||||
acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
||||
acpi_button_notify_fixed,
|
||||
button);
|
||||
input->evbit[0] = BIT(EV_KEY);
|
||||
set_bit(KEY_SLEEP, input->keybit);
|
||||
break;
|
||||
default:
|
||||
status = acpi_install_notify_handler(device->handle,
|
||||
ACPI_DEVICE_NOTIFY,
|
||||
acpi_button_notify,
|
||||
button);
|
||||
|
||||
case ACPI_BUTTON_TYPE_LID:
|
||||
input->evbit[0] = BIT(EV_SW);
|
||||
set_bit(SW_LID, input->swbit);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ACPI_FAILURE(status)) {
|
||||
result = -ENODEV;
|
||||
goto end;
|
||||
}
|
||||
error = input_register_device(input);
|
||||
if (error)
|
||||
goto err_remove_handlers;
|
||||
|
||||
if (device->wakeup.flags.valid) {
|
||||
/* Button's GPE is run-wake GPE */
|
||||
|
@ -385,47 +458,31 @@ static int acpi_button_add(struct acpi_device *device)
|
|||
printk(KERN_INFO PREFIX "%s [%s]\n",
|
||||
acpi_device_name(device), acpi_device_bid(device));
|
||||
|
||||
end:
|
||||
if (result) {
|
||||
acpi_button_remove_fs(device);
|
||||
kfree(button);
|
||||
}
|
||||
return 0;
|
||||
|
||||
return result;
|
||||
err_remove_handlers:
|
||||
acpi_button_remove_notify_handlers(button);
|
||||
err_remove_fs:
|
||||
acpi_button_remove_fs(device);
|
||||
err_free_input:
|
||||
input_free_device(input);
|
||||
err_free_button:
|
||||
kfree(button);
|
||||
return error;
|
||||
}
|
||||
|
||||
static int acpi_button_remove(struct acpi_device *device, int type)
|
||||
{
|
||||
acpi_status status = 0;
|
||||
struct acpi_button *button = NULL;
|
||||
|
||||
struct acpi_button *button;
|
||||
|
||||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
button = acpi_driver_data(device);
|
||||
|
||||
/* Unregister for device notifications. */
|
||||
switch (button->type) {
|
||||
case ACPI_BUTTON_TYPE_POWERF:
|
||||
status =
|
||||
acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
||||
acpi_button_notify_fixed);
|
||||
break;
|
||||
case ACPI_BUTTON_TYPE_SLEEPF:
|
||||
status =
|
||||
acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
||||
acpi_button_notify_fixed);
|
||||
break;
|
||||
default:
|
||||
status = acpi_remove_notify_handler(device->handle,
|
||||
ACPI_DEVICE_NOTIFY,
|
||||
acpi_button_notify);
|
||||
break;
|
||||
}
|
||||
|
||||
acpi_button_remove_notify_handlers(button);
|
||||
acpi_button_remove_fs(device);
|
||||
|
||||
input_unregister_device(button->input);
|
||||
kfree(button);
|
||||
|
||||
return 0;
|
||||
|
@ -433,8 +490,7 @@ static int acpi_button_remove(struct acpi_device *device, int type)
|
|||
|
||||
static int __init acpi_button_init(void)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
int result;
|
||||
|
||||
acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
|
||||
if (!acpi_button_dir)
|
||||
|
@ -451,7 +507,6 @@ static int __init acpi_button_init(void)
|
|||
|
||||
static void __exit acpi_button_exit(void)
|
||||
{
|
||||
|
||||
acpi_bus_unregister_driver(&acpi_button_driver);
|
||||
|
||||
if (acpi_power_dir)
|
||||
|
@ -461,8 +516,6 @@ static void __exit acpi_button_exit(void)
|
|||
if (acpi_lid_dir)
|
||||
remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
|
||||
remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
module_init(acpi_button_init);
|
||||
|
|
|
@ -96,11 +96,10 @@ static int acpi_container_add(struct acpi_device *device)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
container = kmalloc(sizeof(struct acpi_container), GFP_KERNEL);
|
||||
container = kzalloc(sizeof(struct acpi_container), GFP_KERNEL);
|
||||
if (!container)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(container, 0, sizeof(struct acpi_container));
|
||||
container->handle = device->handle;
|
||||
strcpy(acpi_device_name(device), ACPI_CONTAINER_DEVICE_NAME);
|
||||
strcpy(acpi_device_class(device), ACPI_CONTAINER_CLASS);
|
||||
|
@ -117,7 +116,7 @@ static int acpi_container_remove(struct acpi_device *device, int type)
|
|||
acpi_status status = AE_OK;
|
||||
struct acpi_container *pc = NULL;
|
||||
|
||||
pc = (struct acpi_container *)acpi_driver_data(device);
|
||||
pc = acpi_driver_data(device);
|
||||
kfree(pc);
|
||||
return status;
|
||||
}
|
||||
|
|
|
@ -27,6 +27,7 @@
|
|||
#include <linux/init.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/notifier.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/jiffies.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
#include <acpi/acpi_drivers.h>
|
||||
|
@ -39,13 +40,15 @@ MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_NAME);
|
|||
MODULE_LICENSE("GPL");
|
||||
|
||||
static struct atomic_notifier_head dock_notifier_list;
|
||||
static struct platform_device dock_device;
|
||||
static char dock_device_name[] = "dock";
|
||||
|
||||
struct dock_station {
|
||||
acpi_handle handle;
|
||||
unsigned long last_dock_time;
|
||||
u32 flags;
|
||||
spinlock_t dd_lock;
|
||||
spinlock_t hp_lock;
|
||||
struct mutex hp_lock;
|
||||
struct list_head dependent_devices;
|
||||
struct list_head hotplug_devices;
|
||||
};
|
||||
|
@ -115,9 +118,9 @@ static void
|
|||
dock_add_hotplug_device(struct dock_station *ds,
|
||||
struct dock_dependent_device *dd)
|
||||
{
|
||||
spin_lock(&ds->hp_lock);
|
||||
mutex_lock(&ds->hp_lock);
|
||||
list_add_tail(&dd->hotplug_list, &ds->hotplug_devices);
|
||||
spin_unlock(&ds->hp_lock);
|
||||
mutex_unlock(&ds->hp_lock);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -131,9 +134,9 @@ static void
|
|||
dock_del_hotplug_device(struct dock_station *ds,
|
||||
struct dock_dependent_device *dd)
|
||||
{
|
||||
spin_lock(&ds->hp_lock);
|
||||
mutex_lock(&ds->hp_lock);
|
||||
list_del(&dd->hotplug_list);
|
||||
spin_unlock(&ds->hp_lock);
|
||||
mutex_unlock(&ds->hp_lock);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -296,7 +299,7 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
|
|||
{
|
||||
struct dock_dependent_device *dd;
|
||||
|
||||
spin_lock(&ds->hp_lock);
|
||||
mutex_lock(&ds->hp_lock);
|
||||
|
||||
/*
|
||||
* First call driver specific hotplug functions
|
||||
|
@ -318,15 +321,17 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
|
|||
else
|
||||
dock_create_acpi_device(dd->handle);
|
||||
}
|
||||
spin_unlock(&ds->hp_lock);
|
||||
mutex_unlock(&ds->hp_lock);
|
||||
}
|
||||
|
||||
static void dock_event(struct dock_station *ds, u32 event, int num)
|
||||
{
|
||||
struct device *dev = &dock_device.dev;
|
||||
/*
|
||||
* we don't do events until someone tells me that
|
||||
* they would like to have them.
|
||||
* Indicate that the status of the dock station has
|
||||
* changed.
|
||||
*/
|
||||
kobject_uevent(&dev->kobj, KOBJ_CHANGE);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -441,6 +446,9 @@ static int dock_in_progress(struct dock_station *ds)
|
|||
*/
|
||||
int register_dock_notifier(struct notifier_block *nb)
|
||||
{
|
||||
if (!dock_station)
|
||||
return -ENODEV;
|
||||
|
||||
return atomic_notifier_chain_register(&dock_notifier_list, nb);
|
||||
}
|
||||
|
||||
|
@ -452,6 +460,9 @@ EXPORT_SYMBOL_GPL(register_dock_notifier);
|
|||
*/
|
||||
void unregister_dock_notifier(struct notifier_block *nb)
|
||||
{
|
||||
if (!dock_station)
|
||||
return;
|
||||
|
||||
atomic_notifier_chain_unregister(&dock_notifier_list, nb);
|
||||
}
|
||||
|
||||
|
@ -511,6 +522,37 @@ void unregister_hotplug_dock_device(acpi_handle handle)
|
|||
|
||||
EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
|
||||
|
||||
/**
|
||||
* handle_eject_request - handle an undock request checking for error conditions
|
||||
*
|
||||
* Check to make sure the dock device is still present, then undock and
|
||||
* hotremove all the devices that may need removing.
|
||||
*/
|
||||
static int handle_eject_request(struct dock_station *ds, u32 event)
|
||||
{
|
||||
if (!dock_present(ds))
|
||||
return -ENODEV;
|
||||
|
||||
if (dock_in_progress(ds))
|
||||
return -EBUSY;
|
||||
|
||||
/*
|
||||
* here we need to generate the undock
|
||||
* event prior to actually doing the undock
|
||||
* so that the device struct still exists.
|
||||
*/
|
||||
dock_event(ds, event, UNDOCK_EVENT);
|
||||
hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
|
||||
undock(ds);
|
||||
eject_dock(ds);
|
||||
if (dock_present(ds)) {
|
||||
printk(KERN_ERR PREFIX "Unable to undock!\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* dock_notify - act upon an acpi dock notification
|
||||
* @handle: the dock station handle
|
||||
|
@ -519,13 +561,11 @@ EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
|
|||
*
|
||||
* If we are notified to dock, then check to see if the dock is
|
||||
* present and then dock. Notify all drivers of the dock event,
|
||||
* and then hotplug and devices that may need hotplugging. For undock
|
||||
* check to make sure the dock device is still present, then undock
|
||||
* and hotremove all the devices that may need removing.
|
||||
* and then hotplug and devices that may need hotplugging.
|
||||
*/
|
||||
static void dock_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct dock_station *ds = (struct dock_station *)data;
|
||||
struct dock_station *ds = data;
|
||||
|
||||
switch (event) {
|
||||
case ACPI_NOTIFY_BUS_CHECK:
|
||||
|
@ -553,19 +593,7 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
|
|||
* to the driver who wish to hotplug.
|
||||
*/
|
||||
case ACPI_NOTIFY_EJECT_REQUEST:
|
||||
if (!dock_in_progress(ds) && dock_present(ds)) {
|
||||
/*
|
||||
* here we need to generate the undock
|
||||
* event prior to actually doing the undock
|
||||
* so that the device struct still exists.
|
||||
*/
|
||||
dock_event(ds, event, UNDOCK_EVENT);
|
||||
hotplug_dock_devices(ds, ACPI_NOTIFY_EJECT_REQUEST);
|
||||
undock(ds);
|
||||
eject_dock(ds);
|
||||
if (dock_present(ds))
|
||||
printk(KERN_ERR PREFIX "Unable to undock!\n");
|
||||
}
|
||||
handle_eject_request(ds, event);
|
||||
break;
|
||||
default:
|
||||
printk(KERN_ERR PREFIX "Unknown dock event %d\n", event);
|
||||
|
@ -588,7 +616,7 @@ find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
|
|||
{
|
||||
acpi_status status;
|
||||
acpi_handle tmp;
|
||||
struct dock_station *ds = (struct dock_station *)context;
|
||||
struct dock_station *ds = context;
|
||||
struct dock_dependent_device *dd;
|
||||
|
||||
status = acpi_bus_get_ejd(handle, &tmp);
|
||||
|
@ -604,6 +632,33 @@ find_dock_devices(acpi_handle handle, u32 lvl, void *context, void **rv)
|
|||
return AE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
* show_docked - read method for "docked" file in sysfs
|
||||
*/
|
||||
static ssize_t show_docked(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", dock_present(dock_station));
|
||||
|
||||
}
|
||||
DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
|
||||
|
||||
/*
|
||||
* write_undock - write method for "undock" file in sysfs
|
||||
*/
|
||||
static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!count)
|
||||
return -EINVAL;
|
||||
|
||||
ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
|
||||
return ret ? ret: count;
|
||||
}
|
||||
DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
|
||||
|
||||
/**
|
||||
* dock_add - add a new dock station
|
||||
* @handle: the dock station handle
|
||||
|
@ -626,9 +681,33 @@ static int dock_add(acpi_handle handle)
|
|||
INIT_LIST_HEAD(&dock_station->dependent_devices);
|
||||
INIT_LIST_HEAD(&dock_station->hotplug_devices);
|
||||
spin_lock_init(&dock_station->dd_lock);
|
||||
spin_lock_init(&dock_station->hp_lock);
|
||||
mutex_init(&dock_station->hp_lock);
|
||||
ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
|
||||
|
||||
/* initialize platform device stuff */
|
||||
dock_device.name = dock_device_name;
|
||||
ret = platform_device_register(&dock_device);
|
||||
if (ret) {
|
||||
printk(KERN_ERR PREFIX "Error %d registering dock device\n", ret);
|
||||
kfree(dock_station);
|
||||
return ret;
|
||||
}
|
||||
ret = device_create_file(&dock_device.dev, &dev_attr_docked);
|
||||
if (ret) {
|
||||
printk("Error %d adding sysfs file\n", ret);
|
||||
platform_device_unregister(&dock_device);
|
||||
kfree(dock_station);
|
||||
return ret;
|
||||
}
|
||||
ret = device_create_file(&dock_device.dev, &dev_attr_undock);
|
||||
if (ret) {
|
||||
printk("Error %d adding sysfs file\n", ret);
|
||||
device_remove_file(&dock_device.dev, &dev_attr_docked);
|
||||
platform_device_unregister(&dock_device);
|
||||
kfree(dock_station);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Find dependent devices */
|
||||
acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
|
||||
ACPI_UINT32_MAX, find_dock_devices, dock_station,
|
||||
|
@ -638,7 +717,8 @@ static int dock_add(acpi_handle handle)
|
|||
dd = alloc_dock_dependent_device(handle);
|
||||
if (!dd) {
|
||||
kfree(dock_station);
|
||||
return -ENOMEM;
|
||||
ret = -ENOMEM;
|
||||
goto dock_add_err_unregister;
|
||||
}
|
||||
add_dock_dependent_device(dock_station, dd);
|
||||
|
||||
|
@ -658,8 +738,12 @@ static int dock_add(acpi_handle handle)
|
|||
return 0;
|
||||
|
||||
dock_add_err:
|
||||
kfree(dock_station);
|
||||
kfree(dd);
|
||||
dock_add_err_unregister:
|
||||
device_remove_file(&dock_device.dev, &dev_attr_docked);
|
||||
device_remove_file(&dock_device.dev, &dev_attr_undock);
|
||||
platform_device_unregister(&dock_device);
|
||||
kfree(dock_station);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -686,6 +770,11 @@ static int dock_remove(void)
|
|||
if (ACPI_FAILURE(status))
|
||||
printk(KERN_ERR "Error removing notify handler\n");
|
||||
|
||||
/* cleanup sysfs */
|
||||
device_remove_file(&dock_device.dev, &dev_attr_docked);
|
||||
device_remove_file(&dock_device.dev, &dev_attr_undock);
|
||||
platform_device_unregister(&dock_device);
|
||||
|
||||
/* free dock station memory */
|
||||
kfree(dock_station);
|
||||
return 0;
|
||||
|
@ -703,7 +792,7 @@ static int dock_remove(void)
|
|||
static acpi_status
|
||||
find_dock(acpi_handle handle, u32 lvl, void *context, void **rv)
|
||||
{
|
||||
int *count = (int *)context;
|
||||
int *count = context;
|
||||
acpi_status status = AE_OK;
|
||||
|
||||
if (is_dock(handle)) {
|
||||
|
@ -726,7 +815,7 @@ static int __init dock_init(void)
|
|||
ACPI_UINT32_MAX, find_dock, &num, NULL);
|
||||
|
||||
if (!num)
|
||||
return -ENODEV;
|
||||
printk(KERN_INFO "No dock devices found.\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -45,35 +45,34 @@ ACPI_MODULE_NAME("acpi_ec")
|
|||
#define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
|
||||
#define ACPI_EC_DEVICE_NAME "Embedded Controller"
|
||||
#define ACPI_EC_FILE_INFO "info"
|
||||
|
||||
#undef PREFIX
|
||||
#define PREFIX "ACPI: EC: "
|
||||
/* EC status register */
|
||||
#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
|
||||
#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
|
||||
#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
|
||||
#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
|
||||
|
||||
/* EC commands */
|
||||
#define ACPI_EC_COMMAND_READ 0x80
|
||||
#define ACPI_EC_COMMAND_WRITE 0x81
|
||||
#define ACPI_EC_BURST_ENABLE 0x82
|
||||
#define ACPI_EC_BURST_DISABLE 0x83
|
||||
#define ACPI_EC_COMMAND_QUERY 0x84
|
||||
|
||||
enum ec_command {
|
||||
ACPI_EC_COMMAND_READ = 0x80,
|
||||
ACPI_EC_COMMAND_WRITE = 0x81,
|
||||
ACPI_EC_BURST_ENABLE = 0x82,
|
||||
ACPI_EC_BURST_DISABLE = 0x83,
|
||||
ACPI_EC_COMMAND_QUERY = 0x84,
|
||||
};
|
||||
/* EC events */
|
||||
enum {
|
||||
enum ec_event {
|
||||
ACPI_EC_EVENT_OBF_1 = 1, /* Output buffer full */
|
||||
ACPI_EC_EVENT_IBF_0, /* Input buffer empty */
|
||||
ACPI_EC_EVENT_IBF_0, /* Input buffer empty */
|
||||
};
|
||||
|
||||
#define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
|
||||
#define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
|
||||
#define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
|
||||
#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
|
||||
#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
|
||||
|
||||
enum {
|
||||
EC_INTR = 1, /* Output buffer full */
|
||||
EC_POLL, /* Input buffer empty */
|
||||
};
|
||||
static enum ec_mode {
|
||||
EC_INTR = 1, /* Output buffer full */
|
||||
EC_POLL, /* Input buffer empty */
|
||||
} acpi_ec_mode = EC_INTR;
|
||||
|
||||
static int acpi_ec_remove(struct acpi_device *device, int type);
|
||||
static int acpi_ec_start(struct acpi_device *device);
|
||||
|
@ -93,22 +92,21 @@ static struct acpi_driver acpi_ec_driver = {
|
|||
};
|
||||
|
||||
/* If we find an EC via the ECDT, we need to keep a ptr to its context */
|
||||
struct acpi_ec {
|
||||
static struct acpi_ec {
|
||||
acpi_handle handle;
|
||||
unsigned long uid;
|
||||
unsigned long gpe_bit;
|
||||
unsigned long gpe;
|
||||
unsigned long command_addr;
|
||||
unsigned long data_addr;
|
||||
unsigned long global_lock;
|
||||
struct semaphore sem;
|
||||
unsigned int expect_event;
|
||||
struct mutex lock;
|
||||
atomic_t query_pending;
|
||||
atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
|
||||
wait_queue_head_t wait;
|
||||
} *ec_ecdt;
|
||||
|
||||
/* External interfaces use first EC only, so remember */
|
||||
static struct acpi_device *first_ec;
|
||||
static int acpi_ec_mode = EC_INTR;
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
Transaction Management
|
||||
|
@ -134,54 +132,41 @@ static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
|
|||
outb(data, ec->data_addr);
|
||||
}
|
||||
|
||||
static int acpi_ec_check_status(u8 status, u8 event)
|
||||
static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event)
|
||||
{
|
||||
switch (event) {
|
||||
case ACPI_EC_EVENT_OBF_1:
|
||||
u8 status = acpi_ec_read_status(ec);
|
||||
|
||||
if (event == ACPI_EC_EVENT_OBF_1) {
|
||||
if (status & ACPI_EC_FLAG_OBF)
|
||||
return 1;
|
||||
break;
|
||||
case ACPI_EC_EVENT_IBF_0:
|
||||
} else if (event == ACPI_EC_EVENT_IBF_0) {
|
||||
if (!(status & ACPI_EC_FLAG_IBF))
|
||||
return 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
|
||||
static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event)
|
||||
{
|
||||
int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
|
||||
long time_left;
|
||||
|
||||
ec->expect_event = event;
|
||||
if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
|
||||
ec->expect_event = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
do {
|
||||
if (acpi_ec_mode == EC_POLL) {
|
||||
udelay(ACPI_EC_UDELAY);
|
||||
} else {
|
||||
time_left = wait_event_timeout(ec->wait,
|
||||
!ec->expect_event,
|
||||
msecs_to_jiffies(ACPI_EC_DELAY));
|
||||
if (time_left > 0) {
|
||||
ec->expect_event = 0;
|
||||
if (acpi_ec_mode == EC_POLL) {
|
||||
unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
|
||||
while (time_before(jiffies, delay)) {
|
||||
if (acpi_ec_check_status(ec, event))
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
|
||||
ec->expect_event = 0;
|
||||
} else {
|
||||
if (wait_event_timeout(ec->wait,
|
||||
acpi_ec_check_status(ec, event),
|
||||
msecs_to_jiffies(ACPI_EC_DELAY)) ||
|
||||
acpi_ec_check_status(ec, event)) {
|
||||
return 0;
|
||||
} else {
|
||||
printk(KERN_ERR PREFIX "acpi_ec_wait timeout,"
|
||||
" status = %d, expect_event = %d\n",
|
||||
acpi_ec_read_status(ec), event);
|
||||
}
|
||||
} while (--i > 0);
|
||||
|
||||
ec->expect_event = 0;
|
||||
}
|
||||
|
||||
return -ETIME;
|
||||
}
|
||||
|
@ -196,7 +181,6 @@ int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
|
|||
u8 tmp = 0;
|
||||
u8 status = 0;
|
||||
|
||||
|
||||
status = acpi_ec_read_status(ec);
|
||||
if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
|
@ -212,7 +196,7 @@ int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
|
|||
|
||||
atomic_set(&ec->leaving_burst, 0);
|
||||
return 0;
|
||||
end:
|
||||
end:
|
||||
ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
|
||||
return -1;
|
||||
}
|
||||
|
@ -221,58 +205,68 @@ int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
|
|||
{
|
||||
u8 status = 0;
|
||||
|
||||
|
||||
status = acpi_ec_read_status(ec);
|
||||
if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
|
||||
if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)) {
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
if(status)
|
||||
if (status)
|
||||
goto end;
|
||||
acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
|
||||
acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
}
|
||||
atomic_set(&ec->leaving_burst, 1);
|
||||
return 0;
|
||||
end:
|
||||
end:
|
||||
ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
|
||||
return -1;
|
||||
}
|
||||
#endif /* ACPI_FUTURE_USAGE */
|
||||
#endif /* ACPI_FUTURE_USAGE */
|
||||
|
||||
static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
|
||||
const u8 *wdata, unsigned wdata_len,
|
||||
u8 *rdata, unsigned rdata_len)
|
||||
const u8 * wdata, unsigned wdata_len,
|
||||
u8 * rdata, unsigned rdata_len)
|
||||
{
|
||||
int result;
|
||||
int result = 0;
|
||||
|
||||
acpi_ec_write_cmd(ec, command);
|
||||
|
||||
for (; wdata_len > 0; wdata_len --) {
|
||||
for (; wdata_len > 0; --wdata_len) {
|
||||
result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
if (result)
|
||||
return result;
|
||||
if (result) {
|
||||
printk(KERN_ERR PREFIX
|
||||
"write_cmd timeout, command = %d\n", command);
|
||||
goto end;
|
||||
}
|
||||
acpi_ec_write_data(ec, *(wdata++));
|
||||
}
|
||||
|
||||
if (command == ACPI_EC_COMMAND_WRITE) {
|
||||
if (!rdata_len) {
|
||||
result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
if (result)
|
||||
return result;
|
||||
if (result) {
|
||||
printk(KERN_ERR PREFIX
|
||||
"finish-write timeout, command = %d\n", command);
|
||||
goto end;
|
||||
}
|
||||
} else if (command == ACPI_EC_COMMAND_QUERY) {
|
||||
atomic_set(&ec->query_pending, 0);
|
||||
}
|
||||
|
||||
for (; rdata_len > 0; rdata_len --) {
|
||||
for (; rdata_len > 0; --rdata_len) {
|
||||
result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
|
||||
if (result)
|
||||
return result;
|
||||
if (result) {
|
||||
printk(KERN_ERR PREFIX "read timeout, command = %d\n",
|
||||
command);
|
||||
goto end;
|
||||
}
|
||||
|
||||
*(rdata++) = acpi_ec_read_data(ec);
|
||||
}
|
||||
|
||||
return 0;
|
||||
end:
|
||||
return result;
|
||||
}
|
||||
|
||||
static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
|
||||
const u8 *wdata, unsigned wdata_len,
|
||||
u8 *rdata, unsigned rdata_len)
|
||||
const u8 * wdata, unsigned wdata_len,
|
||||
u8 * rdata, unsigned rdata_len)
|
||||
{
|
||||
int status;
|
||||
u32 glk;
|
||||
|
@ -280,36 +274,40 @@ static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
|
|||
if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
|
||||
return -EINVAL;
|
||||
|
||||
if (rdata)
|
||||
memset(rdata, 0, rdata_len);
|
||||
if (rdata)
|
||||
memset(rdata, 0, rdata_len);
|
||||
|
||||
mutex_lock(&ec->lock);
|
||||
if (ec->global_lock) {
|
||||
status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
}
|
||||
down(&ec->sem);
|
||||
|
||||
/* Make sure GPE is enabled before doing transaction */
|
||||
acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
|
||||
|
||||
status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
|
||||
if (status) {
|
||||
printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
|
||||
printk(KERN_DEBUG PREFIX
|
||||
"input buffer is not empty, aborting transaction\n");
|
||||
goto end;
|
||||
}
|
||||
|
||||
status = acpi_ec_transaction_unlocked(ec, command,
|
||||
wdata, wdata_len,
|
||||
rdata, rdata_len);
|
||||
status = acpi_ec_transaction_unlocked(ec, command,
|
||||
wdata, wdata_len,
|
||||
rdata, rdata_len);
|
||||
|
||||
end:
|
||||
up(&ec->sem);
|
||||
end:
|
||||
|
||||
if (ec->global_lock)
|
||||
acpi_release_global_lock(glk);
|
||||
mutex_unlock(&ec->lock);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
|
||||
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
|
||||
{
|
||||
int result;
|
||||
u8 d;
|
||||
|
@ -322,15 +320,15 @@ static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
|
|||
|
||||
static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
|
||||
{
|
||||
u8 wdata[2] = { address, data };
|
||||
return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
|
||||
u8 wdata[2] = { address, data };
|
||||
return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
|
||||
wdata, 2, NULL, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Externally callable EC access functions. For now, assume 1 EC only
|
||||
*/
|
||||
int ec_read(u8 addr, u8 *val)
|
||||
int ec_read(u8 addr, u8 * val)
|
||||
{
|
||||
struct acpi_ec *ec;
|
||||
int err;
|
||||
|
@ -369,9 +367,9 @@ int ec_write(u8 addr, u8 val)
|
|||
|
||||
EXPORT_SYMBOL(ec_write);
|
||||
|
||||
extern int ec_transaction(u8 command,
|
||||
const u8 *wdata, unsigned wdata_len,
|
||||
u8 *rdata, unsigned rdata_len)
|
||||
int ec_transaction(u8 command,
|
||||
const u8 * wdata, unsigned wdata_len,
|
||||
u8 * rdata, unsigned rdata_len)
|
||||
{
|
||||
struct acpi_ec *ec;
|
||||
|
||||
|
@ -386,65 +384,49 @@ extern int ec_transaction(u8 command,
|
|||
|
||||
EXPORT_SYMBOL(ec_transaction);
|
||||
|
||||
static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
|
||||
static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
|
||||
{
|
||||
int result;
|
||||
u8 d;
|
||||
u8 d;
|
||||
|
||||
if (!ec || !data)
|
||||
return -EINVAL;
|
||||
if (!ec || !data)
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* Query the EC to find out which _Qxx method we need to evaluate.
|
||||
* Note that successful completion of the query causes the ACPI_EC_SCI
|
||||
* bit to be cleared (and thus clearing the interrupt source).
|
||||
*/
|
||||
/*
|
||||
* Query the EC to find out which _Qxx method we need to evaluate.
|
||||
* Note that successful completion of the query causes the ACPI_EC_SCI
|
||||
* bit to be cleared (and thus clearing the interrupt source).
|
||||
*/
|
||||
|
||||
result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
|
||||
if (result)
|
||||
return result;
|
||||
result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
|
||||
if (result)
|
||||
return result;
|
||||
|
||||
if (!d)
|
||||
return -ENODATA;
|
||||
if (!d)
|
||||
return -ENODATA;
|
||||
|
||||
*data = d;
|
||||
return 0;
|
||||
*data = d;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
Event Management
|
||||
-------------------------------------------------------------------------- */
|
||||
|
||||
struct acpi_ec_query_data {
|
||||
acpi_handle handle;
|
||||
u8 data;
|
||||
};
|
||||
|
||||
static void acpi_ec_gpe_query(void *ec_cxt)
|
||||
{
|
||||
struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
|
||||
u8 value = 0;
|
||||
static char object_name[8];
|
||||
char object_name[8];
|
||||
|
||||
if (!ec)
|
||||
goto end;
|
||||
|
||||
value = acpi_ec_read_status(ec);
|
||||
|
||||
if (!(value & ACPI_EC_FLAG_SCI))
|
||||
goto end;
|
||||
|
||||
if (acpi_ec_query(ec, &value))
|
||||
goto end;
|
||||
if (!ec || acpi_ec_query(ec, &value))
|
||||
return;
|
||||
|
||||
snprintf(object_name, 8, "_Q%2.2X", value);
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
|
||||
printk(KERN_INFO PREFIX "evaluating %s\n", object_name);
|
||||
|
||||
acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
|
||||
|
||||
end:
|
||||
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
||||
}
|
||||
|
||||
static u32 acpi_ec_gpe_handler(void *data)
|
||||
|
@ -453,22 +435,18 @@ static u32 acpi_ec_gpe_handler(void *data)
|
|||
u8 value;
|
||||
struct acpi_ec *ec = (struct acpi_ec *)data;
|
||||
|
||||
acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
|
||||
value = acpi_ec_read_status(ec);
|
||||
|
||||
if (acpi_ec_mode == EC_INTR) {
|
||||
if (acpi_ec_check_status(value, ec->expect_event)) {
|
||||
ec->expect_event = 0;
|
||||
wake_up(&ec->wait);
|
||||
}
|
||||
wake_up(&ec->wait);
|
||||
}
|
||||
|
||||
if (value & ACPI_EC_FLAG_SCI) {
|
||||
status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
|
||||
return status == AE_OK ?
|
||||
ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
|
||||
value = acpi_ec_read_status(ec);
|
||||
if ((value & ACPI_EC_FLAG_SCI) && !atomic_read(&ec->query_pending)) {
|
||||
atomic_set(&ec->query_pending, 1);
|
||||
status =
|
||||
acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query,
|
||||
ec);
|
||||
}
|
||||
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
|
||||
|
||||
return status == AE_OK ?
|
||||
ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
|
||||
}
|
||||
|
@ -504,7 +482,6 @@ acpi_ec_space_handler(u32 function,
|
|||
acpi_integer f_v = 0;
|
||||
int i = 0;
|
||||
|
||||
|
||||
if ((address > 0xFF) || !value || !handler_context)
|
||||
return AE_BAD_PARAMETER;
|
||||
|
||||
|
@ -518,7 +495,7 @@ acpi_ec_space_handler(u32 function,
|
|||
switch (function) {
|
||||
case ACPI_READ:
|
||||
temp = 0;
|
||||
result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
|
||||
result = acpi_ec_read(ec, (u8) address, (u8 *) & temp);
|
||||
break;
|
||||
case ACPI_WRITE:
|
||||
result = acpi_ec_write(ec, (u8) address, (u8) temp);
|
||||
|
@ -571,18 +548,15 @@ static int acpi_ec_read_info(struct seq_file *seq, void *offset)
|
|||
{
|
||||
struct acpi_ec *ec = (struct acpi_ec *)seq->private;
|
||||
|
||||
|
||||
if (!ec)
|
||||
goto end;
|
||||
|
||||
seq_printf(seq, "gpe bit: 0x%02x\n",
|
||||
(u32) ec->gpe_bit);
|
||||
seq_printf(seq, "gpe: 0x%02x\n", (u32) ec->gpe);
|
||||
seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
|
||||
(u32) ec->command_addr,
|
||||
(u32) ec->data_addr);
|
||||
(u32) ec->command_addr, (u32) ec->data_addr);
|
||||
seq_printf(seq, "use global lock: %s\n",
|
||||
ec->global_lock ? "yes" : "no");
|
||||
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
||||
acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
|
||||
|
||||
end:
|
||||
return 0;
|
||||
|
@ -605,7 +579,6 @@ static int acpi_ec_add_fs(struct acpi_device *device)
|
|||
{
|
||||
struct proc_dir_entry *entry = NULL;
|
||||
|
||||
|
||||
if (!acpi_device_dir(device)) {
|
||||
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
||||
acpi_ec_dir);
|
||||
|
@ -648,18 +621,17 @@ static int acpi_ec_add(struct acpi_device *device)
|
|||
acpi_status status = AE_OK;
|
||||
struct acpi_ec *ec = NULL;
|
||||
|
||||
|
||||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
if (!ec)
|
||||
return -ENOMEM;
|
||||
memset(ec, 0, sizeof(struct acpi_ec));
|
||||
|
||||
ec->handle = device->handle;
|
||||
ec->uid = -1;
|
||||
init_MUTEX(&ec->sem);
|
||||
mutex_init(&ec->lock);
|
||||
atomic_set(&ec->query_pending, 0);
|
||||
if (acpi_ec_mode == EC_INTR) {
|
||||
atomic_set(&ec->leaving_burst, 1);
|
||||
init_waitqueue_head(&ec->wait);
|
||||
|
@ -669,8 +641,7 @@ static int acpi_ec_add(struct acpi_device *device)
|
|||
acpi_driver_data(device) = ec;
|
||||
|
||||
/* Use the global lock for all EC transactions? */
|
||||
acpi_evaluate_integer(ec->handle, "_GLK", NULL,
|
||||
&ec->global_lock);
|
||||
acpi_evaluate_integer(ec->handle, "_GLK", NULL, &ec->global_lock);
|
||||
|
||||
/* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
|
||||
http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
|
||||
|
@ -679,7 +650,7 @@ static int acpi_ec_add(struct acpi_device *device)
|
|||
ACPI_ADR_SPACE_EC,
|
||||
&acpi_ec_space_handler);
|
||||
|
||||
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
||||
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe,
|
||||
&acpi_ec_gpe_handler);
|
||||
|
||||
kfree(ec_ecdt);
|
||||
|
@ -687,11 +658,10 @@ static int acpi_ec_add(struct acpi_device *device)
|
|||
|
||||
/* Get GPE bit assignment (EC events). */
|
||||
/* TODO: Add support for _GPE returning a package */
|
||||
status =
|
||||
acpi_evaluate_integer(ec->handle, "_GPE", NULL,
|
||||
&ec->gpe_bit);
|
||||
status = acpi_evaluate_integer(ec->handle, "_GPE", NULL, &ec->gpe);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
|
||||
ACPI_EXCEPTION((AE_INFO, status,
|
||||
"Obtaining GPE bit assignment"));
|
||||
result = -ENODEV;
|
||||
goto end;
|
||||
}
|
||||
|
@ -701,13 +671,13 @@ static int acpi_ec_add(struct acpi_device *device)
|
|||
goto end;
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
|
||||
acpi_device_name(device), acpi_device_bid(device),
|
||||
(u32) ec->gpe_bit));
|
||||
acpi_device_name(device), acpi_device_bid(device),
|
||||
(u32) ec->gpe));
|
||||
|
||||
if (!first_ec)
|
||||
first_ec = device;
|
||||
|
||||
end:
|
||||
end:
|
||||
if (result)
|
||||
kfree(ec);
|
||||
|
||||
|
@ -718,7 +688,6 @@ static int acpi_ec_remove(struct acpi_device *device, int type)
|
|||
{
|
||||
struct acpi_ec *ec = NULL;
|
||||
|
||||
|
||||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
|
@ -761,7 +730,6 @@ static int acpi_ec_start(struct acpi_device *device)
|
|||
acpi_status status = AE_OK;
|
||||
struct acpi_ec *ec = NULL;
|
||||
|
||||
|
||||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
|
@ -782,27 +750,26 @@ static int acpi_ec_start(struct acpi_device *device)
|
|||
}
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
|
||||
ec->gpe_bit, ec->command_addr, ec->data_addr));
|
||||
ec->gpe, ec->command_addr, ec->data_addr));
|
||||
|
||||
/*
|
||||
* Install GPE handler
|
||||
*/
|
||||
status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
|
||||
status = acpi_install_gpe_handler(NULL, ec->gpe,
|
||||
ACPI_GPE_EDGE_TRIGGERED,
|
||||
&acpi_ec_gpe_handler, ec);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return -ENODEV;
|
||||
}
|
||||
acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
|
||||
acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
|
||||
acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
|
||||
acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
|
||||
|
||||
status = acpi_install_address_space_handler(ec->handle,
|
||||
ACPI_ADR_SPACE_EC,
|
||||
&acpi_ec_space_handler,
|
||||
&acpi_ec_space_setup, ec);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
acpi_remove_gpe_handler(NULL, ec->gpe_bit,
|
||||
&acpi_ec_gpe_handler);
|
||||
acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
|
@ -814,7 +781,6 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
|
|||
acpi_status status = AE_OK;
|
||||
struct acpi_ec *ec = NULL;
|
||||
|
||||
|
||||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
|
@ -826,9 +792,7 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
|
|||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
status =
|
||||
acpi_remove_gpe_handler(NULL, ec->gpe_bit,
|
||||
&acpi_ec_gpe_handler);
|
||||
status = acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler);
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -841,7 +805,7 @@ acpi_fake_ecdt_callback(acpi_handle handle,
|
|||
{
|
||||
acpi_status status;
|
||||
|
||||
init_MUTEX(&ec_ecdt->sem);
|
||||
mutex_init(&ec_ecdt->lock);
|
||||
if (acpi_ec_mode == EC_INTR) {
|
||||
init_waitqueue_head(&ec_ecdt->wait);
|
||||
}
|
||||
|
@ -853,16 +817,15 @@ acpi_fake_ecdt_callback(acpi_handle handle,
|
|||
ec_ecdt->uid = -1;
|
||||
acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
|
||||
|
||||
status =
|
||||
acpi_evaluate_integer(handle, "_GPE", NULL,
|
||||
&ec_ecdt->gpe_bit);
|
||||
status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->gpe);
|
||||
if (ACPI_FAILURE(status))
|
||||
return status;
|
||||
ec_ecdt->global_lock = TRUE;
|
||||
ec_ecdt->handle = handle;
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
|
||||
ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
|
||||
ec_ecdt->gpe, ec_ecdt->command_addr,
|
||||
ec_ecdt->data_addr));
|
||||
|
||||
return AE_CTRL_TERMINATE;
|
||||
}
|
||||
|
@ -884,12 +847,11 @@ static int __init acpi_ec_fake_ecdt(void)
|
|||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
|
||||
|
||||
ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
ec_ecdt = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
if (!ec_ecdt) {
|
||||
ret = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
memset(ec_ecdt, 0, sizeof(struct acpi_ec));
|
||||
|
||||
status = acpi_get_devices(ACPI_EC_HID,
|
||||
acpi_fake_ecdt_callback, NULL, NULL);
|
||||
|
@ -901,7 +863,7 @@ static int __init acpi_ec_fake_ecdt(void)
|
|||
goto error;
|
||||
}
|
||||
return 0;
|
||||
error:
|
||||
error:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -921,30 +883,28 @@ static int __init acpi_ec_get_real_ecdt(void)
|
|||
/*
|
||||
* Generate a temporary ec context to use until the namespace is scanned
|
||||
*/
|
||||
ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
ec_ecdt = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
|
||||
if (!ec_ecdt)
|
||||
return -ENOMEM;
|
||||
memset(ec_ecdt, 0, sizeof(struct acpi_ec));
|
||||
|
||||
init_MUTEX(&ec_ecdt->sem);
|
||||
mutex_init(&ec_ecdt->lock);
|
||||
if (acpi_ec_mode == EC_INTR) {
|
||||
init_waitqueue_head(&ec_ecdt->wait);
|
||||
}
|
||||
ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
|
||||
ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
|
||||
ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
|
||||
ec_ecdt->gpe = ecdt_ptr->gpe_bit;
|
||||
/* use the GL just to be safe */
|
||||
ec_ecdt->global_lock = TRUE;
|
||||
ec_ecdt->uid = ecdt_ptr->uid;
|
||||
|
||||
status =
|
||||
acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
|
||||
status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
error:
|
||||
error:
|
||||
ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
|
||||
kfree(ec_ecdt);
|
||||
ec_ecdt = NULL;
|
||||
|
@ -970,14 +930,14 @@ int __init acpi_ec_ecdt_probe(void)
|
|||
/*
|
||||
* Install GPE handler
|
||||
*/
|
||||
status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
||||
status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe,
|
||||
ACPI_GPE_EDGE_TRIGGERED,
|
||||
&acpi_ec_gpe_handler, ec_ecdt);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
goto error;
|
||||
}
|
||||
acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
|
||||
acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
|
||||
acpi_set_gpe_type(NULL, ec_ecdt->gpe, ACPI_GPE_TYPE_RUNTIME);
|
||||
acpi_enable_gpe(NULL, ec_ecdt->gpe, ACPI_NOT_ISR);
|
||||
|
||||
status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
|
||||
ACPI_ADR_SPACE_EC,
|
||||
|
@ -985,7 +945,7 @@ int __init acpi_ec_ecdt_probe(void)
|
|||
&acpi_ec_space_setup,
|
||||
ec_ecdt);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
|
||||
acpi_remove_gpe_handler(NULL, ec_ecdt->gpe,
|
||||
&acpi_ec_gpe_handler);
|
||||
goto error;
|
||||
}
|
||||
|
@ -1004,7 +964,6 @@ static int __init acpi_ec_init(void)
|
|||
{
|
||||
int result = 0;
|
||||
|
||||
|
||||
if (acpi_disabled)
|
||||
return 0;
|
||||
|
||||
|
@ -1057,7 +1016,8 @@ static int __init acpi_ec_set_intr_mode(char *str)
|
|||
acpi_ec_mode = EC_POLL;
|
||||
}
|
||||
acpi_ec_driver.ops.add = acpi_ec_add;
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n",
|
||||
intr ? "interrupt" : "polling"));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -331,7 +331,6 @@ static void ACPI_SYSTEM_XFACE acpi_ev_global_lock_thread(void *context)
|
|||
static u32 acpi_ev_global_lock_handler(void *context)
|
||||
{
|
||||
u8 acquired = FALSE;
|
||||
acpi_status status;
|
||||
|
||||
/*
|
||||
* Attempt to get the lock
|
||||
|
|
|
@ -266,10 +266,10 @@ acpi_ex_release_mutex(union acpi_operand_object *obj_desc,
|
|||
walk_state->thread->thread_id)
|
||||
&& (obj_desc->mutex.os_mutex != ACPI_GLOBAL_LOCK)) {
|
||||
ACPI_ERROR((AE_INFO,
|
||||
"Thread %X cannot release Mutex [%4.4s] acquired by thread %X",
|
||||
(u32) walk_state->thread->thread_id,
|
||||
"Thread %lX cannot release Mutex [%4.4s] acquired by thread %lX",
|
||||
(unsigned long)walk_state->thread->thread_id,
|
||||
acpi_ut_get_node_name(obj_desc->mutex.node),
|
||||
(u32) obj_desc->mutex.owner_thread->thread_id));
|
||||
(unsigned long)obj_desc->mutex.owner_thread->thread_id));
|
||||
return_ACPI_STATUS(AE_AML_NOT_OWNER);
|
||||
}
|
||||
|
||||
|
|
|
@ -99,8 +99,8 @@ acpi_fan_write_state(struct file *file, const char __user * buffer,
|
|||
size_t count, loff_t * ppos)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_fan *fan = (struct acpi_fan *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_fan *fan = m->private;
|
||||
char state_string[12] = { '\0' };
|
||||
|
||||
|
||||
|
@ -186,10 +186,9 @@ static int acpi_fan_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
fan = kmalloc(sizeof(struct acpi_fan), GFP_KERNEL);
|
||||
fan = kzalloc(sizeof(struct acpi_fan), GFP_KERNEL);
|
||||
if (!fan)
|
||||
return -ENOMEM;
|
||||
memset(fan, 0, sizeof(struct acpi_fan));
|
||||
|
||||
fan->device = device;
|
||||
strcpy(acpi_device_name(device), "Fan");
|
||||
|
@ -229,7 +228,7 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
fan = (struct acpi_fan *)acpi_driver_data(device);
|
||||
fan = acpi_driver_data(device);
|
||||
|
||||
acpi_fan_remove_fs(device);
|
||||
|
||||
|
|
|
@ -96,7 +96,7 @@ struct acpi_find_pci_root {
|
|||
static acpi_status
|
||||
do_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
|
||||
{
|
||||
unsigned long *busnr = (unsigned long *)data;
|
||||
unsigned long *busnr = data;
|
||||
struct acpi_resource_address64 address;
|
||||
|
||||
if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
|
||||
|
@ -189,8 +189,12 @@ find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv)
|
|||
bus = tmp;
|
||||
|
||||
if (seg == find->seg && bus == find->bus)
|
||||
{
|
||||
find->handle = handle;
|
||||
status = AE_OK;
|
||||
status = AE_CTRL_TERMINATE;
|
||||
}
|
||||
else
|
||||
status = AE_OK;
|
||||
exit:
|
||||
kfree(buffer.pointer);
|
||||
return status;
|
||||
|
@ -217,7 +221,7 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
|
|||
acpi_status status;
|
||||
struct acpi_device_info *info;
|
||||
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
||||
struct acpi_find_child *find = (struct acpi_find_child *)context;
|
||||
struct acpi_find_child *find = context;
|
||||
|
||||
status = acpi_get_object_info(handle, &buffer);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
|
|
|
@ -265,8 +265,7 @@ static char *format_result(union acpi_object *object)
|
|||
|
||||
static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_polling_hotkey *poll_hotkey =
|
||||
(struct acpi_polling_hotkey *)seq->private;
|
||||
struct acpi_polling_hotkey *poll_hotkey = seq->private;
|
||||
char *buf;
|
||||
|
||||
|
||||
|
@ -577,7 +576,7 @@ init_poll_hotkey_device(union acpi_hotkey *key, char **config_entry,
|
|||
if (ACPI_FAILURE(status))
|
||||
goto do_fail_zero;
|
||||
key->poll_hotkey.poll_result =
|
||||
(union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
|
||||
kmalloc(sizeof(union acpi_object), GFP_KERNEL);
|
||||
if (!key->poll_hotkey.poll_result)
|
||||
goto do_fail_zero;
|
||||
return AE_OK;
|
||||
|
|
|
@ -309,18 +309,16 @@ static int acpi_ec_hc_add(struct acpi_device *device)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
|
||||
ec_hc = kzalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
|
||||
if (!ec_hc) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(ec_hc, 0, sizeof(struct acpi_ec_hc));
|
||||
|
||||
smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
|
||||
smbus = kzalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
|
||||
if (!smbus) {
|
||||
kfree(ec_hc);
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(smbus, 0, sizeof(struct acpi_ec_smbus));
|
||||
|
||||
ec_hc->handle = device->handle;
|
||||
strcpy(acpi_device_name(device), ACPI_EC_HC_DEVICE_NAME);
|
||||
|
@ -393,7 +391,7 @@ static void __exit acpi_ec_hc_exit(void)
|
|||
|
||||
struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device)
|
||||
{
|
||||
return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
|
||||
return acpi_driver_data(device->parent);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(acpi_get_ec_hc);
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -48,6 +48,50 @@
|
|||
#define _COMPONENT ACPI_NAMESPACE
|
||||
ACPI_MODULE_NAME("nsxfobj")
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: acpi_get_id
|
||||
*
|
||||
* PARAMETERS: Handle - Handle of object whose id is desired
|
||||
* ret_id - Where the id will be placed
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: This routine returns the owner id associated with a handle
|
||||
*
|
||||
******************************************************************************/
|
||||
acpi_status acpi_get_id(acpi_handle handle, acpi_owner_id * ret_id)
|
||||
{
|
||||
struct acpi_namespace_node *node;
|
||||
acpi_status status;
|
||||
|
||||
/* Parameter Validation */
|
||||
|
||||
if (!ret_id) {
|
||||
return (AE_BAD_PARAMETER);
|
||||
}
|
||||
|
||||
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return (status);
|
||||
}
|
||||
|
||||
/* Convert and validate the handle */
|
||||
|
||||
node = acpi_ns_map_handle_to_node(handle);
|
||||
if (!node) {
|
||||
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
|
||||
return (AE_BAD_PARAMETER);
|
||||
}
|
||||
|
||||
*ret_id = node->owner_id;
|
||||
|
||||
status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
|
||||
return (status);
|
||||
}
|
||||
|
||||
ACPI_EXPORT_SYMBOL(acpi_get_id)
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: acpi_get_type
|
||||
|
|
|
@ -248,7 +248,7 @@ int acpi_get_pxm(acpi_handle h)
|
|||
handle = phandle;
|
||||
status = acpi_evaluate_integer(handle, "_PXM", NULL, &pxm);
|
||||
if (ACPI_SUCCESS(status))
|
||||
return (int)pxm;
|
||||
return pxm;
|
||||
status = acpi_get_parent(handle, &phandle);
|
||||
} while (ACPI_SUCCESS(status));
|
||||
return -1;
|
||||
|
|
|
@ -568,6 +568,7 @@ void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */
|
|||
static void acpi_os_execute_deferred(struct work_struct *work)
|
||||
{
|
||||
struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
|
||||
|
||||
if (!dpc) {
|
||||
printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
|
||||
return;
|
||||
|
@ -1031,7 +1032,7 @@ acpi_status
|
|||
acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
|
||||
{
|
||||
*cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
|
||||
if (cache == NULL)
|
||||
if (*cache == NULL)
|
||||
return AE_ERROR;
|
||||
else
|
||||
return AE_OK;
|
||||
|
@ -1051,7 +1052,7 @@ acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
|
|||
|
||||
acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
|
||||
{
|
||||
(void)kmem_cache_shrink(cache);
|
||||
kmem_cache_shrink(cache);
|
||||
return (AE_OK);
|
||||
}
|
||||
|
||||
|
|
|
@ -122,19 +122,17 @@ int acpi_pci_bind(struct acpi_device *device)
|
|||
if (!device || !device->parent)
|
||||
return -EINVAL;
|
||||
|
||||
pathname = kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
if (!pathname)
|
||||
return -ENOMEM;
|
||||
memset(pathname, 0, ACPI_PATHNAME_MAX);
|
||||
buffer.length = ACPI_PATHNAME_MAX;
|
||||
buffer.pointer = pathname;
|
||||
|
||||
data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
|
||||
if (!data) {
|
||||
kfree(pathname);
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(data, 0, sizeof(struct acpi_pci_data));
|
||||
|
||||
acpi_get_name(device->handle, ACPI_FULL_PATHNAME, &buffer);
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Binding PCI device [%s]...\n",
|
||||
|
@ -281,10 +279,9 @@ int acpi_pci_unbind(struct acpi_device *device)
|
|||
if (!device || !device->parent)
|
||||
return -EINVAL;
|
||||
|
||||
pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
if (!pathname)
|
||||
return -ENOMEM;
|
||||
memset(pathname, 0, ACPI_PATHNAME_MAX);
|
||||
|
||||
buffer.length = ACPI_PATHNAME_MAX;
|
||||
buffer.pointer = pathname;
|
||||
|
@ -331,11 +328,9 @@ acpi_pci_bind_root(struct acpi_device *device,
|
|||
char *pathname = NULL;
|
||||
struct acpi_buffer buffer = { 0, NULL };
|
||||
|
||||
|
||||
pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
if (!pathname)
|
||||
return -ENOMEM;
|
||||
memset(pathname, 0, ACPI_PATHNAME_MAX);
|
||||
|
||||
buffer.length = ACPI_PATHNAME_MAX;
|
||||
buffer.pointer = pathname;
|
||||
|
@ -345,12 +340,11 @@ acpi_pci_bind_root(struct acpi_device *device,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
|
||||
if (!data) {
|
||||
kfree(pathname);
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(data, 0, sizeof(struct acpi_pci_data));
|
||||
|
||||
data->id = *id;
|
||||
data->bus = bus;
|
||||
|
|
|
@ -89,10 +89,9 @@ acpi_pci_irq_add_entry(acpi_handle handle,
|
|||
if (!prt)
|
||||
return -EINVAL;
|
||||
|
||||
entry = kmalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
|
||||
entry = kzalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
|
||||
if (!entry)
|
||||
return -ENOMEM;
|
||||
memset(entry, 0, sizeof(struct acpi_prt_entry));
|
||||
|
||||
entry->id.segment = segment;
|
||||
entry->id.bus = bus;
|
||||
|
@ -161,10 +160,9 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
|
|||
static int first_time = 1;
|
||||
|
||||
|
||||
pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
pathname = kzalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
|
||||
if (!pathname)
|
||||
return -ENOMEM;
|
||||
memset(pathname, 0, ACPI_PATHNAME_MAX);
|
||||
|
||||
if (first_time) {
|
||||
acpi_prt.count = 0;
|
||||
|
@ -198,11 +196,10 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
prt = kmalloc(buffer.length, GFP_KERNEL);
|
||||
prt = kzalloc(buffer.length, GFP_KERNEL);
|
||||
if (!prt) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(prt, 0, buffer.length);
|
||||
buffer.pointer = prt;
|
||||
|
||||
status = acpi_get_irq_routing_table(handle, &buffer);
|
||||
|
|
|
@ -103,7 +103,7 @@ DEFINE_MUTEX(acpi_link_lock);
|
|||
static acpi_status
|
||||
acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
|
||||
{
|
||||
struct acpi_pci_link *link = (struct acpi_pci_link *)context;
|
||||
struct acpi_pci_link *link = context;
|
||||
u32 i = 0;
|
||||
|
||||
|
||||
|
@ -307,11 +307,10 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
|
|||
if (!link || !irq)
|
||||
return -EINVAL;
|
||||
|
||||
resource = kmalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
|
||||
resource = kzalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
|
||||
if (!resource)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(resource, 0, sizeof(*resource) + 1);
|
||||
buffer.length = sizeof(*resource) + 1;
|
||||
buffer.pointer = resource;
|
||||
|
||||
|
@ -613,7 +612,7 @@ acpi_pci_link_allocate_irq(acpi_handle handle,
|
|||
return -1;
|
||||
}
|
||||
|
||||
link = (struct acpi_pci_link *)acpi_driver_data(device);
|
||||
link = acpi_driver_data(device);
|
||||
if (!link) {
|
||||
printk(KERN_ERR PREFIX "Invalid link context\n");
|
||||
return -1;
|
||||
|
@ -668,7 +667,7 @@ int acpi_pci_link_free_irq(acpi_handle handle)
|
|||
return -1;
|
||||
}
|
||||
|
||||
link = (struct acpi_pci_link *)acpi_driver_data(device);
|
||||
link = acpi_driver_data(device);
|
||||
if (!link) {
|
||||
printk(KERN_ERR PREFIX "Invalid link context\n");
|
||||
return -1;
|
||||
|
@ -718,10 +717,9 @@ static int acpi_pci_link_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
|
||||
link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
|
||||
if (!link)
|
||||
return -ENOMEM;
|
||||
memset(link, 0, sizeof(struct acpi_pci_link));
|
||||
|
||||
link->device = device;
|
||||
strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
|
||||
|
@ -808,7 +806,7 @@ static int acpi_pci_link_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
link = (struct acpi_pci_link *)acpi_driver_data(device);
|
||||
link = acpi_driver_data(device);
|
||||
|
||||
mutex_lock(&acpi_link_lock);
|
||||
list_del(&link->node);
|
||||
|
|
|
@ -98,11 +98,12 @@ void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
|
|||
|
||||
struct acpi_pci_driver **pptr = &sub_driver;
|
||||
while (*pptr) {
|
||||
if (*pptr != driver)
|
||||
continue;
|
||||
*pptr = (*pptr)->next;
|
||||
break;
|
||||
if (*pptr == driver)
|
||||
break;
|
||||
pptr = &(*pptr)->next;
|
||||
}
|
||||
BUG_ON(!*pptr);
|
||||
*pptr = (*pptr)->next;
|
||||
|
||||
if (!driver->remove)
|
||||
return;
|
||||
|
@ -119,7 +120,7 @@ EXPORT_SYMBOL(acpi_pci_unregister_driver);
|
|||
static acpi_status
|
||||
get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
|
||||
{
|
||||
int *busnr = (int *)data;
|
||||
int *busnr = data;
|
||||
struct acpi_resource_address64 address;
|
||||
|
||||
if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
|
||||
|
@ -164,10 +165,9 @@ static int acpi_pci_root_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
root = kmalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
|
||||
root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
|
||||
if (!root)
|
||||
return -ENOMEM;
|
||||
memset(root, 0, sizeof(struct acpi_pci_root));
|
||||
INIT_LIST_HEAD(&root->node);
|
||||
|
||||
root->device = device;
|
||||
|
@ -331,7 +331,7 @@ static int acpi_pci_root_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
root = (struct acpi_pci_root *)acpi_driver_data(device);
|
||||
root = acpi_driver_data(device);
|
||||
|
||||
kfree(root);
|
||||
|
||||
|
|
|
@ -108,7 +108,7 @@ acpi_power_get_context(acpi_handle handle,
|
|||
return result;
|
||||
}
|
||||
|
||||
*resource = (struct acpi_power_resource *)acpi_driver_data(device);
|
||||
*resource = acpi_driver_data(device);
|
||||
if (!resource)
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -442,7 +442,7 @@ static int acpi_power_seq_show(struct seq_file *seq, void *offset)
|
|||
struct acpi_power_resource *resource = NULL;
|
||||
|
||||
|
||||
resource = (struct acpi_power_resource *)seq->private;
|
||||
resource = seq->private;
|
||||
|
||||
if (!resource)
|
||||
goto end;
|
||||
|
@ -532,10 +532,9 @@ static int acpi_power_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
resource = kmalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
|
||||
resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
|
||||
if (!resource)
|
||||
return -ENOMEM;
|
||||
memset(resource, 0, sizeof(struct acpi_power_resource));
|
||||
|
||||
resource->device = device;
|
||||
strcpy(resource->name, device->pnp.bus_id);
|
||||
|
@ -590,7 +589,7 @@ static int acpi_power_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
resource = (struct acpi_power_resource *)acpi_driver_data(device);
|
||||
resource = acpi_driver_data(device);
|
||||
|
||||
acpi_power_remove_fs(device);
|
||||
|
||||
|
|
|
@ -277,7 +277,7 @@ static struct proc_dir_entry *acpi_processor_dir = NULL;
|
|||
|
||||
static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_processor *pr = (struct acpi_processor *)seq->private;
|
||||
struct acpi_processor *pr = seq->private;
|
||||
|
||||
|
||||
if (!pr)
|
||||
|
@ -542,12 +542,12 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
|
|||
* Don't trust it blindly
|
||||
*/
|
||||
if (processor_device_array[pr->id] != NULL &&
|
||||
processor_device_array[pr->id] != (void *)device) {
|
||||
processor_device_array[pr->id] != device) {
|
||||
printk(KERN_WARNING "BIOS reported wrong ACPI id"
|
||||
"for the processor\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
processor_device_array[pr->id] = (void *)device;
|
||||
processor_device_array[pr->id] = device;
|
||||
|
||||
processors[pr->id] = pr;
|
||||
|
||||
|
@ -578,7 +578,7 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
|
|||
|
||||
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_processor *pr = (struct acpi_processor *)data;
|
||||
struct acpi_processor *pr = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
|
||||
|
@ -615,10 +615,9 @@ static int acpi_processor_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL);
|
||||
pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
|
||||
if (!pr)
|
||||
return -ENOMEM;
|
||||
memset(pr, 0, sizeof(struct acpi_processor));
|
||||
|
||||
pr->handle = device->handle;
|
||||
strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
|
||||
|
@ -637,7 +636,7 @@ static int acpi_processor_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
pr = (struct acpi_processor *)acpi_driver_data(device);
|
||||
pr = acpi_driver_data(device);
|
||||
|
||||
if (pr->id >= NR_CPUS) {
|
||||
kfree(pr);
|
||||
|
@ -901,13 +900,13 @@ static int __init acpi_processor_init(void)
|
|||
|
||||
acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
|
||||
if (!acpi_processor_dir)
|
||||
return 0;
|
||||
return -ENOMEM;
|
||||
acpi_processor_dir->owner = THIS_MODULE;
|
||||
|
||||
result = acpi_bus_register_driver(&acpi_processor_driver);
|
||||
if (result < 0) {
|
||||
remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
|
||||
return 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
acpi_processor_install_hotplug_notify();
|
||||
|
|
|
@ -681,7 +681,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
cst = (union acpi_object *)buffer.pointer;
|
||||
cst = buffer.pointer;
|
||||
|
||||
/* There must be at least 2 elements */
|
||||
if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
|
||||
|
@ -710,14 +710,14 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
|
||||
memset(&cx, 0, sizeof(cx));
|
||||
|
||||
element = (union acpi_object *)&(cst->package.elements[i]);
|
||||
element = &(cst->package.elements[i]);
|
||||
if (element->type != ACPI_TYPE_PACKAGE)
|
||||
continue;
|
||||
|
||||
if (element->package.count != 4)
|
||||
continue;
|
||||
|
||||
obj = (union acpi_object *)&(element->package.elements[0]);
|
||||
obj = &(element->package.elements[0]);
|
||||
|
||||
if (obj->type != ACPI_TYPE_BUFFER)
|
||||
continue;
|
||||
|
@ -729,7 +729,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
continue;
|
||||
|
||||
/* There should be an easy way to extract an integer... */
|
||||
obj = (union acpi_object *)&(element->package.elements[1]);
|
||||
obj = &(element->package.elements[1]);
|
||||
if (obj->type != ACPI_TYPE_INTEGER)
|
||||
continue;
|
||||
|
||||
|
@ -762,13 +762,13 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
|
|||
}
|
||||
}
|
||||
|
||||
obj = (union acpi_object *)&(element->package.elements[2]);
|
||||
obj = &(element->package.elements[2]);
|
||||
if (obj->type != ACPI_TYPE_INTEGER)
|
||||
continue;
|
||||
|
||||
cx.latency = obj->integer.value;
|
||||
|
||||
obj = (union acpi_object *)&(element->package.elements[3]);
|
||||
obj = &(element->package.elements[3]);
|
||||
if (obj->type != ACPI_TYPE_INTEGER)
|
||||
continue;
|
||||
|
||||
|
@ -1037,7 +1037,7 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
|
|||
|
||||
static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_processor *pr = (struct acpi_processor *)seq->private;
|
||||
struct acpi_processor *pr = seq->private;
|
||||
unsigned int i;
|
||||
|
||||
|
||||
|
|
|
@ -236,7 +236,7 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
pss = (union acpi_object *)buffer.pointer;
|
||||
pss = buffer.pointer;
|
||||
if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
|
||||
printk(KERN_ERR PREFIX "Invalid _PSS data\n");
|
||||
result = -EFAULT;
|
||||
|
@ -410,7 +410,7 @@ static struct file_operations acpi_processor_perf_fops = {
|
|||
|
||||
static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_processor *pr = (struct acpi_processor *)seq->private;
|
||||
struct acpi_processor *pr = seq->private;
|
||||
int i;
|
||||
|
||||
|
||||
|
@ -451,8 +451,8 @@ acpi_processor_write_performance(struct file *file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_processor *pr = (struct acpi_processor *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_processor *pr = m->private;
|
||||
struct acpi_processor_performance *perf;
|
||||
char state_string[12] = { '\0' };
|
||||
unsigned int new_state = 0;
|
||||
|
@ -551,7 +551,7 @@ static int acpi_processor_get_psd(struct acpi_processor *pr)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
psd = (union acpi_object *) buffer.pointer;
|
||||
psd = buffer.pointer;
|
||||
if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
|
||||
result = -EFAULT;
|
||||
|
|
|
@ -208,7 +208,7 @@ int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
|
|||
if (result)
|
||||
return result;
|
||||
|
||||
pr = (struct acpi_processor *)acpi_driver_data(device);
|
||||
pr = acpi_driver_data(device);
|
||||
if (!pr)
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -348,8 +348,8 @@ static ssize_t acpi_processor_write_limit(struct file * file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_processor *pr = (struct acpi_processor *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_processor *pr = m->private;
|
||||
char limit_string[25] = { '\0' };
|
||||
int px = 0;
|
||||
int tx = 0;
|
||||
|
|
|
@ -259,7 +259,7 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
|
|||
static int acpi_processor_throttling_seq_show(struct seq_file *seq,
|
||||
void *offset)
|
||||
{
|
||||
struct acpi_processor *pr = (struct acpi_processor *)seq->private;
|
||||
struct acpi_processor *pr = seq->private;
|
||||
int i = 0;
|
||||
int result = 0;
|
||||
|
||||
|
@ -307,8 +307,8 @@ static ssize_t acpi_processor_write_throttling(struct file * file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int result = 0;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_processor *pr = (struct acpi_processor *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_processor *pr = m->private;
|
||||
char state_string[12] = { '\0' };
|
||||
|
||||
|
||||
|
|
|
@ -923,7 +923,7 @@ static struct proc_dir_entry *acpi_battery_dir = NULL;
|
|||
|
||||
static int acpi_battery_read_info(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
int cscale;
|
||||
int result = 0;
|
||||
|
||||
|
@ -1076,7 +1076,7 @@ static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
int result = 0;
|
||||
int cscale;
|
||||
|
||||
|
@ -1125,8 +1125,8 @@ static ssize_t
|
|||
acpi_battery_write_alarm(struct file *file, const char __user * buffer,
|
||||
size_t count, loff_t * ppos)
|
||||
{
|
||||
struct seq_file *seq = (struct seq_file *)file->private_data;
|
||||
struct acpi_battery *battery = (struct acpi_battery *)seq->private;
|
||||
struct seq_file *seq = file->private_data;
|
||||
struct acpi_battery *battery = seq->private;
|
||||
char alarm_string[12] = { '\0' };
|
||||
int result, old_alarm, new_alarm;
|
||||
|
||||
|
@ -1160,14 +1160,14 @@ acpi_battery_write_alarm(struct file *file, const char __user * buffer,
|
|||
if (result) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"acpi_battery_set_alarm() failed\n"));
|
||||
(void)acpi_battery_set_alarm(battery, old_alarm);
|
||||
acpi_battery_set_alarm(battery, old_alarm);
|
||||
goto end;
|
||||
}
|
||||
result = acpi_battery_get_alarm(battery);
|
||||
if (result) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"acpi_battery_get_alarm() failed\n"));
|
||||
(void)acpi_battery_set_alarm(battery, old_alarm);
|
||||
acpi_battery_set_alarm(battery, old_alarm);
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
@ -1217,7 +1217,7 @@ static struct proc_dir_entry *acpi_ac_dir = NULL;
|
|||
|
||||
static int acpi_ac_read_state(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_sbs *sbs = (struct acpi_sbs *)seq->private;
|
||||
struct acpi_sbs *sbs = seq->private;
|
||||
int result;
|
||||
|
||||
if (sbs->zombie) {
|
||||
|
@ -1302,7 +1302,7 @@ static int acpi_battery_add(struct acpi_sbs *sbs, int id)
|
|||
battery->init_state = 1;
|
||||
}
|
||||
|
||||
(void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
|
||||
result = acpi_sbs_generic_add_fs(&battery->battery_entry,
|
||||
acpi_battery_dir,
|
||||
|
@ -1485,7 +1485,7 @@ static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
|
|||
}
|
||||
|
||||
if (old_battery_present != new_battery_present) {
|
||||
(void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
result = acpi_sbs_generate_event(sbs->device,
|
||||
ACPI_SBS_BATTERY_NOTIFY_STATUS,
|
||||
new_battery_present,
|
||||
|
@ -1498,7 +1498,7 @@ static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
|
|||
}
|
||||
}
|
||||
if (old_remaining_capacity != battery->state.remaining_capacity) {
|
||||
(void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
|
||||
result = acpi_sbs_generate_event(sbs->device,
|
||||
ACPI_SBS_BATTERY_NOTIFY_STATUS,
|
||||
new_battery_present,
|
||||
|
@ -1576,12 +1576,11 @@ static int acpi_sbs_add(struct acpi_device *device)
|
|||
int id, cnt;
|
||||
acpi_status status = AE_OK;
|
||||
|
||||
sbs = kmalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
|
||||
sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
|
||||
if (!sbs) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(sbs, 0, sizeof(struct acpi_sbs));
|
||||
|
||||
cnt = 0;
|
||||
while (cnt < 10) {
|
||||
|
@ -1659,7 +1658,7 @@ static int acpi_sbs_add(struct acpi_device *device)
|
|||
init_timer(&sbs->update_timer);
|
||||
if (update_mode == QUEUE_UPDATE_MODE) {
|
||||
status = acpi_os_execute(OSL_GPE_HANDLER,
|
||||
acpi_sbs_update_queue, (void *)sbs);
|
||||
acpi_sbs_update_queue, sbs);
|
||||
if (status != AE_OK) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
|
||||
"acpi_os_execute() failed\n"));
|
||||
|
@ -1685,7 +1684,7 @@ static int acpi_sbs_add(struct acpi_device *device)
|
|||
|
||||
int acpi_sbs_remove(struct acpi_device *device, int type)
|
||||
{
|
||||
struct acpi_sbs *sbs = NULL;
|
||||
struct acpi_sbs *sbs;
|
||||
int id;
|
||||
|
||||
if (!device) {
|
||||
|
|
|
@ -984,12 +984,11 @@ acpi_add_single_object(struct acpi_device **child,
|
|||
if (!child)
|
||||
return -EINVAL;
|
||||
|
||||
device = kmalloc(sizeof(struct acpi_device), GFP_KERNEL);
|
||||
device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
|
||||
if (!device) {
|
||||
printk(KERN_ERR PREFIX "Memory allocation error\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(device, 0, sizeof(struct acpi_device));
|
||||
|
||||
device->handle = handle;
|
||||
device->parent = parent;
|
||||
|
|
|
@ -183,11 +183,11 @@ late_initcall(acpi_wakeup_device_init);
|
|||
#endif
|
||||
|
||||
/*
|
||||
* Disable all wakeup GPEs before power off.
|
||||
*
|
||||
* Disable all wakeup GPEs before entering requested sleep state.
|
||||
* @sleep_state: ACPI state
|
||||
* Since acpi_enter_sleep_state() will disable all
|
||||
* RUNTIME GPEs, we simply mark all GPES that
|
||||
* are not enabled for wakeup from S5 as RUNTIME.
|
||||
* are not enabled for wakeup from requested state as RUNTIME.
|
||||
*/
|
||||
void acpi_gpe_sleep_prepare(u32 sleep_state)
|
||||
{
|
||||
|
|
|
@ -228,7 +228,7 @@ void acpi_table_print_madt_entry(acpi_table_entry_header * header)
|
|||
static int
|
||||
acpi_table_compute_checksum(void *table_pointer, unsigned long length)
|
||||
{
|
||||
u8 *p = (u8 *) table_pointer;
|
||||
u8 *p = table_pointer;
|
||||
unsigned long remains = length;
|
||||
unsigned long sum = 0;
|
||||
|
||||
|
|
|
@ -123,7 +123,6 @@ acpi_status acpi_load_tables(void)
|
|||
|
||||
ACPI_EXPORT_SYMBOL(acpi_load_tables)
|
||||
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: acpi_load_table
|
||||
|
@ -219,6 +218,59 @@ acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
|
|||
|
||||
ACPI_EXPORT_SYMBOL(acpi_load_table)
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: acpi_unload_table_id
|
||||
*
|
||||
* PARAMETERS: table_type - Type of table to be unloaded
|
||||
* id - Owner ID of the table to be removed.
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: This routine is used to force the unload of a table (by id)
|
||||
*
|
||||
******************************************************************************/
|
||||
acpi_status acpi_unload_table_id(acpi_table_type table_type, acpi_owner_id id)
|
||||
{
|
||||
struct acpi_table_desc *table_desc;
|
||||
acpi_status status;
|
||||
|
||||
ACPI_FUNCTION_TRACE(acpi_unload_table);
|
||||
|
||||
/* Parameter validation */
|
||||
if (table_type > ACPI_TABLE_ID_MAX)
|
||||
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
||||
|
||||
/* Find table from the requested type list */
|
||||
table_desc = acpi_gbl_table_lists[table_type].next;
|
||||
while (table_desc && table_desc->owner_id != id)
|
||||
table_desc = table_desc->next;
|
||||
|
||||
if (!table_desc)
|
||||
return_ACPI_STATUS(AE_NOT_EXIST);
|
||||
|
||||
/*
|
||||
* Delete all namespace objects owned by this table. Note that these
|
||||
* objects can appear anywhere in the namespace by virtue of the AML
|
||||
* "Scope" operator. Thus, we need to track ownership by an ID, not
|
||||
* simply a position within the hierarchy
|
||||
*/
|
||||
acpi_ns_delete_namespace_by_owner(table_desc->owner_id);
|
||||
|
||||
status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
||||
if (ACPI_FAILURE(status))
|
||||
return_ACPI_STATUS(status);
|
||||
|
||||
(void)acpi_tb_uninstall_table(table_desc);
|
||||
|
||||
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
||||
|
||||
return_ACPI_STATUS(AE_OK);
|
||||
}
|
||||
|
||||
ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
|
||||
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: acpi_unload_table
|
||||
|
|
|
@ -663,7 +663,7 @@ static void acpi_thermal_run(unsigned long data)
|
|||
static void acpi_thermal_check(void *data)
|
||||
{
|
||||
int result = 0;
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)data;
|
||||
struct acpi_thermal *tz = data;
|
||||
unsigned long sleep_time = 0;
|
||||
int i = 0;
|
||||
struct acpi_thermal_state state;
|
||||
|
@ -778,7 +778,7 @@ static struct proc_dir_entry *acpi_thermal_dir;
|
|||
|
||||
static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
|
||||
struct acpi_thermal *tz = seq->private;
|
||||
|
||||
|
||||
if (!tz)
|
||||
|
@ -813,7 +813,7 @@ static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
|
|||
static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
int result = 0;
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
|
||||
struct acpi_thermal *tz = seq->private;
|
||||
|
||||
|
||||
if (!tz)
|
||||
|
@ -837,7 +837,7 @@ static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
|
||||
struct acpi_thermal *tz = seq->private;
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
|
||||
|
@ -893,8 +893,8 @@ acpi_thermal_write_trip_points(struct file *file,
|
|||
const char __user * buffer,
|
||||
size_t count, loff_t * ppos)
|
||||
{
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_thermal *tz = m->private;
|
||||
|
||||
char *limit_string;
|
||||
int num, critical, hot, passive;
|
||||
|
@ -902,12 +902,10 @@ acpi_thermal_write_trip_points(struct file *file,
|
|||
int i = 0;
|
||||
|
||||
|
||||
limit_string = kmalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
|
||||
limit_string = kzalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
|
||||
if (!limit_string)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(limit_string, 0, ACPI_THERMAL_MAX_LIMIT_STR_LEN);
|
||||
|
||||
active = kmalloc(ACPI_THERMAL_MAX_ACTIVE * sizeof(int), GFP_KERNEL);
|
||||
if (!active) {
|
||||
kfree(limit_string);
|
||||
|
@ -953,7 +951,7 @@ acpi_thermal_write_trip_points(struct file *file,
|
|||
|
||||
static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
|
||||
struct acpi_thermal *tz = seq->private;
|
||||
|
||||
|
||||
if (!tz)
|
||||
|
@ -984,8 +982,8 @@ acpi_thermal_write_cooling_mode(struct file *file,
|
|||
const char __user * buffer,
|
||||
size_t count, loff_t * ppos)
|
||||
{
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_thermal *tz = m->private;
|
||||
int result = 0;
|
||||
char mode_string[12] = { '\0' };
|
||||
|
||||
|
@ -1014,7 +1012,7 @@ acpi_thermal_write_cooling_mode(struct file *file,
|
|||
|
||||
static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
|
||||
struct acpi_thermal *tz = seq->private;
|
||||
|
||||
|
||||
if (!tz)
|
||||
|
@ -1043,8 +1041,8 @@ acpi_thermal_write_polling(struct file *file,
|
|||
const char __user * buffer,
|
||||
size_t count, loff_t * ppos)
|
||||
{
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_thermal *tz = m->private;
|
||||
int result = 0;
|
||||
char polling_string[12] = { '\0' };
|
||||
int seconds = 0;
|
||||
|
@ -1170,7 +1168,7 @@ static int acpi_thermal_remove_fs(struct acpi_device *device)
|
|||
|
||||
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_thermal *tz = (struct acpi_thermal *)data;
|
||||
struct acpi_thermal *tz = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
|
||||
|
@ -1271,10 +1269,9 @@ static int acpi_thermal_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
tz = kmalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
|
||||
tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
|
||||
if (!tz)
|
||||
return -ENOMEM;
|
||||
memset(tz, 0, sizeof(struct acpi_thermal));
|
||||
|
||||
tz->device = device;
|
||||
strcpy(tz->name, device->pnp.bus_id);
|
||||
|
@ -1324,7 +1321,7 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
tz = (struct acpi_thermal *)acpi_driver_data(device);
|
||||
tz = acpi_driver_data(device);
|
||||
|
||||
/* avoid timer adding new defer task */
|
||||
tz->zombie = 1;
|
||||
|
@ -1364,7 +1361,7 @@ static int acpi_thermal_resume(struct acpi_device *device, int state)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
tz = (struct acpi_thermal *)acpi_driver_data(device);
|
||||
tz = acpi_driver_data(device);
|
||||
|
||||
acpi_thermal_get_temperature(tz);
|
||||
|
||||
|
|
|
@ -41,6 +41,8 @@
|
|||
#include <linux/init.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/backlight.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include <acpi/acpi_drivers.h>
|
||||
|
@ -210,6 +212,7 @@ static acpi_status hci_read1(u32 reg, u32 * out1, u32 * result)
|
|||
}
|
||||
|
||||
static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
|
||||
static struct backlight_device *toshiba_backlight_device;
|
||||
static int force_fan;
|
||||
static int last_key_event;
|
||||
static int key_event_valid;
|
||||
|
@ -271,14 +274,23 @@ dispatch_write(struct file *file, const char __user * buffer,
|
|||
return result;
|
||||
}
|
||||
|
||||
static char *read_lcd(char *p)
|
||||
static int get_lcd(struct backlight_device *bd)
|
||||
{
|
||||
u32 hci_result;
|
||||
u32 value;
|
||||
|
||||
hci_read1(HCI_LCD_BRIGHTNESS, &value, &hci_result);
|
||||
if (hci_result == HCI_SUCCESS) {
|
||||
value = value >> HCI_LCD_BRIGHTNESS_SHIFT;
|
||||
return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
|
||||
} else
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
static char *read_lcd(char *p)
|
||||
{
|
||||
int value = get_lcd(NULL);
|
||||
|
||||
if (value >= 0) {
|
||||
p += sprintf(p, "brightness: %d\n", value);
|
||||
p += sprintf(p, "brightness_levels: %d\n",
|
||||
HCI_LCD_BRIGHTNESS_LEVELS);
|
||||
|
@ -289,22 +301,34 @@ static char *read_lcd(char *p)
|
|||
return p;
|
||||
}
|
||||
|
||||
static int set_lcd(int value)
|
||||
{
|
||||
u32 hci_result;
|
||||
|
||||
value = value << HCI_LCD_BRIGHTNESS_SHIFT;
|
||||
hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
|
||||
if (hci_result != HCI_SUCCESS)
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_lcd_status(struct backlight_device *bd)
|
||||
{
|
||||
return set_lcd(bd->props->brightness);
|
||||
}
|
||||
|
||||
static unsigned long write_lcd(const char *buffer, unsigned long count)
|
||||
{
|
||||
int value;
|
||||
u32 hci_result;
|
||||
int ret = count;
|
||||
|
||||
if (sscanf(buffer, " brightness : %i", &value) == 1 &&
|
||||
value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
|
||||
value = value << HCI_LCD_BRIGHTNESS_SHIFT;
|
||||
hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
|
||||
if (hci_result != HCI_SUCCESS)
|
||||
return -EFAULT;
|
||||
} else {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return count;
|
||||
value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS)
|
||||
ret = set_lcd(value);
|
||||
else
|
||||
ret = -EINVAL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static char *read_video(char *p)
|
||||
|
@ -506,6 +530,26 @@ static acpi_status __exit remove_device(void)
|
|||
return AE_OK;
|
||||
}
|
||||
|
||||
static struct backlight_properties toshiba_backlight_data = {
|
||||
.owner = THIS_MODULE,
|
||||
.get_brightness = get_lcd,
|
||||
.update_status = set_lcd_status,
|
||||
.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1,
|
||||
};
|
||||
|
||||
static void __exit toshiba_acpi_exit(void)
|
||||
{
|
||||
if (toshiba_backlight_device)
|
||||
backlight_device_unregister(toshiba_backlight_device);
|
||||
|
||||
remove_device();
|
||||
|
||||
if (toshiba_proc_dir)
|
||||
remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static int __init toshiba_acpi_init(void)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
|
@ -546,18 +590,17 @@ static int __init toshiba_acpi_init(void)
|
|||
remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
|
||||
}
|
||||
|
||||
toshiba_backlight_device = backlight_device_register("toshiba",NULL,
|
||||
NULL,
|
||||
&toshiba_backlight_data);
|
||||
if (IS_ERR(toshiba_backlight_device)) {
|
||||
printk(KERN_ERR "Could not register toshiba backlight device\n");
|
||||
toshiba_backlight_device = NULL;
|
||||
toshiba_acpi_exit();
|
||||
}
|
||||
|
||||
return (ACPI_SUCCESS(status)) ? 0 : -ENODEV;
|
||||
}
|
||||
|
||||
static void __exit toshiba_acpi_exit(void)
|
||||
{
|
||||
remove_device();
|
||||
|
||||
if (toshiba_proc_dir)
|
||||
remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
module_init(toshiba_acpi_init);
|
||||
module_exit(toshiba_acpi_exit);
|
||||
|
|
|
@ -180,8 +180,9 @@ acpi_ut_debug_print(u32 requested_debug_level,
|
|||
if (thread_id != acpi_gbl_prev_thread_id) {
|
||||
if (ACPI_LV_THREADS & acpi_dbg_level) {
|
||||
acpi_os_printf
|
||||
("\n**** Context Switch from TID %X to TID %X ****\n\n",
|
||||
(u32) acpi_gbl_prev_thread_id, (u32) thread_id);
|
||||
("\n**** Context Switch from TID %lX to TID %lX ****\n\n",
|
||||
(unsigned long) acpi_gbl_prev_thread_id,
|
||||
(unsigned long) thread_id);
|
||||
}
|
||||
|
||||
acpi_gbl_prev_thread_id = thread_id;
|
||||
|
|
|
@ -243,23 +243,24 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
|
|||
#endif
|
||||
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
|
||||
"Thread %X attempting to acquire Mutex [%s]\n",
|
||||
(u32) this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
|
||||
"Thread %lX attempting to acquire Mutex [%s]\n",
|
||||
(unsigned long) this_thread_id,
|
||||
acpi_ut_get_mutex_name(mutex_id)));
|
||||
|
||||
status = acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex,
|
||||
ACPI_WAIT_FOREVER);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
|
||||
"Thread %X acquired Mutex [%s]\n",
|
||||
(u32) this_thread_id,
|
||||
"Thread %lX acquired Mutex [%s]\n",
|
||||
(unsigned long) this_thread_id,
|
||||
acpi_ut_get_mutex_name(mutex_id)));
|
||||
|
||||
acpi_gbl_mutex_info[mutex_id].use_count++;
|
||||
acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
|
||||
} else {
|
||||
ACPI_EXCEPTION((AE_INFO, status,
|
||||
"Thread %X could not acquire Mutex [%X]",
|
||||
(u32) this_thread_id, mutex_id));
|
||||
"Thread %lX could not acquire Mutex [%X]",
|
||||
(unsigned long) this_thread_id, mutex_id));
|
||||
}
|
||||
|
||||
return (status);
|
||||
|
@ -285,7 +286,8 @@ acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
|
|||
|
||||
this_thread_id = acpi_os_get_thread_id();
|
||||
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
|
||||
"Thread %X releasing Mutex [%s]\n", (u32) this_thread_id,
|
||||
"Thread %lX releasing Mutex [%s]\n",
|
||||
(unsigned long) this_thread_id,
|
||||
acpi_ut_get_mutex_name(mutex_id)));
|
||||
|
||||
if (mutex_id > ACPI_MAX_MUTEX) {
|
||||
|
|
|
@ -83,7 +83,7 @@ acpi_extract_package(union acpi_object *package,
|
|||
return AE_BAD_DATA;
|
||||
}
|
||||
|
||||
format_string = (char *)format->pointer;
|
||||
format_string = format->pointer;
|
||||
|
||||
/*
|
||||
* Calculate size_required.
|
||||
|
@ -262,11 +262,10 @@ acpi_evaluate_integer(acpi_handle handle,
|
|||
if (!data)
|
||||
return AE_BAD_PARAMETER;
|
||||
|
||||
element = kmalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
|
||||
element = kzalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
|
||||
if (!element)
|
||||
return AE_NO_MEMORY;
|
||||
|
||||
memset(element, 0, sizeof(union acpi_object));
|
||||
buffer.length = sizeof(union acpi_object);
|
||||
buffer.pointer = element;
|
||||
status = acpi_evaluate_object(handle, pathname, arguments, &buffer);
|
||||
|
@ -321,12 +320,11 @@ acpi_evaluate_string(acpi_handle handle,
|
|||
return AE_BAD_DATA;
|
||||
}
|
||||
|
||||
*data = kmalloc(element->string.length + 1, GFP_KERNEL);
|
||||
*data = kzalloc(element->string.length + 1, GFP_KERNEL);
|
||||
if (!data) {
|
||||
printk(KERN_ERR PREFIX "Memory allocation\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(*data, 0, element->string.length + 1);
|
||||
|
||||
memcpy(*data, element->string.pointer, element->string.length);
|
||||
|
||||
|
@ -361,7 +359,7 @@ acpi_evaluate_reference(acpi_handle handle,
|
|||
if (ACPI_FAILURE(status))
|
||||
goto end;
|
||||
|
||||
package = (union acpi_object *)buffer.pointer;
|
||||
package = buffer.pointer;
|
||||
|
||||
if ((buffer.length == 0) || !package) {
|
||||
printk(KERN_ERR PREFIX "No return object (len %X ptr %p)\n",
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
*
|
||||
* Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
|
||||
* Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
|
||||
* Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
*
|
||||
|
@ -47,11 +48,11 @@
|
|||
#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
|
||||
#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
|
||||
|
||||
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x82
|
||||
#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x83
|
||||
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x84
|
||||
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x85
|
||||
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x86
|
||||
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
|
||||
#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
|
||||
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
|
||||
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
|
||||
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
|
||||
|
||||
#define ACPI_VIDEO_HEAD_INVALID (~0u - 1)
|
||||
#define ACPI_VIDEO_HEAD_END (~0u)
|
||||
|
@ -386,7 +387,7 @@ acpi_video_device_EDID(struct acpi_video_device *device,
|
|||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
obj = (union acpi_object *)buffer.pointer;
|
||||
obj = buffer.pointer;
|
||||
|
||||
if (obj && obj->type == ACPI_TYPE_BUFFER)
|
||||
*edid = obj;
|
||||
|
@ -532,11 +533,10 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
|
|||
int count = 0;
|
||||
union acpi_object *o;
|
||||
|
||||
br = kmalloc(sizeof(*br), GFP_KERNEL);
|
||||
br = kzalloc(sizeof(*br), GFP_KERNEL);
|
||||
if (!br) {
|
||||
printk(KERN_ERR "can't allocate memory\n");
|
||||
} else {
|
||||
memset(br, 0, sizeof(*br));
|
||||
br->levels = kmalloc(obj->package.count *
|
||||
sizeof *(br->levels), GFP_KERNEL);
|
||||
if (!br->levels)
|
||||
|
@ -654,8 +654,7 @@ static struct proc_dir_entry *acpi_video_dir;
|
|||
|
||||
static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_device *dev =
|
||||
(struct acpi_video_device *)seq->private;
|
||||
struct acpi_video_device *dev = seq->private;
|
||||
|
||||
|
||||
if (!dev)
|
||||
|
@ -688,8 +687,7 @@ acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
|
|||
static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
int status;
|
||||
struct acpi_video_device *dev =
|
||||
(struct acpi_video_device *)seq->private;
|
||||
struct acpi_video_device *dev = seq->private;
|
||||
unsigned long state;
|
||||
|
||||
|
||||
|
@ -727,8 +725,8 @@ acpi_video_device_write_state(struct file *file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int status;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_video_device *dev = (struct acpi_video_device *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_video_device *dev = m->private;
|
||||
char str[12] = { 0 };
|
||||
u32 state = 0;
|
||||
|
||||
|
@ -754,8 +752,7 @@ acpi_video_device_write_state(struct file *file,
|
|||
static int
|
||||
acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_device *dev =
|
||||
(struct acpi_video_device *)seq->private;
|
||||
struct acpi_video_device *dev = seq->private;
|
||||
int i;
|
||||
|
||||
|
||||
|
@ -784,8 +781,8 @@ acpi_video_device_write_brightness(struct file *file,
|
|||
const char __user * buffer,
|
||||
size_t count, loff_t * data)
|
||||
{
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_video_device *dev = (struct acpi_video_device *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_video_device *dev = m->private;
|
||||
char str[4] = { 0 };
|
||||
unsigned int level = 0;
|
||||
int i;
|
||||
|
@ -817,8 +814,7 @@ acpi_video_device_write_brightness(struct file *file,
|
|||
|
||||
static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_device *dev =
|
||||
(struct acpi_video_device *)seq->private;
|
||||
struct acpi_video_device *dev = seq->private;
|
||||
int status;
|
||||
int i;
|
||||
union acpi_object *edid = NULL;
|
||||
|
@ -866,7 +862,7 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -ENODEV;
|
||||
|
||||
vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
|
||||
vid_dev = acpi_driver_data(device);
|
||||
if (!vid_dev)
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -931,7 +927,7 @@ static int acpi_video_device_remove_fs(struct acpi_device *device)
|
|||
{
|
||||
struct acpi_video_device *vid_dev;
|
||||
|
||||
vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
|
||||
vid_dev = acpi_driver_data(device);
|
||||
if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -950,7 +946,7 @@ static int acpi_video_device_remove_fs(struct acpi_device *device)
|
|||
/* video bus */
|
||||
static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
|
||||
struct acpi_video_bus *video = seq->private;
|
||||
|
||||
|
||||
if (!video)
|
||||
|
@ -975,7 +971,7 @@ static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
|
||||
struct acpi_video_bus *video = seq->private;
|
||||
|
||||
|
||||
if (!video)
|
||||
|
@ -995,7 +991,7 @@ static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
|
||||
struct acpi_video_bus *video = seq->private;
|
||||
unsigned long options;
|
||||
int status;
|
||||
|
||||
|
@ -1033,7 +1029,7 @@ acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
|
|||
|
||||
static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
|
||||
struct acpi_video_bus *video = seq->private;
|
||||
int status;
|
||||
unsigned long id;
|
||||
|
||||
|
@ -1054,7 +1050,7 @@ static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
|
|||
|
||||
static int acpi_video_bus_DOS_seq_show(struct seq_file *seq, void *offset)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)seq->private;
|
||||
struct acpi_video_bus *video = seq->private;
|
||||
|
||||
|
||||
seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
|
||||
|
@ -1079,8 +1075,8 @@ acpi_video_bus_write_POST(struct file *file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int status;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_video_bus *video = m->private;
|
||||
char str[12] = { 0 };
|
||||
unsigned long opt, options;
|
||||
|
||||
|
@ -1119,8 +1115,8 @@ acpi_video_bus_write_DOS(struct file *file,
|
|||
size_t count, loff_t * data)
|
||||
{
|
||||
int status;
|
||||
struct seq_file *m = (struct seq_file *)file->private_data;
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)m->private;
|
||||
struct seq_file *m = file->private_data;
|
||||
struct acpi_video_bus *video = m->private;
|
||||
char str[12] = { 0 };
|
||||
unsigned long opt;
|
||||
|
||||
|
@ -1150,7 +1146,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
|
|||
struct acpi_video_bus *video;
|
||||
|
||||
|
||||
video = (struct acpi_video_bus *)acpi_driver_data(device);
|
||||
video = acpi_driver_data(device);
|
||||
|
||||
if (!acpi_device_dir(device)) {
|
||||
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
||||
|
@ -1226,7 +1222,7 @@ static int acpi_video_bus_remove_fs(struct acpi_device *device)
|
|||
struct acpi_video_bus *video;
|
||||
|
||||
|
||||
video = (struct acpi_video_bus *)acpi_driver_data(device);
|
||||
video = acpi_driver_data(device);
|
||||
|
||||
if (acpi_device_dir(device)) {
|
||||
remove_proc_entry("info", acpi_device_dir(device));
|
||||
|
@ -1263,12 +1259,10 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
|
|||
acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
|
||||
data = kmalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
|
||||
if (!data)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(data, 0, sizeof(struct acpi_video_device));
|
||||
|
||||
strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
|
||||
strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
|
||||
acpi_driver_data(device) = data;
|
||||
|
@ -1403,7 +1397,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
|
|||
return status;
|
||||
}
|
||||
|
||||
dod = (union acpi_object *)buffer.pointer;
|
||||
dod = buffer.pointer;
|
||||
if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
|
||||
status = -EFAULT;
|
||||
|
@ -1426,7 +1420,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
|
|||
|
||||
count = 0;
|
||||
for (i = 0; i < dod->package.count; i++) {
|
||||
obj = (union acpi_object *)&dod->package.elements[i];
|
||||
obj = &dod->package.elements[i];
|
||||
|
||||
if (obj->type != ACPI_TYPE_INTEGER) {
|
||||
printk(KERN_ERR PREFIX "Invalid _DOD data\n");
|
||||
|
@ -1509,8 +1503,34 @@ static int
|
|||
acpi_video_get_next_level(struct acpi_video_device *device,
|
||||
u32 level_current, u32 event)
|
||||
{
|
||||
/*Fix me */
|
||||
return level_current;
|
||||
int min, max, min_above, max_below, i, l;
|
||||
max = max_below = 0;
|
||||
min = min_above = 255;
|
||||
for (i = 0; i < device->brightness->count; i++) {
|
||||
l = device->brightness->levels[i];
|
||||
if (l < min)
|
||||
min = l;
|
||||
if (l > max)
|
||||
max = l;
|
||||
if (l < min_above && l > level_current)
|
||||
min_above = l;
|
||||
if (l > max_below && l < level_current)
|
||||
max_below = l;
|
||||
}
|
||||
|
||||
switch (event) {
|
||||
case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
|
||||
return (level_current < max) ? min_above : min;
|
||||
case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
|
||||
return (level_current < max) ? min_above : max;
|
||||
case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
|
||||
return (level_current > min) ? max_below : min;
|
||||
case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
|
||||
case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
|
||||
return 0;
|
||||
default:
|
||||
return level_current;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -1612,7 +1632,7 @@ static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
|
|||
|
||||
static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_video_bus *video = (struct acpi_video_bus *)data;
|
||||
struct acpi_video_bus *video = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
printk("video bus notify\n");
|
||||
|
@ -1654,8 +1674,7 @@ static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
|
|||
|
||||
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
|
||||
{
|
||||
struct acpi_video_device *video_device =
|
||||
(struct acpi_video_device *)data;
|
||||
struct acpi_video_device *video_device = data;
|
||||
struct acpi_device *device = NULL;
|
||||
|
||||
|
||||
|
@ -1696,10 +1715,9 @@ static int acpi_video_bus_add(struct acpi_device *device)
|
|||
if (!device)
|
||||
return -EINVAL;
|
||||
|
||||
video = kmalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
|
||||
video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
|
||||
if (!video)
|
||||
return -ENOMEM;
|
||||
memset(video, 0, sizeof(struct acpi_video_bus));
|
||||
|
||||
video->device = device;
|
||||
strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
|
||||
|
@ -1757,7 +1775,7 @@ static int acpi_video_bus_remove(struct acpi_device *device, int type)
|
|||
if (!device || !acpi_driver_data(device))
|
||||
return -EINVAL;
|
||||
|
||||
video = (struct acpi_video_bus *)acpi_driver_data(device);
|
||||
video = acpi_driver_data(device);
|
||||
|
||||
acpi_video_bus_stop_devices(video);
|
||||
|
||||
|
|
|
@ -317,7 +317,8 @@ static int __init msi_init(void)
|
|||
|
||||
/* Register backlight stuff */
|
||||
|
||||
msibl_device = backlight_device_register("msi-laptop-bl", NULL, &msibl_props);
|
||||
msibl_device = backlight_device_register("msi-laptop-bl", NULL, NULL,
|
||||
&msibl_props);
|
||||
if (IS_ERR(msibl_device))
|
||||
return PTR_ERR(msibl_device);
|
||||
|
||||
|
|
|
@ -319,13 +319,12 @@ static int ibm_get_table_from_acpi(char **bufp)
|
|||
if (bufp == NULL)
|
||||
goto read_table_done;
|
||||
|
||||
lbuf = kmalloc(size, GFP_KERNEL);
|
||||
lbuf = kzalloc(size, GFP_KERNEL);
|
||||
dbg("%s: element count: %i, ASL table size: %i, &table = 0x%p\n",
|
||||
__FUNCTION__, package->package.count, size, lbuf);
|
||||
|
||||
if (lbuf) {
|
||||
*bufp = lbuf;
|
||||
memset(lbuf, 0, size);
|
||||
} else {
|
||||
size = -ENOMEM;
|
||||
goto read_table_done;
|
||||
|
|
|
@ -281,7 +281,7 @@ static int appledisplay_probe(struct usb_interface *iface,
|
|||
/* Register backlight device */
|
||||
snprintf(bl_name, sizeof(bl_name), "appledisplay%d",
|
||||
atomic_inc_return(&count_displays) - 1);
|
||||
pdata->bd = backlight_device_register(bl_name, pdata,
|
||||
pdata->bd = backlight_device_register(bl_name, NULL, NULL,
|
||||
&appledisplay_bl_data);
|
||||
if (IS_ERR(pdata->bd)) {
|
||||
err("appledisplay: Backlight registration failed");
|
||||
|
|
|
@ -1834,7 +1834,7 @@ static void aty128_bl_init(struct aty128fb_par *par)
|
|||
|
||||
snprintf(name, sizeof(name), "aty128bl%d", info->node);
|
||||
|
||||
bd = backlight_device_register(name, par, &aty128_bl_data);
|
||||
bd = backlight_device_register(name, info->dev, par, &aty128_bl_data);
|
||||
if (IS_ERR(bd)) {
|
||||
info->bl_dev = NULL;
|
||||
printk(KERN_WARNING "aty128: Backlight registration failed\n");
|
||||
|
|
|
@ -2211,7 +2211,7 @@ static void aty_bl_init(struct atyfb_par *par)
|
|||
|
||||
snprintf(name, sizeof(name), "atybl%d", info->node);
|
||||
|
||||
bd = backlight_device_register(name, par, &aty_bl_data);
|
||||
bd = backlight_device_register(name, info->dev, par, &aty_bl_data);
|
||||
if (IS_ERR(bd)) {
|
||||
info->bl_dev = NULL;
|
||||
printk(KERN_WARNING "aty: Backlight registration failed\n");
|
||||
|
|
|
@ -163,7 +163,7 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
|
|||
|
||||
snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node);
|
||||
|
||||
bd = backlight_device_register(name, pdata, &radeon_bl_data);
|
||||
bd = backlight_device_register(name, rinfo->info->dev, pdata, &radeon_bl_data);
|
||||
if (IS_ERR(bd)) {
|
||||
rinfo->info->bl_dev = NULL;
|
||||
printk("radeonfb: Backlight registration failed\n");
|
||||
|
|
|
@ -216,8 +216,10 @@ static const struct class_device_attribute bl_class_device_attributes[] = {
|
|||
* Creates and registers new backlight class_device. Returns either an
|
||||
* ERR_PTR() or a pointer to the newly allocated device.
|
||||
*/
|
||||
struct backlight_device *backlight_device_register(const char *name, void *devdata,
|
||||
struct backlight_properties *bp)
|
||||
struct backlight_device *backlight_device_register(const char *name,
|
||||
struct device *dev,
|
||||
void *devdata,
|
||||
struct backlight_properties *bp)
|
||||
{
|
||||
int i, rc;
|
||||
struct backlight_device *new_bd;
|
||||
|
@ -232,6 +234,7 @@ struct backlight_device *backlight_device_register(const char *name, void *devda
|
|||
new_bd->props = bp;
|
||||
memset(&new_bd->class_dev, 0, sizeof(new_bd->class_dev));
|
||||
new_bd->class_dev.class = &backlight_class;
|
||||
new_bd->class_dev.dev = dev;
|
||||
strlcpy(new_bd->class_dev.class_id, name, KOBJ_NAME_LEN);
|
||||
class_set_devdata(&new_bd->class_dev, devdata);
|
||||
|
||||
|
|
|
@ -141,7 +141,7 @@ void nvidia_bl_init(struct nvidia_par *par)
|
|||
|
||||
snprintf(name, sizeof(name), "nvidiabl%d", info->node);
|
||||
|
||||
bd = backlight_device_register(name, par, &nvidia_bl_data);
|
||||
bd = backlight_device_register(name, info->dev, par, &nvidia_bl_data);
|
||||
if (IS_ERR(bd)) {
|
||||
info->bl_dev = NULL;
|
||||
printk(KERN_WARNING "nvidia: Backlight registration failed\n");
|
||||
|
|
|
@ -384,7 +384,7 @@ static void riva_bl_init(struct riva_par *par)
|
|||
|
||||
snprintf(name, sizeof(name), "rivabl%d", info->node);
|
||||
|
||||
bd = backlight_device_register(name, par, &riva_bl_data);
|
||||
bd = backlight_device_register(name, info->dev, par, &riva_bl_data);
|
||||
if (IS_ERR(bd)) {
|
||||
info->bl_dev = NULL;
|
||||
printk(KERN_WARNING "riva: Backlight registration failed\n");
|
||||
|
|
|
@ -97,11 +97,12 @@ acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address);
|
|||
|
||||
acpi_status acpi_load_tables(void);
|
||||
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
acpi_status acpi_load_table(struct acpi_table_header *table_ptr);
|
||||
|
||||
acpi_status acpi_unload_table(acpi_table_type table_type);
|
||||
acpi_status acpi_unload_table_id(acpi_table_type table_type, acpi_owner_id id);
|
||||
|
||||
#ifdef ACPI_FUTURE_USAGE
|
||||
acpi_status acpi_unload_table(acpi_table_type table_type);
|
||||
acpi_status
|
||||
acpi_get_table_header(acpi_table_type table_type,
|
||||
u32 instance, struct acpi_table_header *out_table_header);
|
||||
|
@ -180,6 +181,8 @@ acpi_get_next_object(acpi_object_type type,
|
|||
|
||||
acpi_status acpi_get_type(acpi_handle object, acpi_object_type * out_type);
|
||||
|
||||
acpi_status acpi_get_id(acpi_handle object, acpi_owner_id * out_type);
|
||||
|
||||
acpi_status acpi_get_parent(acpi_handle object, acpi_handle * out_handle);
|
||||
|
||||
/*
|
||||
|
|
|
@ -56,30 +56,8 @@
|
|||
#define ACPI_ENABLE_IRQS() local_irq_enable()
|
||||
#define ACPI_FLUSH_CPU_CACHE() wbinvd()
|
||||
|
||||
|
||||
static inline int
|
||||
__acpi_acquire_global_lock (unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1));
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return (new < 3) ? -1 : 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
__acpi_release_global_lock (unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = old & ~0x3;
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return old & 0x1;
|
||||
}
|
||||
int __acpi_acquire_global_lock(unsigned int *lock);
|
||||
int __acpi_release_global_lock(unsigned int *lock);
|
||||
|
||||
#define ACPI_ACQUIRE_GLOBAL_LOCK(GLptr, Acq) \
|
||||
((Acq) = __acpi_acquire_global_lock((unsigned int *) GLptr))
|
||||
|
|
|
@ -54,30 +54,8 @@
|
|||
#define ACPI_ENABLE_IRQS() local_irq_enable()
|
||||
#define ACPI_FLUSH_CPU_CACHE() wbinvd()
|
||||
|
||||
|
||||
static inline int
|
||||
__acpi_acquire_global_lock (unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1));
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return (new < 3) ? -1 : 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
__acpi_release_global_lock (unsigned int *lock)
|
||||
{
|
||||
unsigned int old, new, val;
|
||||
do {
|
||||
old = *lock;
|
||||
new = old & ~0x3;
|
||||
val = cmpxchg(lock, old, new);
|
||||
} while (unlikely (val != old));
|
||||
return old & 0x1;
|
||||
}
|
||||
int __acpi_acquire_global_lock(unsigned int *lock);
|
||||
int __acpi_release_global_lock(unsigned int *lock);
|
||||
|
||||
#define ACPI_ACQUIRE_GLOBAL_LOCK(GLptr, Acq) \
|
||||
((Acq) = __acpi_acquire_global_lock((unsigned int *) GLptr))
|
||||
|
|
|
@ -54,7 +54,7 @@ struct backlight_device {
|
|||
};
|
||||
|
||||
extern struct backlight_device *backlight_device_register(const char *name,
|
||||
void *devdata, struct backlight_properties *bp);
|
||||
struct device *dev,void *devdata,struct backlight_properties *bp);
|
||||
extern void backlight_device_unregister(struct backlight_device *bd);
|
||||
|
||||
#define to_backlight_device(obj) container_of(obj, struct backlight_device, class_dev)
|
||||
|
|
|
@ -60,9 +60,11 @@ static void power_down(suspend_disk_method_t mode)
|
|||
{
|
||||
switch(mode) {
|
||||
case PM_DISK_PLATFORM:
|
||||
kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
|
||||
pm_ops->enter(PM_SUSPEND_DISK);
|
||||
break;
|
||||
if (pm_ops && pm_ops->enter) {
|
||||
kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
|
||||
pm_ops->enter(PM_SUSPEND_DISK);
|
||||
break;
|
||||
}
|
||||
case PM_DISK_SHUTDOWN:
|
||||
kernel_power_off();
|
||||
break;
|
||||
|
|
|
@ -29,7 +29,7 @@
|
|||
DEFINE_MUTEX(pm_mutex);
|
||||
|
||||
struct pm_ops *pm_ops;
|
||||
suspend_disk_method_t pm_disk_mode = PM_DISK_SHUTDOWN;
|
||||
suspend_disk_method_t pm_disk_mode = PM_DISK_PLATFORM;
|
||||
|
||||
/**
|
||||
* pm_set_ops - Set the global power method table.
|
||||
|
|
Loading…
Reference in a new issue