2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2009-04-08 09:39:38 -06:00
|
|
|
* button.c - ACPI Button Driver
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
2005-08-03 15:55:21 -06:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2006-11-08 22:40:13 -07:00
|
|
|
#include <linux/input.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2013-12-02 17:49:16 -07:00
|
|
|
#include <linux/acpi.h>
|
2013-03-11 03:17:04 -06:00
|
|
|
#include <acpi/button.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-28 14:45:54 -06:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_BUTTON_CLASS "button"
|
2005-08-03 15:55:21 -06:00
|
|
|
#define ACPI_BUTTON_FILE_INFO "info"
|
|
|
|
#define ACPI_BUTTON_FILE_STATE "state"
|
|
|
|
#define ACPI_BUTTON_TYPE_UNKNOWN 0x00
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_BUTTON_NOTIFY_STATUS 0x80
|
|
|
|
|
|
|
|
#define ACPI_BUTTON_SUBCLASS_POWER "power"
|
2005-08-04 22:44:28 -06:00
|
|
|
#define ACPI_BUTTON_HID_POWER "PNP0C0C"
|
2009-04-08 09:40:04 -06:00
|
|
|
#define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button"
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_BUTTON_TYPE_POWER 0x01
|
|
|
|
|
|
|
|
#define ACPI_BUTTON_SUBCLASS_SLEEP "sleep"
|
|
|
|
#define ACPI_BUTTON_HID_SLEEP "PNP0C0E"
|
2009-04-08 09:40:04 -06:00
|
|
|
#define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button"
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_BUTTON_TYPE_SLEEP 0x03
|
|
|
|
|
|
|
|
#define ACPI_BUTTON_SUBCLASS_LID "lid"
|
|
|
|
#define ACPI_BUTTON_HID_LID "PNP0C0D"
|
|
|
|
#define ACPI_BUTTON_DEVICE_NAME_LID "Lid Switch"
|
|
|
|
#define ACPI_BUTTON_TYPE_LID 0x05
|
|
|
|
|
2016-06-01 04:10:48 -06:00
|
|
|
#define ACPI_BUTTON_LID_INIT_IGNORE 0x00
|
|
|
|
#define ACPI_BUTTON_LID_INIT_OPEN 0x01
|
|
|
|
#define ACPI_BUTTON_LID_INIT_METHOD 0x02
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define _COMPONENT ACPI_BUTTON_COMPONENT
|
2007-02-12 20:42:12 -07:00
|
|
|
ACPI_MODULE_NAME("button");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
MODULE_AUTHOR("Paul Diefenbaugh");
|
2007-02-12 21:50:02 -07:00
|
|
|
MODULE_DESCRIPTION("ACPI Button Driver");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2007-07-23 06:44:41 -06:00
|
|
|
static const struct acpi_device_id button_device_ids[] = {
|
|
|
|
{ACPI_BUTTON_HID_LID, 0},
|
|
|
|
{ACPI_BUTTON_HID_SLEEP, 0},
|
|
|
|
{ACPI_BUTTON_HID_SLEEPF, 0},
|
|
|
|
{ACPI_BUTTON_HID_POWER, 0},
|
|
|
|
{ACPI_BUTTON_HID_POWERF, 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, button_device_ids);
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_button_add(struct acpi_device *device);
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_button_remove(struct acpi_device *device);
|
2009-03-30 11:48:18 -06:00
|
|
|
static void acpi_button_notify(struct acpi_device *device, u32 event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-09 15:00:02 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2014-07-22 16:59:04 -06:00
|
|
|
static int acpi_button_suspend(struct device *dev);
|
2012-06-27 15:26:51 -06:00
|
|
|
static int acpi_button_resume(struct device *dev);
|
2014-02-12 20:19:07 -07:00
|
|
|
#else
|
2014-07-22 16:59:04 -06:00
|
|
|
#define acpi_button_suspend NULL
|
2014-02-12 20:19:07 -07:00
|
|
|
#define acpi_button_resume NULL
|
2012-08-09 15:00:02 -06:00
|
|
|
#endif
|
2014-07-22 16:59:04 -06:00
|
|
|
static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume);
|
2012-06-27 15:26:51 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct acpi_driver acpi_button_driver = {
|
2007-02-12 21:33:40 -07:00
|
|
|
.name = "button",
|
2005-08-04 22:44:28 -06:00
|
|
|
.class = ACPI_BUTTON_CLASS,
|
2007-07-23 06:44:41 -06:00
|
|
|
.ids = button_device_ids,
|
2005-08-04 22:44:28 -06:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_button_add,
|
|
|
|
.remove = acpi_button_remove,
|
2009-03-30 11:48:18 -06:00
|
|
|
.notify = acpi_button_notify,
|
2006-11-08 22:40:13 -07:00
|
|
|
},
|
2012-06-27 15:26:51 -06:00
|
|
|
.drv.pm = &acpi_button_pm,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_button {
|
2006-11-08 22:40:13 -07:00
|
|
|
unsigned int type;
|
|
|
|
struct input_dev *input;
|
|
|
|
char phys[32]; /* for input device */
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long pushed;
|
2014-07-22 16:59:04 -06:00
|
|
|
bool suspended;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2009-09-10 16:28:02 -06:00
|
|
|
static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
|
|
|
|
static struct acpi_device *lid_device;
|
2016-06-01 04:10:48 -06:00
|
|
|
static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
|
2009-09-10 16:28:02 -06:00
|
|
|
|
2005-08-03 15:55:21 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
FS Interface (/proc)
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static struct proc_dir_entry *acpi_button_dir;
|
2011-03-22 20:21:40 -06:00
|
|
|
static struct proc_dir_entry *acpi_lid_dir;
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
static int acpi_lid_evaluate_state(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
unsigned long long lid_state;
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(device->handle, "_LID", NULL, &lid_state);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return lid_state ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_lid_notify_state(struct acpi_device *device, int state)
|
|
|
|
{
|
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* input layer checks if event is redundant */
|
|
|
|
input_report_switch(button->input, SW_LID, !state);
|
|
|
|
input_sync(button->input);
|
|
|
|
|
|
|
|
if (state)
|
|
|
|
pm_wakeup_event(&device->dev, 0);
|
|
|
|
|
|
|
|
ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
|
|
|
|
if (ret == NOTIFY_DONE)
|
|
|
|
ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
|
|
|
|
device);
|
|
|
|
if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
|
|
|
|
/*
|
|
|
|
* It is also regarded as success if the notifier_chain
|
|
|
|
* returns NOTIFY_OK or NOTIFY_DONE.
|
|
|
|
*/
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-08-03 15:55:21 -06:00
|
|
|
static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2009-04-08 09:39:59 -06:00
|
|
|
struct acpi_device *device = seq->private;
|
2016-06-01 04:10:42 -06:00
|
|
|
int state;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
state = acpi_lid_evaluate_state(device);
|
2006-11-08 22:40:13 -07:00
|
|
|
seq_printf(seq, "state: %s\n",
|
2016-06-01 04:10:42 -06:00
|
|
|
state < 0 ? "unsupported" : (state ? "open" : "closed"));
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-03-31 16:16:14 -06:00
|
|
|
return single_open(file, acpi_button_state_seq_show, PDE_DATA(inode));
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
static const struct file_operations acpi_button_state_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = acpi_button_state_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_button_add_fs(struct acpi_device *device)
|
2005-08-03 15:55:21 -06:00
|
|
|
{
|
2009-04-08 09:39:49 -06:00
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
2005-08-04 22:44:28 -06:00
|
|
|
struct proc_dir_entry *entry = NULL;
|
2011-03-22 20:21:40 -06:00
|
|
|
int ret = 0;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
/* procfs I/F for ACPI lid device only */
|
|
|
|
if (button->type != ACPI_BUTTON_TYPE_LID)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (acpi_button_dir || acpi_lid_dir) {
|
|
|
|
printk(KERN_ERR PREFIX "More than one Lid device found!\n");
|
|
|
|
return -EEXIST;
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
/* create /proc/acpi/button */
|
|
|
|
acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
|
|
|
|
if (!acpi_button_dir)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
/* create /proc/acpi/button/lid */
|
|
|
|
acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
|
|
|
|
if (!acpi_lid_dir) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto remove_button_dir;
|
|
|
|
}
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
/* create /proc/acpi/button/lid/LID/ */
|
|
|
|
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir);
|
|
|
|
if (!acpi_device_dir(device)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto remove_lid_dir;
|
|
|
|
}
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
/* create /proc/acpi/button/lid/LID/state */
|
|
|
|
entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
|
|
|
|
S_IRUGO, acpi_device_dir(device),
|
|
|
|
&acpi_button_state_fops, device);
|
|
|
|
if (!entry) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto remove_dev_dir;
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
done:
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
remove_dev_dir:
|
|
|
|
remove_proc_entry(acpi_device_bid(device),
|
|
|
|
acpi_lid_dir);
|
|
|
|
acpi_device_dir(device) = NULL;
|
|
|
|
remove_lid_dir:
|
|
|
|
remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
|
2016-07-29 09:08:41 -06:00
|
|
|
acpi_lid_dir = NULL;
|
2011-03-22 20:21:40 -06:00
|
|
|
remove_button_dir:
|
|
|
|
remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
|
2016-07-29 09:08:41 -06:00
|
|
|
acpi_button_dir = NULL;
|
2011-03-22 20:21:40 -06:00
|
|
|
goto done;
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_button_remove_fs(struct acpi_device *device)
|
2005-08-03 15:55:21 -06:00
|
|
|
{
|
2006-11-08 22:40:13 -07:00
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
if (button->type != ACPI_BUTTON_TYPE_LID)
|
|
|
|
return 0;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2011-03-22 20:21:40 -06:00
|
|
|
remove_proc_entry(ACPI_BUTTON_FILE_STATE,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(acpi_device_bid(device),
|
|
|
|
acpi_lid_dir);
|
|
|
|
acpi_device_dir(device) = NULL;
|
|
|
|
remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
|
2016-07-29 09:08:41 -06:00
|
|
|
acpi_lid_dir = NULL;
|
2011-03-22 20:21:40 -06:00
|
|
|
remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
|
2016-07-29 09:08:41 -06:00
|
|
|
acpi_button_dir = NULL;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-08-03 15:55:21 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
2009-09-10 16:28:02 -06:00
|
|
|
int acpi_lid_notifier_register(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_register(&acpi_lid_notifier, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_lid_notifier_register);
|
|
|
|
|
|
|
|
int acpi_lid_notifier_unregister(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_unregister(&acpi_lid_notifier, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_lid_notifier_unregister);
|
|
|
|
|
|
|
|
int acpi_lid_open(void)
|
|
|
|
{
|
2009-10-07 15:39:46 -06:00
|
|
|
if (!lid_device)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
return acpi_lid_evaluate_state(lid_device);
|
2009-09-10 16:28:02 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_lid_open);
|
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
static int acpi_lid_update_state(struct acpi_device *device)
|
2007-10-22 04:18:18 -06:00
|
|
|
{
|
2016-06-01 04:10:42 -06:00
|
|
|
int state;
|
2009-04-08 09:39:38 -06:00
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
state = acpi_lid_evaluate_state(device);
|
|
|
|
if (state < 0)
|
|
|
|
return state;
|
2009-09-10 16:28:02 -06:00
|
|
|
|
2016-06-01 04:10:42 -06:00
|
|
|
return acpi_lid_notify_state(device, state);
|
2007-10-22 04:18:18 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-06-01 04:10:48 -06:00
|
|
|
static void acpi_lid_initialize_state(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
switch (lid_init_state) {
|
|
|
|
case ACPI_BUTTON_LID_INIT_OPEN:
|
|
|
|
(void)acpi_lid_notify_state(device, 1);
|
|
|
|
break;
|
|
|
|
case ACPI_BUTTON_LID_INIT_METHOD:
|
|
|
|
(void)acpi_lid_update_state(device);
|
|
|
|
break;
|
|
|
|
case ACPI_BUTTON_LID_INIT_IGNORE:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-30 11:48:18 -06:00
|
|
|
static void acpi_button_notify(struct acpi_device *device, u32 event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-03-30 11:48:18 -06:00
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
2006-11-08 22:40:13 -07:00
|
|
|
struct input_dev *input;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (event) {
|
2009-03-30 11:48:18 -06:00
|
|
|
case ACPI_FIXED_HARDWARE_EVENT:
|
|
|
|
event = ACPI_BUTTON_NOTIFY_STATUS;
|
|
|
|
/* fall through */
|
2005-04-16 16:20:36 -06:00
|
|
|
case ACPI_BUTTON_NOTIFY_STATUS:
|
2006-11-08 22:40:13 -07:00
|
|
|
input = button->input;
|
|
|
|
if (button->type == ACPI_BUTTON_TYPE_LID) {
|
2016-06-01 04:10:42 -06:00
|
|
|
acpi_lid_update_state(device);
|
2006-11-08 22:40:13 -07:00
|
|
|
} else {
|
2014-07-22 16:59:04 -06:00
|
|
|
int keycode;
|
|
|
|
|
|
|
|
pm_wakeup_event(&device->dev, 0);
|
|
|
|
if (button->suspended)
|
|
|
|
break;
|
2006-11-08 22:40:13 -07:00
|
|
|
|
2014-07-22 16:59:04 -06:00
|
|
|
keycode = test_bit(KEY_SLEEP, input->keybit) ?
|
|
|
|
KEY_SLEEP : KEY_POWER;
|
2006-11-08 22:40:13 -07:00
|
|
|
input_report_key(input, keycode, 1);
|
|
|
|
input_sync(input);
|
|
|
|
input_report_key(input, keycode, 0);
|
2008-10-23 15:28:33 -06:00
|
|
|
input_sync(input);
|
2011-01-06 15:36:01 -07:00
|
|
|
|
2014-03-15 11:37:13 -06:00
|
|
|
acpi_bus_generate_netlink_event(
|
|
|
|
device->pnp.device_class,
|
|
|
|
dev_name(&device->dev),
|
|
|
|
event, ++button->pushed);
|
2006-11-08 22:40:13 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-04 22:44:28 -06:00
|
|
|
"Unsupported event [0x%x]\n", event));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-09 15:00:02 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2014-07-22 16:59:04 -06:00
|
|
|
static int acpi_button_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *device = to_acpi_device(dev);
|
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
|
|
|
|
|
|
|
button->suspended = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-27 15:26:51 -06:00
|
|
|
static int acpi_button_resume(struct device *dev)
|
2007-10-22 04:18:18 -06:00
|
|
|
{
|
2012-06-27 15:26:51 -06:00
|
|
|
struct acpi_device *device = to_acpi_device(dev);
|
2009-04-08 09:39:49 -06:00
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
2009-04-08 09:39:38 -06:00
|
|
|
|
2014-07-22 16:59:04 -06:00
|
|
|
button->suspended = false;
|
2016-06-01 04:10:48 -06:00
|
|
|
if (button->type == ACPI_BUTTON_TYPE_LID)
|
|
|
|
acpi_lid_initialize_state(device);
|
2007-10-22 04:18:18 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2012-08-09 15:00:02 -06:00
|
|
|
#endif
|
2007-10-22 04:18:18 -06:00
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
static int acpi_button_add(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
struct acpi_button *button;
|
|
|
|
struct input_dev *input;
|
2010-10-01 02:54:00 -06:00
|
|
|
const char *hid = acpi_device_hid(device);
|
|
|
|
char *name, *class;
|
2009-04-08 09:39:49 -06:00
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!button)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = button;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
button->input = input = input_allocate_device();
|
|
|
|
if (!input) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto err_free_button;
|
|
|
|
}
|
|
|
|
|
2009-04-08 09:39:54 -06:00
|
|
|
name = acpi_device_name(device);
|
|
|
|
class = acpi_device_class(device);
|
|
|
|
|
2009-04-08 09:40:04 -06:00
|
|
|
if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
|
|
|
|
!strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
button->type = ACPI_BUTTON_TYPE_POWER;
|
2009-04-08 09:39:54 -06:00
|
|
|
strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
|
|
|
|
sprintf(class, "%s/%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
|
2009-04-08 09:40:04 -06:00
|
|
|
} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
|
|
|
|
!strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
button->type = ACPI_BUTTON_TYPE_SLEEP;
|
2009-04-08 09:39:54 -06:00
|
|
|
strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
|
|
|
|
sprintf(class, "%s/%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
|
2009-04-08 09:39:54 -06:00
|
|
|
} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
button->type = ACPI_BUTTON_TYPE_LID;
|
2009-04-08 09:39:54 -06:00
|
|
|
strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
|
|
|
|
sprintf(class, "%s/%s",
|
2005-04-16 16:20:36 -06:00
|
|
|
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
|
2005-08-04 22:44:28 -06:00
|
|
|
} else {
|
2009-04-08 09:39:54 -06:00
|
|
|
printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
|
2006-11-08 22:40:13 -07:00
|
|
|
error = -ENODEV;
|
|
|
|
goto err_free_input;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
error = acpi_button_add_fs(device);
|
|
|
|
if (error)
|
|
|
|
goto err_free_input;
|
|
|
|
|
2009-04-08 09:39:54 -06:00
|
|
|
snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
|
2006-11-08 22:40:13 -07:00
|
|
|
|
2009-04-08 09:39:54 -06:00
|
|
|
input->name = name;
|
2006-11-08 22:40:13 -07:00
|
|
|
input->phys = button->phys;
|
|
|
|
input->id.bustype = BUS_HOST;
|
|
|
|
input->id.product = button->type;
|
2008-03-04 16:06:35 -07:00
|
|
|
input->dev.parent = &device->dev;
|
2005-08-03 15:55:21 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (button->type) {
|
2006-11-08 22:40:13 -07:00
|
|
|
case ACPI_BUTTON_TYPE_POWER:
|
2013-09-12 01:32:03 -06:00
|
|
|
input_set_capability(input, EV_KEY, KEY_POWER);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2006-11-08 22:40:13 -07:00
|
|
|
|
|
|
|
case ACPI_BUTTON_TYPE_SLEEP:
|
2013-09-12 01:32:03 -06:00
|
|
|
input_set_capability(input, EV_KEY, KEY_SLEEP);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2006-11-08 22:40:13 -07:00
|
|
|
|
|
|
|
case ACPI_BUTTON_TYPE_LID:
|
2013-09-12 01:32:03 -06:00
|
|
|
input_set_capability(input, EV_SW, SW_LID);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
error = input_register_device(input);
|
|
|
|
if (error)
|
2009-03-30 11:48:18 -06:00
|
|
|
goto err_remove_fs;
|
2009-09-10 16:28:02 -06:00
|
|
|
if (button->type == ACPI_BUTTON_TYPE_LID) {
|
2016-06-01 04:10:48 -06:00
|
|
|
acpi_lid_initialize_state(device);
|
2009-09-10 16:28:02 -06:00
|
|
|
/*
|
|
|
|
* This assumes there's only one lid device, or if there are
|
|
|
|
* more we only care about the last one...
|
|
|
|
*/
|
|
|
|
lid_device = device;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-08 09:39:54 -06:00
|
|
|
printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
|
2006-11-08 22:40:13 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-08 22:40:13 -07:00
|
|
|
err_remove_fs:
|
|
|
|
acpi_button_remove_fs(device);
|
|
|
|
err_free_input:
|
|
|
|
input_free_device(input);
|
|
|
|
err_free_button:
|
|
|
|
kfree(button);
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_button_remove(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-04-08 09:39:49 -06:00
|
|
|
struct acpi_button *button = acpi_driver_data(device);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_button_remove_fs(device);
|
2006-11-08 22:40:13 -07:00
|
|
|
input_unregister_device(button->input);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(button);
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-06-01 04:10:48 -06:00
|
|
|
static int param_set_lid_init_state(const char *val, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
if (!strncmp(val, "open", sizeof("open") - 1)) {
|
|
|
|
lid_init_state = ACPI_BUTTON_LID_INIT_OPEN;
|
|
|
|
pr_info("Notify initial lid state as open\n");
|
|
|
|
} else if (!strncmp(val, "method", sizeof("method") - 1)) {
|
|
|
|
lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
|
|
|
|
pr_info("Notify initial lid state with _LID return value\n");
|
|
|
|
} else if (!strncmp(val, "ignore", sizeof("ignore") - 1)) {
|
|
|
|
lid_init_state = ACPI_BUTTON_LID_INIT_IGNORE;
|
|
|
|
pr_info("Do not notify initial lid state\n");
|
|
|
|
} else
|
|
|
|
result = -EINVAL;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int param_get_lid_init_state(char *buffer, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
switch (lid_init_state) {
|
|
|
|
case ACPI_BUTTON_LID_INIT_OPEN:
|
|
|
|
return sprintf(buffer, "open");
|
|
|
|
case ACPI_BUTTON_LID_INIT_METHOD:
|
|
|
|
return sprintf(buffer, "method");
|
|
|
|
case ACPI_BUTTON_LID_INIT_IGNORE:
|
|
|
|
return sprintf(buffer, "ignore");
|
|
|
|
default:
|
|
|
|
return sprintf(buffer, "invalid");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_param_call(lid_init_state,
|
|
|
|
param_set_lid_init_state, param_get_lid_init_state,
|
|
|
|
NULL, 0644);
|
|
|
|
MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state");
|
|
|
|
|
2012-09-07 01:31:39 -06:00
|
|
|
module_acpi_driver(acpi_button_driver);
|