URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [acpi/] [button.c] - Blame information for rev 78

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  acpi_button.c - ACPI Button Driver ($Revision: 30 $)
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
 
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#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>
 
#define ACPI_BUTTON_COMPONENT           0x00080000
#define ACPI_BUTTON_CLASS               "button"
#define ACPI_BUTTON_FILE_INFO           "info"
#define ACPI_BUTTON_FILE_STATE          "state"
#define ACPI_BUTTON_TYPE_UNKNOWN        0x00
#define ACPI_BUTTON_NOTIFY_STATUS       0x80
 
#define ACPI_BUTTON_SUBCLASS_POWER      "power"
#define ACPI_BUTTON_HID_POWER           "PNP0C0C"
#define ACPI_BUTTON_DEVICE_NAME_POWER   "Power Button (CM)"
#define ACPI_BUTTON_DEVICE_NAME_POWERF  "Power Button (FF)"
#define ACPI_BUTTON_TYPE_POWER          0x01
#define ACPI_BUTTON_TYPE_POWERF         0x02
 
#define ACPI_BUTTON_SUBCLASS_SLEEP      "sleep"
#define ACPI_BUTTON_HID_SLEEP           "PNP0C0E"
#define ACPI_BUTTON_DEVICE_NAME_SLEEP   "Sleep Button (CM)"
#define ACPI_BUTTON_DEVICE_NAME_SLEEPF  "Sleep Button (FF)"
#define ACPI_BUTTON_TYPE_SLEEP          0x03
#define ACPI_BUTTON_TYPE_SLEEPF         0x04
 
#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
 
#define _COMPONENT              ACPI_BUTTON_COMPONENT
ACPI_MODULE_NAME("button");
 
MODULE_AUTHOR("Paul Diefenbaugh");
MODULE_DESCRIPTION("ACPI Button Driver");
MODULE_LICENSE("GPL");
 
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);
 
static int acpi_button_add(struct acpi_device *device);
static int acpi_button_remove(struct acpi_device *device, int type);
static int acpi_button_resume(struct acpi_device *device);
static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
 
static struct acpi_driver acpi_button_driver = {
        .name = "button",
        .class = ACPI_BUTTON_CLASS,
        .ids = button_device_ids,
        .ops = {
                .add = acpi_button_add,
                .resume = acpi_button_resume,
                .remove = acpi_button_remove,
        },
};
 
struct acpi_button {
        struct acpi_device *device;     /* Fixed button kludge */
        unsigned int type;
        struct input_dev *input;
        char phys[32];                  /* for input device */
        unsigned long pushed;
};
 
static const struct file_operations acpi_button_info_fops = {
        .open = acpi_button_info_open_fs,
        .read = seq_read,
        .llseek = seq_lseek,
        .release = single_release,
};
 
static const struct file_operations acpi_button_state_fops = {
        .open = acpi_button_state_open_fs,
        .read = seq_read,
        .llseek = seq_lseek,
        .release = single_release,
};
 
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */
 
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 = seq->private;
 
        if (!button || !button->device)
                return 0;
 
        seq_printf(seq, "type:                    %s\n",
                   acpi_device_name(button->device));
 
        return 0;
}
 
static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
{
        return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
}
 
static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
{
        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);
        seq_printf(seq, "state:      %s\n",
                   ACPI_FAILURE(status) ? "unsupported" :
                        (state ? "open" : "closed"));
        return 0;
}
 
static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
{
        return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
}
 
