Skip to content

cloud-kernel
cloud-kernel

openanolis / cloud-kernel
1 年多 前同步成功

通知 160
Star 36
Fork 7
cloud-kernel
cloud-kernel
提交 f1d4661a 编写于 作者: A Alexey Starikovskiy 提交者： Len Brown
浏览文件
操作

ACPI: Battery: simplify update scheme 

Signed-off-by: NAlexey Starikovskiy <astarikovskiy@suse.de>
Signed-off-by: NLen Brown <len.brown@intel.com>
上级 038fdea2
隐藏空白更改
内联 并排
Showing with 57 addition and 223 deletion
drivers/acpi/battery.c
浏览文件 @ f1d4661a
......@@ -27,6 +27,7 @@
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/jiffies.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
......@@ -41,27 +42,18 @@
#define ACPI_BATTERY_DEVICE_NAME "Battery"
#define ACPI_BATTERY_NOTIFY_STATUS 0x80
#define ACPI_BATTERY_NOTIFY_INFO 0x81
#define ACPI_BATTERY_UNITS_WATTS "mW"
#define ACPI_BATTERY_UNITS_AMPS "mA"
#define _COMPONENT ACPI_BATTERY_COMPONENT
#define ACPI_BATTERY_UPDATE_TIME 0
#define ACPI_BATTERY_NONE_UPDATE 0
#define ACPI_BATTERY_EASY_UPDATE 1
#define ACPI_BATTERY_INIT_UPDATE 2
ACPI_MODULE_NAME("battery");
MODULE_AUTHOR("Paul Diefenbaugh");
MODULE_DESCRIPTION("ACPI Battery Driver");
MODULE_LICENSE("GPL");
static unsigned int update_time = ACPI_BATTERY_UPDATE_TIME;
/* 0 - every time, > 0 - by update_time */
module_param(update_time, uint, 0644);
static unsigned int cache_time = 1000;
module_param(cache_time, uint, 0644);
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
extern struct proc_dir_entry *acpi_lock_battery_dir(void);
extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
......@@ -95,15 +87,12 @@ enum acpi_battery_files {
};
struct acpi_battery {
struct acpi_device *device;
struct mutex lock;
unsigned long alarm;
unsigned long update_time[ACPI_BATTERY_NUMFILES];
int state;
struct acpi_device *device;
unsigned long update_time;
int present_rate;
int remaining_capacity;
int present_voltage;
int power_unit;
int design_capacity;
int last_full_capacity;
int technology;
......@@ -112,14 +101,14 @@ struct acpi_battery {
int design_capacity_low;
int capacity_granularity_1;
int capacity_granularity_2;
int alarm;
char model_number[32];
char serial_number[32];
char type[32];
char oem_info[32];
u8 present_prev;
int state;
int power_unit;
u8 alarm_present;
u8 init_update;
u8 update[ACPI_BATTERY_NUMFILES];
};
inline int acpi_battery_present(struct acpi_battery *battery)
......@@ -127,33 +116,15 @@ inline int acpi_battery_present(struct acpi_battery *battery)
return battery->device->status.battery_present;
}
inline char *acpi_battery_power_units(struct acpi_battery *battery)
inline char *acpi_battery_units(struct acpi_battery *battery)
{
if (battery->power_unit)
return ACPI_BATTERY_UNITS_AMPS;
else
return ACPI_BATTERY_UNITS_WATTS;
}
inline acpi_handle acpi_battery_handle(struct acpi_battery *battery)
{
return battery->device->handle;
return (battery->power_unit)?"mA":"mW";
}
/* --------------------------------------------------------------------------
Battery Management
-------------------------------------------------------------------------- */
static void acpi_battery_check_result(struct acpi_battery *battery, int result)
{
if (!battery)
return;
if (result) {
battery->init_update = 1;
}
}
struct acpi_offsets {
size_t offset; /* offset inside struct acpi_sbs_battery */
u8 mode; /* int or string? */
......@@ -228,11 +199,10 @@ static int acpi_battery_get_info(struct acpi_battery *battery)
acpi_status status = 0;
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
battery->update_time[ACPI_BATTERY_INFO] = get_seconds();
if (!acpi_battery_present(battery))
return 0;
mutex_lock(&battery->lock);
status = acpi_evaluate_object(acpi_battery_handle(battery), "_BIF",
status = acpi_evaluate_object(battery->device->handle, "_BIF",
NULL, &buffer);
mutex_unlock(&battery->lock);
if (ACPI_FAILURE(status)) {
......@@ -251,13 +221,16 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
acpi_status status = 0;
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
battery->update_time[ACPI_BATTERY_STATE] = get_seconds();
if (!acpi_battery_present(battery))
return 0;
if (battery->update_time &&
time_before(jiffies, battery->update_time +
msecs_to_jiffies(cache_time)))
return 0;
mutex_lock(&battery->lock);
status = acpi_evaluate_object(acpi_battery_handle(battery), "_BST",
status = acpi_evaluate_object(battery->device->handle, "_BST",
NULL, &buffer);
mutex_unlock(&battery->lock);
......@@ -267,14 +240,13 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
}
result = extract_package(battery, buffer.pointer,
state_offsets, ARRAY_SIZE(state_offsets));
battery->update_time = jiffies;
kfree(buffer.pointer);
return result;
}
static int acpi_battery_get_alarm(struct acpi_battery *battery)
{
battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
return 0;
}
......@@ -285,8 +257,6 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery,
union acpi_object arg0 = { ACPI_TYPE_INTEGER };
struct acpi_object_list arg_list = { 1, &arg0 };
battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
if (!acpi_battery_present(battery))
return -ENODEV;
......@@ -296,8 +266,8 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery,
arg0.integer.value = alarm;
mutex_lock(&battery->lock);
status = acpi_evaluate_object(acpi_battery_handle(battery), "_BTP",
&arg_list, NULL);
status = acpi_evaluate_object(battery->device->handle, "_BTP",
&arg_list, NULL);
mutex_unlock(&battery->lock);
if (ACPI_FAILURE(status))
return -ENODEV;
......@@ -311,112 +281,36 @@ static int acpi_battery_set_alarm(struct acpi_battery *battery,
static int acpi_battery_init_alarm(struct acpi_battery *battery)
{
int result = 0;
acpi_status status = AE_OK;
acpi_handle handle = NULL;
unsigned long alarm = battery->alarm;
/* See if alarms are supported, and if so, set default */
status = acpi_get_handle(acpi_battery_handle(battery), "_BTP", &handle);
if (ACPI_SUCCESS(status)) {
battery->alarm_present = 1;
if (!alarm) {
alarm = battery->design_capacity_warning;
}
result = acpi_battery_set_alarm(battery, alarm);
if (result)
goto end;
} else {
status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
if (ACPI_FAILURE(status)) {
battery->alarm_present = 0;
return 0;
}
end:
return result;
battery->alarm_present = 1;
if (!battery->alarm)
battery->alarm = battery->design_capacity_warning;
return acpi_battery_set_alarm(battery, battery->alarm);
}
static int acpi_battery_init_update(struct acpi_battery *battery)
static int acpi_battery_update(struct acpi_battery *battery)
{
int result = 0;
result = acpi_battery_get_status(battery);
if (result)
int saved_present = acpi_battery_present(battery);
int result = acpi_battery_get_status(battery);
if (result || !acpi_battery_present(battery))
return result;
battery->present_prev = acpi_battery_present(battery);
if (acpi_battery_present(battery)) {
if (saved_present != acpi_battery_present(battery) ||
!battery->update_time) {
battery->update_time = 0;
result = acpi_battery_get_info(battery);
if (result)
return result;
result = acpi_battery_get_state(battery);
if (result)
return result;
acpi_battery_init_alarm(battery);
}
return result;
}
static int acpi_battery_update(struct acpi_battery *battery,
int update, int *update_result_ptr)
{
int result = 0;
int update_result = ACPI_BATTERY_NONE_UPDATE;
if (!acpi_battery_present(battery)) {
update = 1;
}
if (battery->init_update) {
result = acpi_battery_init_update(battery);
if (result)
goto end;
update_result = ACPI_BATTERY_INIT_UPDATE;
} else if (update) {
result = acpi_battery_get_status(battery);
if (result)
goto end;
if ((!battery->present_prev & acpi_battery_present(battery))
|| (battery->present_prev & !acpi_battery_present(battery))) {
result = acpi_battery_init_update(battery);
if (result)
goto end;
update_result = ACPI_BATTERY_INIT_UPDATE;
} else {
update_result = ACPI_BATTERY_EASY_UPDATE;
}
}
end:
battery->init_update = (result != 0);
*update_result_ptr = update_result;
return result;
}
static void acpi_battery_notify_update(struct acpi_battery *battery)
{
acpi_battery_get_status(battery);
if (battery->init_update) {
return;
}
if ((!battery->present_prev &
acpi_battery_present(battery)) ||
(battery->present_prev &
!acpi_battery_present(battery))) {
battery->init_update = 1;
} else {
battery->update[ACPI_BATTERY_INFO] = 1;
battery->update[ACPI_BATTERY_STATE] = 1;
battery->update[ACPI_BATTERY_ALARM] = 1;
}
return acpi_battery_get_state(battery);
}
/* --------------------------------------------------------------------------
......@@ -442,7 +336,7 @@ static int acpi_battery_print_info(struct seq_file *seq, int result)
/* Battery Units */
units = acpi_battery_power_units(battery);
units = acpi_battery_units(battery);
if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
seq_printf(seq, "design capacity: unknown\n");
......@@ -511,7 +405,7 @@ static int acpi_battery_print_state(struct seq_file *seq, int result)
/* Battery Units */
units = acpi_battery_power_units(battery);
units = acpi_battery_units(battery);
if (!(battery->state & 0x04))
seq_printf(seq, "capacity state: ok\n");
......@@ -571,13 +465,13 @@ static int acpi_battery_print_alarm(struct seq_file *seq, int result)
/* Battery Units */
units = acpi_battery_power_units(battery);
units = acpi_battery_units(battery);
seq_printf(seq, "alarm: ");
if (!battery->alarm)
seq_printf(seq, "unsupported\n");
else
seq_printf(seq, "%lu %sh\n", battery->alarm, units);
seq_printf(seq, "%u %sh\n", battery->alarm, units);
end:
......@@ -587,49 +481,35 @@ static int acpi_battery_print_alarm(struct seq_file *seq, int result)
return result;
}
static ssize_t
acpi_battery_write_alarm(struct file *file,
const char __user * buffer,
size_t count, loff_t * ppos)
static ssize_t acpi_battery_write_alarm(struct file *file,
const char __user * buffer,
size_t count, loff_t * ppos)
{
int result = 0;
char alarm_string[12] = { '\0' };
struct seq_file *m = file->private_data;
struct acpi_battery *battery = m->private;
int update_result = ACPI_BATTERY_NONE_UPDATE;
if (!battery || (count > sizeof(alarm_string) - 1))
return -EINVAL;
result = acpi_battery_update(battery, 1, &update_result);
if (result) {
result = -ENODEV;
goto end;
}
if (!acpi_battery_present(battery)) {
result = -ENODEV;
goto end;
}
if (copy_from_user(alarm_string, buffer, count)) {
result = -EFAULT;
goto end;
}
alarm_string[count] = '\0';
result = acpi_battery_set_alarm(battery,
simple_strtoul(alarm_string, NULL, 0));
if (result)
goto end;
battery->alarm = simple_strtol(alarm_string, NULL, 0);
result = acpi_battery_set_alarm(battery, battery->alarm);
end:
acpi_battery_check_result(battery, result);
if (!result)
result = count;
return count;
return result;
}
......@@ -648,28 +528,8 @@ static struct acpi_read_mux {
static int acpi_battery_read(int fid, struct seq_file *seq)
{
struct acpi_battery *battery = seq->private;
int result = 0;
int update_result = ACPI_BATTERY_NONE_UPDATE;
int update = 0;
update = (get_seconds() - battery->update_time[fid] >= update_time);
update = (update | battery->update[fid]);
result = acpi_battery_update(battery, update, &update_result);
if (result)
goto end;
if (update_result == ACPI_BATTERY_EASY_UPDATE) {
result = acpi_read_funcs[fid].get(battery);
if (result)
goto end;
}
end:
result = acpi_read_funcs[fid].print(seq, result);
acpi_battery_check_result(battery, result);
battery->update[fid] = result;
return result;
int result = acpi_battery_update(battery);
return acpi_read_funcs[fid].print(seq, result);
}
static int acpi_battery_read_info(struct seq_file *seq, void *offset)
......@@ -793,33 +653,16 @@ 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 = data;
struct acpi_device *device = NULL;
struct acpi_device *device;
if (!battery)
return;
device = battery->device;
switch (event) {
case ACPI_BATTERY_NOTIFY_STATUS:
case ACPI_BATTERY_NOTIFY_INFO:
case ACPI_NOTIFY_BUS_CHECK:
case ACPI_NOTIFY_DEVICE_CHECK:
device = battery->device;
acpi_battery_notify_update(battery);
acpi_bus_generate_proc_event(device, event,
acpi_battery_update(battery);
acpi_bus_generate_proc_event(device, event,
acpi_battery_present(battery));
acpi_bus_generate_netlink_event(device->pnp.device_class,
device->dev.bus_id, event,
acpi_battery_present(battery));
acpi_bus_generate_netlink_event(device->pnp.device_class,
device->dev.bus_id, event,
acpi_battery_present(battery));
break;
default:
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Unsupported event [0x%x]\n", event));
break;
}
return;
}
static int acpi_battery_add(struct acpi_device *device)
......@@ -840,12 +683,7 @@ static int acpi_battery_add(struct acpi_device *device)
strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
acpi_driver_data(device) = battery;
mutex_init(&battery->lock);
result = acpi_battery_get_status(battery);
if (result)
goto end;
battery->init_update = 1;
acpi_battery_update(battery);
result = acpi_battery_add_fs(device);
if (result)
goto end;
......@@ -898,14 +736,10 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
static int acpi_battery_resume(struct acpi_device *device)
{
struct acpi_battery *battery;
if (!device)
return -EINVAL;
battery = device->driver_data;
battery->init_update = 1;
battery = acpi_driver_data(device);
battery->update_time = 0;
return 0;
}
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或