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
 307                acpi_bus_generate_proc_event(device, event, ++button->pushed);
 308                break;
 309        default:
 310                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 311                                  "Unsupported event [0x%x]\n", event));
 312                break;
 313        }
 314}
 315
 316#ifdef CONFIG_PM_SLEEP
 317static int acpi_button_resume(struct device *dev)
 318{
 319        struct acpi_device *device = to_acpi_device(dev);
 320        struct acpi_button *button = acpi_driver_data(device);
 321
 322        if (button->type == ACPI_BUTTON_TYPE_LID)
 323                return acpi_lid_send_state(device);
 324        return 0;
 325}
 326#endif
 327
 328static int acpi_button_add(struct acpi_device *device)
 329{
 330        struct acpi_button *button;
 331        struct input_dev *input;
 332        const char *hid = acpi_device_hid(device);
 333        char *name, *class;
 334        int error;
 335
 336        button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
 337        if (!button)
 338                return -ENOMEM;
 339
 340        device->driver_data = button;
 341
 342        button->input = input = input_allocate_device();
 343        if (!input) {
 344                error = -ENOMEM;
 345                goto err_free_button;
 346        }
 347
 348        name = acpi_device_name(device);
 349        class = acpi_device_class(device);
 350
 351        if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
 352            !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
 353                button->type = ACPI_BUTTON_TYPE_POWER;
 354                strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
 355                sprintf(class, "%s/%s",
 356                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
 357        } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
 358                   !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
 359                button->type = ACPI_BUTTON_TYPE_SLEEP;
 360                strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
 361                sprintf(class, "%s/%s",
 362                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
 363        } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
 364                button->type = ACPI_BUTTON_TYPE_LID;
 365                strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
 366                sprintf(class, "%s/%s",
 367                        ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
 368        } else {
 369                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
 370                error = -ENODEV;
 371                goto err_free_input;
 372        }
 373
 374        error = acpi_button_add_fs(device);
 375        if (error)
 376                goto err_free_input;
 377
 378        snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
 379
 380        input->name = name;
 381        input->phys = button->phys;
 382        input->id.bustype = BUS_HOST;
 383        input->id.product = button->type;
 384        input->dev.parent = &device->dev;
 385
 386        switch (button->type) {
 387        case ACPI_BUTTON_TYPE_POWER:
 388                input->evbit[0] = BIT_MASK(EV_KEY);
 389                set_bit(KEY_POWER, input->keybit);
 390                break;
 391
 392        case ACPI_BUTTON_TYPE_SLEEP:
 393                input->evbit[0] = BIT_MASK(EV_KEY);
 394                set_bit(KEY_SLEEP, input->keybit);
 395                break;
 396
 397        case ACPI_BUTTON_TYPE_LID:
 398                input->evbit[0] = BIT_MASK(EV_SW);
 399                set_bit(SW_LID, input->swbit);
 400                break;
 401        }
 402
 403        error = input_register_device(input);
 404        if (error)
 405                goto err_remove_fs;
 406        if (button->type == ACPI_BUTTON_TYPE_LID) {
 407                acpi_lid_send_state(device);
 408                /*
 409                 * This assumes there's only one lid device, or if there are
 410                 * more we only care about the last one...
 411                 */
 412                lid_device = device;
 413        }
 414
 415        if (device->wakeup.flags.valid) {
 416                /* Button's GPE is run-wake GPE */
 417                acpi_enable_gpe(device->wakeup.gpe_device,
 418                                device->wakeup.gpe_number);
 419                if (!device_may_wakeup(&device->dev)) {
 420                        device_set_wakeup_enable(&device->dev, true);
 421                        button->wakeup_enabled = true;
 422                }
 423        }
 424
 425        printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
 426        return 0;
 427
 428 err_remove_fs:
 429        acpi_button_remove_fs(device);
 430 err_free_input:
 431        input_free_device(input);
 432 err_free_button:
 433        kfree(button);
 434        return error;
 435}
 436
 437static int acpi_button_remove(struct acpi_device *device)
 438{
 439        struct acpi_button *button = acpi_driver_data(device);
 440
 441        if (device->wakeup.flags.valid) {
 442                acpi_disable_gpe(device->wakeup.gpe_device,
 443                                device->wakeup.gpe_number);
 444                if (button->wakeup_enabled)
 445                        device_set_wakeup_enable(&device->dev, false);
 446        }
 447
 448        acpi_button_remove_fs(device);
 449        input_unregister_device(button->input);
 450        kfree(button);
 451        return 0;
 452}
 453
 454module_acpi_driver(acpi_button_driver);
 455
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.