static struct proc_dir_entry *acpi_power_dir;
static struct proc_dir_entry *acpi_sleep_dir;
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;
 
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
 
        button = acpi_driver_data(device);
 
        switch (button->type) {
        case ACPI_BUTTON_TYPE_POWER:
        case ACPI_BUTTON_TYPE_POWERF:
                if (!acpi_power_dir)
                        acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
                                                    acpi_button_dir);
                entry = acpi_power_dir;
                break;
        case ACPI_BUTTON_TYPE_SLEEP:
        case ACPI_BUTTON_TYPE_SLEEPF:
                if (!acpi_sleep_dir)
                        acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
                                                    acpi_button_dir);
                entry = acpi_sleep_dir;
                break;
        case ACPI_BUTTON_TYPE_LID:
                if (!acpi_lid_dir)
                        acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
                                                  acpi_button_dir);
                entry = acpi_lid_dir;
                break;
        }
 
        if (!entry)
                return -ENODEV;
        entry->owner = THIS_MODULE;
 
        acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
        if (!acpi_device_dir(device))
                return -ENODEV;
        acpi_device_dir(device)->owner = THIS_MODULE;
 
        /* 'info' [R] */
        entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
                                  S_IRUGO, acpi_device_dir(device));
        if (!entry)
                return -ENODEV;
        else {
                entry->proc_fops = &acpi_button_info_fops;
                entry->data = acpi_driver_data(device);
                entry->owner = THIS_MODULE;
        }
 
        /* show lid state [R] */
        if (button->type == ACPI_BUTTON_TYPE_LID) {
                entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
                                          S_IRUGO, acpi_device_dir(device));
                if (!entry)
                        return -ENODEV;
                else {
                        entry->proc_fops = &acpi_button_state_fops;
                        entry->data = acpi_driver_data(device);
                        entry->owner = THIS_MODULE;
                }
        }
 
        return 0;
}
 
static int acpi_button_remove_fs(struct acpi_device *device)
{
        struct acpi_button *button = acpi_driver_data(device);
 
        if (acpi_device_dir(device)) {
                if (button->type == ACPI_BUTTON_TYPE_LID)
                        remove_proc_entry(ACPI_BUTTON_FILE_STATE,
                                          acpi_device_dir(device));
                remove_proc_entry(ACPI_BUTTON_FILE_INFO,
                                  acpi_device_dir(device));
 
                remove_proc_entry(acpi_device_bid(device),
                                  acpi_device_dir(device)->parent);
                acpi_device_dir(device) = NULL;
        }
 
        return 0;
}
 
/* --------------------------------------------------------------------------
                                Driver Interface
   -------------------------------------------------------------------------- */
static int acpi_lid_send_state(struct acpi_button *button)
{
        unsigned long state;
        acpi_status status;
 
        status = acpi_evaluate_integer(button->device->handle, "_LID", NULL,
                                        &state);
        if (ACPI_FAILURE(status))
                return -ENODEV;
        /* input layer checks if event is redundant */
        input_report_switch(button->input, SW_LID, !state);
        return 0;
}
 
static void acpi_button_notify(acpi_handle handle, u32 event, void *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) {
                        acpi_lid_send_state(button);
                } 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_proc_event(button->device, event,
                                        ++button->pushed);
                break;
        default:
                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                  "Unsupported event [0x%x]\n", event));
                break;
        }
 
        return;
}
 
