linux/drivers/acpi/button.c
<<
>>
Prefs
   1/*
   2 *  button.c - ACPI Button Driver
   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 <linux/slab.h>
  34#include <acpi/acpi_bus.h>
  35#include <acpi/acpi_drivers.h>
  36#include <acpi/button.h>
  37
  38#define PREFIX "ACPI: "
  39
  40#define ACPI_BUTTON_CLASS               "button"
  41#define ACPI_BUTTON_FILE_INFO           "info"
  42#define ACPI_BUTTON_FILE_STATE          "state"
  43#define ACPI_BUTTON_TYPE_UNKNOWN        0x00
  44#define ACPI_BUTTON_NOTIFY_STATUS       0x80
  45
  46#define ACPI_BUTTON_SUBCLASS_POWER      "power"
  47#define ACPI_BUTTON_HID_POWER           "PNP0C0C"
  48#define ACPI_BUTTON_DEVICE_NAME_POWER   "Power Button"
  49#define ACPI_BUTTON_TYPE_POWER          0x01
  50
  51#define ACPI_BUTTON_SUBCLASS_SLEEP      "sleep"
  52#define ACPI_BUTTON_HID_SLEEP           "PNP0C0E"
  53#define ACPI_BUTTON_DEVICE_NAME_SLEEP   "Sleep Button"
  54#define ACPI_BUTTON_TYPE_SLEEP          0x03
  55
  56#define ACPI_BUTTON_SUBCLASS_LID        "lid"
  57#define ACPI_BUTTON_HID_LID             "PNP0C0D"
  58#define ACPI_BUTTON_DEVICE_NAME_LID     "Lid Switch"
  59#define ACPI_BUTTON_TYPE_LID            0x05
  60
  61#define _COMPONENT              ACPI_BUTTON_COMPONENT
  62ACPI_MODULE_NAME("button");
  63
  64MODULE_AUTHOR("Paul Diefenbaugh");
  65MODULE_DESCRIPTION("ACPI Button Driver");
  66MODULE_LICENSE("GPL");
  67
  68static const struct acpi_device_id button_device_ids[] = {
  69        {ACPI_BUTTON_HID_LID,    0},
  70        {ACPI_BUTTON_HID_SLEEP,  0},
  71        {ACPI_BUTTON_HID_SLEEPF, 0},
  72        {ACPI_BUTTON_HID_POWER,  0},
  73        {ACPI_BUTTON_HID_POWERF, 0},
  74        {"", 0},
  75};
  76MODULE_DEVICE_TABLE(acpi, button_device_ids);
  77
  78static int acpi_button_add(struct acpi_device *device);
  79static int acpi_button_remove(struct acpi_device *device);
  80static void acpi_button_notify(struct acpi_device *device, u32 event);
  81
  82#ifdef CONFIG_PM_SLEEP
  83static int acpi_button_resume(struct device *dev);
  84#endif
  85static SIMPLE_DEV_PM_OPS(acpi_button_pm, NULL, acpi_button_resume);
  86
  87static struct acpi_driver acpi_button_driver = {
  88        .name = "button",
  89        .class = ACPI_BUTTON_CLASS,
  90        .ids = button_device_ids,
  91        .ops = {
  92                .add = acpi_button_add,
  93                .remove = acpi_button_remove,
  94                .notify = acpi_button_notify,
  95        },
  96        .drv.pm = &acpi_button_pm,
  97};
  98
  99struct acpi_button {
 100        unsigned int type;
 101        struct input_dev *input;
 102        char phys[32];                  /* for input device */
 103        unsigned long pushed;
 104        bool wakeup_enabled;
 105};
 106
 107static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
 108static struct acpi_device *lid_device;
 109
 110/* --------------------------------------------------------------------------
 111                              FS Interface (/proc)
 112   -------------------------------------------------------------------------- */
 113
 114static struct proc_dir_entry *acpi_button_dir;
 115static struct proc_dir_entry *acpi_lid_dir;
 116
 117static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
 118{
 119        struct acpi_device *device = seq->private;
 120        acpi_status status;
 121        unsigned long long state;
 122
 123        status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
 124        seq_printf(seq, "state:      %s\n",
 125                   ACPI_FAILURE(status) ? "unsupported" :
 126                        (state ? "open" : "closed"));
 127        return 0;
 128}
 129
 130static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
 131{
 132        return single_open(file, acpi_button_state_seq_show, PDE_DATA(inode));
 133}
 134
 135static const struct file_operations acpi_button_state_fops = {
 136        .owner = THIS_MODULE,
 137        .open = acpi_button_state_open_fs,
 138        .read = seq_read,
 139        .llseek = seq_lseek,
 140        .release = single_release,
 141};
 142
 143static int acpi_button_add_fs(struct acpi_device *device)
 144{
 145        struct acpi_button *button = acpi_driver_data(device);
 146        struct proc_dir_entry *entry = NULL;
 147        int ret = 0;
 148
 149        /* procfs I/F for ACPI lid device only */
 150        if (button->type != ACPI_BUTTON_TYPE_LID)
 151                return 0;
 152
 153        if (acpi_button_dir || acpi_lid_dir) {
 154                printk(KERN_ERR PREFIX "More than one Lid device found!\n");
 155                return -EEXIST;
 156        }
 157
 158        /* create /proc/acpi/button */
 159        acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
 160        if (!acpi_button_dir)
 161                return -ENODEV;
 162
 163        /* create /proc/acpi/button/lid */
 164        acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
 165        if (!acpi_lid_dir) {
 166                ret = -ENODEV;
 167                goto remove_button_dir;
 168        }
 169
 170        /* create /proc/acpi/button/lid/LID/ */
 171        acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir);
 172        if (!acpi_device_dir(device)) {
 173                ret = -ENODEV;
 174                goto remove_lid_dir;
 175        }
 176
 177        /* create /proc/acpi/button/lid/LID/state */
 178        entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
 179                                 S_IRUGO, acpi_device_dir(device),
 180                                 &acpi_button_state_fops, device);
 181        if (!entry) {
 182                ret = -ENODEV;
 183                goto remove_dev_dir;
 184        }
 185
 186done:
 187        return ret;
 188
 189remove_dev_dir:
 190        remove_proc_entry(acpi_device_bid(device),
 191                          acpi_lid_dir);
 192        acpi_device_dir(device) = NULL;
 193remove_lid_dir:
 194        remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
 195remove_button_dir:
 196        remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
 197        goto done;
 198}
 199
 200static int acpi_button_remove_fs(struct acpi_device *device)
 201{
 202        struct acpi_button *button = acpi_driver_data(device);
 203
 204        if (button->type != ACPI_BUTTON_TYPE_LID)
 205                return 0;
 206
 207        remove_proc_entry(ACPI_BUTTON_FILE_STATE,
 208                          acpi_device_dir(device));
 209        remove_proc_entry(acpi_device_bid(device),
 210                          acpi_lid_dir);
 211        acpi_device_dir(device) = NULL;
 212        remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
 213        remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
 214
 215        return 0;
 216}
 217
 218/* --------------------------------------------------------------------------
 219                                Driver Interface
 220   -------------------------------------------------------------------------- */
 221int acpi_lid_notifier_register(struct notifier_block *nb)
 222{
 223        return blocking_notifier_chain_register(&acpi_lid_notifier, nb);
 224}
 225EXPORT_SYMBOL(acpi_lid_notifier_register);
 226
 227int acpi_lid_notifier_unregister(struct notifier_block *nb)
 228{
 229        return blocking_notifier_chain_unregister(&acpi_lid_notifier, nb);
 230}
 231EXPORT_SYMBOL(acpi_lid_notifier_unregister);
 232
 233int acpi_lid_open(void)
 234{
 235        acpi_status status;
 236        unsigned long long state;
 237
 238        if (!lid_device)
 239                return -ENODEV;
 240
 241        status = acpi_evaluate_integer(lid_device->handle, "_LID", NULL,
 242                                       &state);
 243        if (ACPI_FAILURE(status))
 244                return -ENODEV;
 245
 246        return !!state;
 247}
 248EXPORT_SYMBOL(acpi_lid_open);
 249
 250static int acpi_lid_send_state(struct acpi_device *device)
 251{
 252        struct acpi_button *button = acpi_driver_data(device);
 253        unsigned long long state;
 254        acpi_status status;
 255        int ret;
 256
 257        status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
 258        if (ACPI_FAILURE(status))
 259                return -ENODEV;
 260
 261        /* input layer checks if event is redundant */
 262        input_report_switch(button->input, SW_LID, !state);
 263        input_sync(button->input);
 264
 265        if (state)
 266                pm_wakeup_event(&device->dev, 0);
 267
 268        ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
 269        if (ret == NOTIFY_DONE)
 270                ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
 271                                                   device);
 272        if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
 273                /*
 274                 * It is also regarded as success if the notifier_chain
 275                 * returns NOTIFY_OK or NOTIFY_DONE.
 276                 */
 277                ret = 0;
 278        }
 279        return ret;
 280}
 281
 282static void acpi_button_notify(struct acpi_device *device, u32 event)
 283{
 284        struct acpi_button *button = acpi_driver_data(device);
 285        struct input_dev *input;
 286
 287        switch (event) {
 288        case ACPI_FIXED_HARDWARE_EVENT:
 289                event = ACPI_BUTTON_NOTIFY_STATUS;
 290                /* fall through */
 291        case ACPI_BUTTON_NOTIFY_STATUS:
 292                input = button->input;
 293                if (button->type == ACPI_BUTTON_TYPE_LID) {
 294                        acpi_lid_send_state(device);
 295                } else {
 296                        int keycode = test_bit(KEY_SLEEP, input->keybit) ?
 297                                                KEY_SLEEP : KEY_POWER;
 298
 299                        input_report_key(input, keycode, 1);
 300                        input_sync(input);
 301                        input_report_key(input, keycode, 0);
 302                        input_sync(input);
 303
 304                        pm_wakeup_event(&device->dev, 0);
 305                }
 306                break;
 307        default:
 308                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 309                                  "Unsupported event [0x%x]\n", event));
 310                break;
 311        }
 312}
 313
 314#ifdef CONFIG_PM_SLEEP
 315static int acpi_button_resume(struct device *dev)
 316{
 317        struct acpi_device *device = to_acpi_device(dev);
 318        struct acpi_button *button = acpi_driver_data(device);
 319
 320        if (button->type == ACPI_BUTTON_TYPE_LID)
 321                return acpi_lid_send_state(device);
 322        return 0;
 323}
 324#endif
 325
 326static int acpi_button_add(struct acpi_device *device)
 327{
 328        struct acpi_button *button;
 329        struct input_dev *input;
 330        const char *hid = acpi_device_hid(device);
 331        char *name, *class;
 332        int error;
 333
 334        button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
 335        if (!button)
 336                return -ENOMEM;
 337
 338        device->driver_data = button;
 339
 340        button->input = input = input_allocate_device();
 341        if (!input) {
 342                error = -ENOMEM;
 343                goto err_free_button;
 344        }
 345
 346        name = acpi_device_name(device);
 347        class = acpi_device_class(device);
 348
 349        if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
 350            !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
 351                button->type = ACPI_BUTTON_TYPE_POWER;
 352                strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
 353                sprintf(class, "%s/%s",
 354                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
 355        } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
 356                   !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
 357                button->type = ACPI_BUTTON_TYPE_SLEEP;
 358                strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
 359                sprintf(class, "%s/%s",
 360                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
 361        } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
 362                button->type = ACPI_BUTTON_TYPE_LID;
 363                strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
 364                sprintf(class, "%s/%s",
 365                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
 366        } else {
 367                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
 368                error = -ENODEV;
 369                goto err_free_input;
 370        }
 371
 372        error = acpi_button_add_fs(device);
 373        if (error)
 374                goto err_free_input;
 375
 376        snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
 377
 378        input->name = name;
 379        input->phys = button->phys;
 380        input->id.bustype = BUS_HOST;
 381        input->id.product = button->type;
 382        input->dev.parent = &device->dev;
 383
 384        switch (button->type) {
 385        case ACPI_BUTTON_TYPE_POWER:
 386                input->evbit[0] = BIT_MASK(EV_KEY);
 387                set_bit(KEY_POWER, input->keybit);
 388                break;
 389
 390        case ACPI_BUTTON_TYPE_SLEEP:
 391                input->evbit[0] = BIT_MASK(EV_KEY);
 392                set_bit(KEY_SLEEP, input->keybit);
 393                break;
 394
 395        case ACPI_BUTTON_TYPE_LID:
 396                input->evbit[0] = BIT_MASK(EV_SW);
 397                set_bit(SW_LID, input->swbit);
 398                break;
 399        }
 400
 401        error = input_register_device(input);
 402        if (error)
 403                goto err_remove_fs;
 404        if (button->type == ACPI_BUTTON_TYPE_LID) {
 405                acpi_lid_send_state(device);
 406                /*
 407                 * This assumes there's only one lid device, or if there are
 408                 * more we only care about the last one...
 409                 */
 410                lid_device = device;
 411        }
 412
 413        if (device->wakeup.flags.valid) {
 414                /* Button's GPE is run-wake GPE */
 415                acpi_enable_gpe(device->wakeup.gpe_device,
 416                                device->wakeup.gpe_number);
 417                if (!device_may_wakeup(&device->dev)) {
 418                        device_set_wakeup_enable(&device->dev, true);
 419                        button->wakeup_enabled = true;
 420                }
 421        }
 422
 423        printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
 424        return 0;
 425
 426 err_remove_fs:
 427        acpi_button_remove_fs(device);
 428 err_free_input:
 429        input_free_device(input);
 430 err_free_button:
 431        kfree(button);
 432        return error;
 433}
 434
 435static int acpi_button_remove(struct acpi_device *device)
 436{
 437        struct acpi_button *button = acpi_driver_data(device);
 438
 439        if (device->wakeup.flags.valid) {
 440                acpi_disable_gpe(device->wakeup.gpe_device,
 441                                device->wakeup.gpe_number);
 442                if (button->wakeup_enabled)
 443                        device_set_wakeup_enable(&device->dev, false);
 444        }
 445
 446        acpi_button_remove_fs(device);
 447        input_unregister_device(button->input);
 448        kfree(button);
 449        return 0;
 450}
 451
 452module_acpi_driver(acpi_button_driver);
 453
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.