static acpi_status acpi_button_notify_fixed(void *data)
{
        struct acpi_button *button = data;
 
        if (!button)
                return AE_BAD_PARAMETER;
 
        acpi_button_notify(button->device->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
 
        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 int acpi_button_resume(struct acpi_device *device)
{
        struct acpi_button *button;
        if (!device)
                return -EINVAL;
        button = acpi_driver_data(device);
        if (button && button->type == ACPI_BUTTON_TYPE_LID)
                return acpi_lid_send_state(button);
        return 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 error;
        struct acpi_button *button;
        struct input_dev *input;
 
        if (!device)
                return -EINVAL;
 
        button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
        if (!button)
                return -ENOMEM;
 
        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.
         */
        if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {
                button->type = ACPI_BUTTON_TYPE_POWER;
                strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER);
                sprintf(acpi_device_class(device), "%s/%s",
                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
        } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {
                button->type = ACPI_BUTTON_TYPE_POWERF;
                strcpy(acpi_device_name(device),
                       ACPI_BUTTON_DEVICE_NAME_POWERF);
                sprintf(acpi_device_class(device), "%s/%s",
                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
        } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
                button->type = ACPI_BUTTON_TYPE_SLEEP;
                strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP);
                sprintf(acpi_device_class(device), "%s/%s",
                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
        } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {
                button->type = ACPI_BUTTON_TYPE_SLEEPF;
                strcpy(acpi_device_name(device),
                       ACPI_BUTTON_DEVICE_NAME_SLEEPF);
                sprintf(acpi_device_class(device), "%s/%s",
                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
        } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
                button->type = ACPI_BUTTON_TYPE_LID;
                strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID);
                sprintf(acpi_device_class(device), "%s/%s",
                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
        } else {
                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
                            acpi_device_hid(device));
                error = -ENODEV;
                goto err_free_input;
        }
 
        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:
                input->evbit[0] = BIT_MASK(EV_KEY);
                set_bit(KEY_POWER, input->keybit);
                break;
 
        case ACPI_BUTTON_TYPE_SLEEP:
        case ACPI_BUTTON_TYPE_SLEEPF:
                input->evbit[0] = BIT_MASK(EV_KEY);
                set_bit(KEY_SLEEP, input->keybit);
                break;
 
        case ACPI_BUTTON_TYPE_LID:
                input->evbit[0] = BIT_MASK(EV_SW);
                set_bit(SW_LID, input->swbit);
                break;
        }
 
        error = input_register_device(input);
        if (error)
                goto err_remove_handlers;
        if (button->type == ACPI_BUTTON_TYPE_LID)
                acpi_lid_send_state(button);
 
        if (device->wakeup.flags.valid) {
                /* Button's GPE is run-wake GPE */
                acpi_set_gpe_type(device->wakeup.gpe_device,
                                  device->wakeup.gpe_number,
                                  ACPI_GPE_TYPE_WAKE_RUN);
                acpi_enable_gpe(device->wakeup.gpe_device,
                                device->wakeup.gpe_number, ACPI_NOT_ISR);
                device->wakeup.state.enabled = 1;
        }
 
        printk(KERN_INFO PREFIX "%s [%s]\n",
               acpi_device_name(device), acpi_device_bid(device));
 
        return 0;
 
 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)
{
        struct acpi_button *button;
 
        if (!device || !acpi_driver_data(device))
                return -EINVAL;
 
        button = acpi_driver_data(device);
 
        acpi_button_remove_notify_handlers(button);
        acpi_button_remove_fs(device);
        input_unregister_device(button->input);
        kfree(button);
 
        return 0;
}
 
static int __init acpi_button_init(void)
{
        int result;
 
        acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
        if (!acpi_button_dir)
                return -ENODEV;
        acpi_button_dir->owner = THIS_MODULE;
        result = acpi_bus_register_driver(&acpi_button_driver);
        if (result < 0) {
                remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
                return -ENODEV;
        }
 
        return 0;
}
 
static void __exit acpi_button_exit(void)
{
        acpi_bus_unregister_driver(&acpi_button_driver);
 
        if (acpi_power_dir)
                remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
        if (acpi_sleep_dir)
                remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
        if (acpi_lid_dir)
                remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
        remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
}
 
module_init(acpi_button_init);
module_exit(acpi_button_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [acpi/] [button.c] - Blame information for rev 78

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* acpi_button.c - ACPI Button Driver ($Revision: 30 $)`
3			`*`
4			`* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>`
5			`* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>`
6			`*`
7			`* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
8			`*`
9			`* This program is free software; you can redistribute it and/or modify`
10			`* it under the terms of the GNU General Public License as published by`
11			`* the Free Software Foundation; either version 2 of the License, or (at`
12			`* your option) any later version.`
13			`*`
14			`* This program is distributed in the hope that it will be useful, but`
15			`* WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
17			`* General Public License for more details.`
18			`*`
19			`* You should have received a copy of the GNU General Public License along`
20			`* with this program; if not, write to the Free Software Foundation, Inc.,`
21			`* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.`
22			`*`
23			`* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
24			`*/`
25
26			`#include <linux/kernel.h>`
27			`#include <linux/module.h>`
28			`#include <linux/init.h>`
29			`#include <linux/types.h>`
30			`#include <linux/proc_fs.h>`
31			`#include <linux/seq_file.h>`
32			`#include <linux/input.h>`
33			`#include <acpi/acpi_bus.h>`
34			`#include <acpi/acpi_drivers.h>`
35
36			`#define ACPI_BUTTON_COMPONENT 0x00080000`
37			`#define ACPI_BUTTON_CLASS "button"`
38			`#define ACPI_BUTTON_FILE_INFO "info"`
39			`#define ACPI_BUTTON_FILE_STATE "state"`
40			`#define ACPI_BUTTON_TYPE_UNKNOWN 0x00`
41			`#define ACPI_BUTTON_NOTIFY_STATUS 0x80`
42
43			`#define ACPI_BUTTON_SUBCLASS_POWER "power"`
44			`#define ACPI_BUTTON_HID_POWER "PNP0C0C"`
45			`#define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button (CM)"`
46			`#define ACPI_BUTTON_DEVICE_NAME_POWERF "Power Button (FF)"`
47			`#define ACPI_BUTTON_TYPE_POWER 0x01`
48			`#define ACPI_BUTTON_TYPE_POWERF 0x02`
49
50			`#define ACPI_BUTTON_SUBCLASS_SLEEP "sleep"`
51			`#define ACPI_BUTTON_HID_SLEEP "PNP0C0E"`
52			`#define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button (CM)"`
53			`#define ACPI_BUTTON_DEVICE_NAME_SLEEPF "Sleep Button (FF)"`
54			`#define ACPI_BUTTON_TYPE_SLEEP 0x03`
55			`#define ACPI_BUTTON_TYPE_SLEEPF 0x04`
56
57			`#define ACPI_BUTTON_SUBCLASS_LID "lid"`
58			`#define ACPI_BUTTON_HID_LID "PNP0C0D"`
59			`#define ACPI_BUTTON_DEVICE_NAME_LID "Lid Switch"`
60			`#define ACPI_BUTTON_TYPE_LID 0x05`
61
62			`#define _COMPONENT ACPI_BUTTON_COMPONENT`
63			`ACPI_MODULE_NAME("button");`
64
65			`MODULE_AUTHOR("Paul Diefenbaugh");`
66			`MODULE_DESCRIPTION("ACPI Button Driver");`
67			`MODULE_LICENSE("GPL");`
68
69			`static const struct acpi_device_id button_device_ids[] = {`
70			`{ACPI_BUTTON_HID_LID, 0},`
71			`{ACPI_BUTTON_HID_SLEEP, 0},`
72			`{ACPI_BUTTON_HID_SLEEPF, 0},`
73			`{ACPI_BUTTON_HID_POWER, 0},`
74			`{ACPI_BUTTON_HID_POWERF, 0},`
75			`{"", 0},`
76			`};`
77			`MODULE_DEVICE_TABLE(acpi, button_device_ids);`
78
79			`static int acpi_button_add(struct acpi_device *device);`
80			`static int acpi_button_remove(struct acpi_device *device, int type);`
81			`static int acpi_button_resume(struct acpi_device *device);`
82			`static int acpi_button_info_open_fs(struct inode inode, struct file file);`
83			`static int acpi_button_state_open_fs(struct inode inode, struct file file);`
84
85			`static struct acpi_driver acpi_button_driver = {`
86			`.name = "button",`
87			`.class = ACPI_BUTTON_CLASS,`
88			`.ids = button_device_ids,`
89			`.ops = {`
90			`.add = acpi_button_add,`
91			`.resume = acpi_button_resume,`
92			`.remove = acpi_button_remove,`
93			`},`
94			`};`
95
96			`struct acpi_button {`
97			`struct acpi_device device; / Fixed button kludge */`
98			`unsigned int type;`
99			`struct input_dev *input;`
100			`char phys[32]; /* for input device */`
101			`unsigned long pushed;`
102			`};`
103
104			`static const struct file_operations acpi_button_info_fops = {`
105			`.open = acpi_button_info_open_fs,`
106			`.read = seq_read,`
107			`.llseek = seq_lseek,`
108			`.release = single_release,`
109			`};`
110
111			`static const struct file_operations acpi_button_state_fops = {`
112			`.open = acpi_button_state_open_fs,`
113			`.read = seq_read,`
114			`.llseek = seq_lseek,`
115			`.release = single_release,`
116			`};`
117
118			`/* --------------------------------------------------------------------------`
119			`FS Interface (/proc)`
120			`-------------------------------------------------------------------------- */`
121
122			`static struct proc_dir_entry *acpi_button_dir;`
123
124			`static int acpi_button_info_seq_show(struct seq_file seq, void offset)`
125			`{`
126			`struct acpi_button *button = seq->private;`
127
128			`if (!button \|\| !button->device)`
129			`return 0;`
130
131			`seq_printf(seq, "type: %s\n",`
132			`acpi_device_name(button->device));`
133
134			`return 0;`
135			`}`
136
137			`static int acpi_button_info_open_fs(struct inode inode, struct file file)`
138			`{`
139			`return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);`
140			`}`
141
142			`static int acpi_button_state_seq_show(struct seq_file seq, void offset)`
143			`{`
144			`struct acpi_button *button = seq->private;`
145			`acpi_status status;`
146			`unsigned long state;`
147
148			`if (!button \|\| !button->device)`
149			`return 0;`
150
151			`status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);`
152			`seq_printf(seq, "state: %s\n",`
153			`ACPI_FAILURE(status) ? "unsupported" :`
154			`(state ? "open" : "closed"));`
155			`return 0;`
156			`}`
157
158			`static int acpi_button_state_open_fs(struct inode inode, struct file file)`
159			`{`
160			`return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);`
161			`}`
162
163			`static struct proc_dir_entry *acpi_power_dir;`
164			`static struct proc_dir_entry *acpi_sleep_dir;`
165			`static struct proc_dir_entry *acpi_lid_dir;`
166
167			`static int acpi_button_add_fs(struct acpi_device *device)`
168			`{`
169			`struct proc_dir_entry *entry = NULL;`
170			`struct acpi_button *button;`
171
172			`if (!device \|\| !acpi_driver_data(device))`
173			`return -EINVAL;`
174
175			`button = acpi_driver_data(device);`
176
177			`switch (button->type) {`
178			`case ACPI_BUTTON_TYPE_POWER:`
179			`case ACPI_BUTTON_TYPE_POWERF:`
180			`if (!acpi_power_dir)`
181			`acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,`
182			`acpi_button_dir);`
183			`entry = acpi_power_dir;`
184			`break;`
185			`case ACPI_BUTTON_TYPE_SLEEP:`
186			`case ACPI_BUTTON_TYPE_SLEEPF:`
187			`if (!acpi_sleep_dir)`
188			`acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,`
189			`acpi_button_dir);`
190			`entry = acpi_sleep_dir;`
191			`break;`
192			`case ACPI_BUTTON_TYPE_LID:`
193			`if (!acpi_lid_dir)`
194			`acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,`
195			`acpi_button_dir);`
196			`entry = acpi_lid_dir;`
197			`break;`
198			`}`
199
200			`if (!entry)`
201			`return -ENODEV;`
202			`entry->owner = THIS_MODULE;`
203
204			`acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);`
205			`if (!acpi_device_dir(device))`
206			`return -ENODEV;`
207			`acpi_device_dir(device)->owner = THIS_MODULE;`
208
209			`/* 'info' [R] */`
210			`entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,`
211			`S_IRUGO, acpi_device_dir(device));`
212			`if (!entry)`
213			`return -ENODEV;`
214			`else {`
215			`entry->proc_fops = &acpi_button_info_fops;`
216			`entry->data = acpi_driver_data(device);`
217			`entry->owner = THIS_MODULE;`
218			`}`
219
220			`/* show lid state [R] */`
221			`if (button->type == ACPI_BUTTON_TYPE_LID) {`
222			`entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,`
223			`S_IRUGO, acpi_device_dir(device));`
224			`if (!entry)`
225			`return -ENODEV;`
226			`else {`
227			`entry->proc_fops = &acpi_button_state_fops;`
228			`entry->data = acpi_driver_data(device);`
229			`entry->owner = THIS_MODULE;`
230			`}`
231			`}`
232
233			`return 0;`
234			`}`
235
236			`static int acpi_button_remove_fs(struct acpi_device *device)`
237			`{`
238			`struct acpi_button *button = acpi_driver_data(device);`
239
240			`if (acpi_device_dir(device)) {`
241			`if (button->type == ACPI_BUTTON_TYPE_LID)`
242			`remove_proc_entry(ACPI_BUTTON_FILE_STATE,`
243			`acpi_device_dir(device));`
244			`remove_proc_entry(ACPI_BUTTON_FILE_INFO,`
245			`acpi_device_dir(device));`
246
247			`remove_proc_entry(acpi_device_bid(device),`
248			`acpi_device_dir(device)->parent);`
249			`acpi_device_dir(device) = NULL;`
250			`}`
251
252			`return 0;`
253			`}`
254
255			`/* --------------------------------------------------------------------------`
256			`Driver Interface`
257			`-------------------------------------------------------------------------- */`
258			`static int acpi_lid_send_state(struct acpi_button *button)`
259			`{`
260			`unsigned long state;`
261			`acpi_status status;`
262
263			`status = acpi_evaluate_integer(button->device->handle, "_LID", NULL,`
264			`&state);`
265			`if (ACPI_FAILURE(status))`
266			`return -ENODEV;`
267			`/* input layer checks if event is redundant */`
268			`input_report_switch(button->input, SW_LID, !state);`
269			`return 0;`
270			`}`
271
272			`static void acpi_button_notify(acpi_handle handle, u32 event, void *data)`
273			`{`
274			`struct acpi_button *button = data;`
275			`struct input_dev *input;`
276
277			`if (!button \|\| !button->device)`
278			`return;`
279
280			`switch (event) {`
281			`case ACPI_BUTTON_NOTIFY_STATUS:`
282			`input = button->input;`
283			`if (button->type == ACPI_BUTTON_TYPE_LID) {`
284			`acpi_lid_send_state(button);`
285			`} else {`
286			`int keycode = test_bit(KEY_SLEEP, input->keybit) ?`
287			`KEY_SLEEP : KEY_POWER;`
288
289			`input_report_key(input, keycode, 1);`
290			`input_sync(input);`
291			`input_report_key(input, keycode, 0);`
292			`}`
293			`input_sync(input);`
294
295			`acpi_bus_generate_proc_event(button->device, event,`
296			`++button->pushed);`
297			`break;`
298			`default:`
299			`ACPI_DEBUG_PRINT((ACPI_DB_INFO,`
300			`"Unsupported event [0x%x]\n", event));`
301			`break;`
302			`}`
303
304			`return;`
305			`}`
306
307			`static acpi_status acpi_button_notify_fixed(void *data)`
308			`{`
309			`struct acpi_button *button = data;`
310
311			`if (!button)`
312			`return AE_BAD_PARAMETER;`
313
314			`acpi_button_notify(button->device->handle, ACPI_BUTTON_NOTIFY_STATUS, button);`
315
316			`return AE_OK;`
317			`}`
318
319			`static int acpi_button_install_notify_handlers(struct acpi_button *button)`
320			`{`
321			`acpi_status status;`
322
323			`switch (button->type) {`
324			`case ACPI_BUTTON_TYPE_POWERF:`
325			`status =`
326			`acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,`
327			`acpi_button_notify_fixed,`
328			`button);`
329			`break;`
330			`case ACPI_BUTTON_TYPE_SLEEPF:`
331			`status =`
332			`acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,`
333			`acpi_button_notify_fixed,`
334			`button);`
335			`break;`
336			`default:`
337			`status = acpi_install_notify_handler(button->device->handle,`
338			`ACPI_DEVICE_NOTIFY,`
339			`acpi_button_notify,`
340			`button);`
341			`break;`
342			`}`
343
344			`return ACPI_FAILURE(status) ? -ENODEV : 0;`
345			`}`
346
347			`static int acpi_button_resume(struct acpi_device *device)`
348			`{`
349			`struct acpi_button *button;`
350			`if (!device)`
351			`return -EINVAL;`
352			`button = acpi_driver_data(device);`
353			`if (button && button->type == ACPI_BUTTON_TYPE_LID)`
354			`return acpi_lid_send_state(button);`
355			`return 0;`
356			`}`
357
358			`static void acpi_button_remove_notify_handlers(struct acpi_button *button)`
359			`{`
360			`switch (button->type) {`
361			`case ACPI_BUTTON_TYPE_POWERF:`
362			`acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,`
363			`acpi_button_notify_fixed);`
364			`break;`
365			`case ACPI_BUTTON_TYPE_SLEEPF:`
366			`acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,`
367			`acpi_button_notify_fixed);`
368			`break;`
369			`default:`
370			`acpi_remove_notify_handler(button->device->handle,`
371			`ACPI_DEVICE_NOTIFY,`
372			`acpi_button_notify);`
373			`break;`
374			`}`
375			`}`
376
377			`static int acpi_button_add(struct acpi_device *device)`
378			`{`
379			`int error;`
380			`struct acpi_button *button;`
381			`struct input_dev *input;`
382
383			`if (!device)`
384			`return -EINVAL;`
385
386			`button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);`
387			`if (!button)`
388			`return -ENOMEM;`
389
390			`button->device = device;`
391			`acpi_driver_data(device) = button;`
392
393			`button->input = input = input_allocate_device();`
394			`if (!input) {`
395			`error = -ENOMEM;`
396			`goto err_free_button;`
397			`}`
398
399			`/*`
400			`* Determine the button type (via hid), as fixed-feature buttons`
401			`* need to be handled a bit differently than generic-space.`
402			`*/`
403			`if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {`
404			`button->type = ACPI_BUTTON_TYPE_POWER;`
405			`strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER);`
406			`sprintf(acpi_device_class(device), "%s/%s",`
407			`ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);`
408			`} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {`
409			`button->type = ACPI_BUTTON_TYPE_POWERF;`
410			`strcpy(acpi_device_name(device),`
411			`ACPI_BUTTON_DEVICE_NAME_POWERF);`
412			`sprintf(acpi_device_class(device), "%s/%s",`
413			`ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);`
414			`} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {`
415			`button->type = ACPI_BUTTON_TYPE_SLEEP;`
416			`strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP);`
417			`sprintf(acpi_device_class(device), "%s/%s",`
418			`ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);`
419			`} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {`
420			`button->type = ACPI_BUTTON_TYPE_SLEEPF;`
421			`strcpy(acpi_device_name(device),`
422			`ACPI_BUTTON_DEVICE_NAME_SLEEPF);`
423			`sprintf(acpi_device_class(device), "%s/%s",`
424			`ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);`
425			`} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {`
426			`button->type = ACPI_BUTTON_TYPE_LID;`
427			`strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID);`
428			`sprintf(acpi_device_class(device), "%s/%s",`
429			`ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);`
430			`} else {`
431			`printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",`
432			`acpi_device_hid(device));`
433			`error = -ENODEV;`
434			`goto err_free_input;`
435			`}`
436
437			`error = acpi_button_add_fs(device);`
438			`if (error)`
439			`goto err_free_input;`
440
441			`error = acpi_button_install_notify_handlers(button);`
442			`if (error)`
443			`goto err_remove_fs;`
444
445			`snprintf(button->phys, sizeof(button->phys),`
446			`"%s/button/input0", acpi_device_hid(device));`
447
448			`input->name = acpi_device_name(device);`
449			`input->phys = button->phys;`
450			`input->id.bustype = BUS_HOST;`
451			`input->id.product = button->type;`
452
453			`switch (button->type) {`
454			`case ACPI_BUTTON_TYPE_POWER:`
455			`case ACPI_BUTTON_TYPE_POWERF:`
456			`input->evbit[0] = BIT_MASK(EV_KEY);`
457			`set_bit(KEY_POWER, input->keybit);`
458			`break;`
459
460			`case ACPI_BUTTON_TYPE_SLEEP:`
461			`case ACPI_BUTTON_TYPE_SLEEPF:`
462			`input->evbit[0] = BIT_MASK(EV_KEY);`
463			`set_bit(KEY_SLEEP, input->keybit);`
464			`break;`
465
466			`case ACPI_BUTTON_TYPE_LID:`
467			`input->evbit[0] = BIT_MASK(EV_SW);`
468			`set_bit(SW_LID, input->swbit);`
469			`break;`
470			`}`
471
472			`error = input_register_device(input);`
473			`if (error)`
474			`goto err_remove_handlers;`
475			`if (button->type == ACPI_BUTTON_TYPE_LID)`
476			`acpi_lid_send_state(button);`
477
478			`if (device->wakeup.flags.valid) {`
479			`/* Button's GPE is run-wake GPE */`
480			`acpi_set_gpe_type(device->wakeup.gpe_device,`
481			`device->wakeup.gpe_number,`
482			`ACPI_GPE_TYPE_WAKE_RUN);`
483			`acpi_enable_gpe(device->wakeup.gpe_device,`
484			`device->wakeup.gpe_number, ACPI_NOT_ISR);`
485			`device->wakeup.state.enabled = 1;`
486			`}`
487
488			`printk(KERN_INFO PREFIX "%s [%s]\n",`
489			`acpi_device_name(device), acpi_device_bid(device));`
490
491			`return 0;`
492
493			`err_remove_handlers:`
494			`acpi_button_remove_notify_handlers(button);`
495			`err_remove_fs:`
496			`acpi_button_remove_fs(device);`
497			`err_free_input:`
498			`input_free_device(input);`
499			`err_free_button:`
500			`kfree(button);`
501			`return error;`
502			`}`
503
504			`static int acpi_button_remove(struct acpi_device *device, int type)`
505			`{`
506			`struct acpi_button *button;`
507
508			`if (!device \|\| !acpi_driver_data(device))`
509			`return -EINVAL;`
510
511			`button = acpi_driver_data(device);`
512
513			`acpi_button_remove_notify_handlers(button);`
514			`acpi_button_remove_fs(device);`
515			`input_unregister_device(button->input);`
516			`kfree(button);`
517
518			`return 0;`
519			`}`
520
521			`static int __init acpi_button_init(void)`
522			`{`
523			`int result;`
524
525			`acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);`
526			`if (!acpi_button_dir)`
527			`return -ENODEV;`
528			`acpi_button_dir->owner = THIS_MODULE;`
529			`result = acpi_bus_register_driver(&acpi_button_driver);`
530			`if (result < 0) {`
531			`remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);`
532			`return -ENODEV;`
533			`}`
534
535			`return 0;`
536			`}`
537
538			`static void __exit acpi_button_exit(void)`
539			`{`
540			`acpi_bus_unregister_driver(&acpi_button_driver);`
541
542			`if (acpi_power_dir)`
543			`remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);`
544			`if (acpi_sleep_dir)`
545			`remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);`
546			`if (acpi_lid_dir)`
547			`remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);`
548			`remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);`
549			`}`
550
551			`module_init(acpi_button_init);`
552			`module_exit(acpi_button_exit);`