drivers/acpi/button.c

   1 /*
   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 <acpi/acpi_bus.h>
  33 #include <acpi/acpi_drivers.h>
  34
  35 #define ACPI_BUTTON_COMPONENT           0x00080000
  36 #define ACPI_BUTTON_DRIVER_NAME         "ACPI Button Driver"
  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("acpi_button")
  64
  65     MODULE_AUTHOR("Paul Diefenbaugh");
  66 MODULE_DESCRIPTION(ACPI_BUTTON_DRIVER_NAME);
  67 MODULE_LICENSE("GPL");
  68
  69 static int acpi_button_add(struct acpi_device *device);
  70 static int acpi_button_remove(struct acpi_device *device, int type);
  71 static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
  72 static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
  73
  74 static struct acpi_driver acpi_button_driver = {
  75         .name = ACPI_BUTTON_DRIVER_NAME,
  76         .class = ACPI_BUTTON_CLASS,
  77         .ids = "ACPI_FPB,ACPI_FSB,PNP0C0D,PNP0C0C,PNP0C0E",
  78         .ops = {
  79                 .add = acpi_button_add,
  80                 .remove = acpi_button_remove,
  81                 },
  82 };
  83
  84 struct acpi_button {
  85         acpi_handle handle;
  86         struct acpi_device *device;     /* Fixed button kludge */
  87         u8 type;
  88         unsigned long pushed;
  89 };
  90
  91 static struct file_operations acpi_button_info_fops = {
  92         .open = acpi_button_info_open_fs,
  93         .read = seq_read,
  94         .llseek = seq_lseek,
  95         .release = single_release,
  96 };
  97
  98 static struct file_operations acpi_button_state_fops = {
  99         .open = acpi_button_state_open_fs,
 100         .read = seq_read,
 101         .llseek = seq_lseek,
 102         .release = single_release,
 103 };
 104
 105 /* --------------------------------------------------------------------------
 106                               FS Interface (/proc)
 107    -------------------------------------------------------------------------- */
 108
 109 static struct proc_dir_entry *acpi_button_dir;
 110
 111 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
 112 {
 113         struct acpi_button *button = (struct acpi_button *)seq->private;
 114
 115         ACPI_FUNCTION_TRACE("acpi_button_info_seq_show");
 116
 117         if (!button || !button->device)
 118                 return_VALUE(0);
 119
 120         seq_printf(seq, "type:                    %s\n",
 121                    acpi_device_name(button->device));
 122
 123         return_VALUE(0);
 124 }
 125
 126 static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
 127 {
 128         return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
 129 }
 130
 131 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
 132 {
 133         struct acpi_button *button = (struct acpi_button *)seq->private;
 134         acpi_status status;
 135         unsigned long state;
 136
 137         ACPI_FUNCTION_TRACE("acpi_button_state_seq_show");
 138
 139         if (!button || !button->device)
 140                 return_VALUE(0);
 141
 142         status = acpi_evaluate_integer(button->handle, "_LID", NULL, &state);
 143         if (ACPI_FAILURE(status)) {
 144                 seq_printf(seq, "state:      unsupported\n");
 145         } else {
 146                 seq_printf(seq, "state:      %s\n",
 147                            (state ? "open" : "closed"));
 148         }
 149
 150         return_VALUE(0);
 151 }
 152
 153 static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
 154 {
 155         return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
 156 }
 157
 158 static struct proc_dir_entry *acpi_power_dir;
 159 static struct proc_dir_entry *acpi_sleep_dir;
 160 static struct proc_dir_entry *acpi_lid_dir;
 161
 162 static int acpi_button_add_fs(struct acpi_device *device)
 163 {
 164         struct proc_dir_entry *entry = NULL;
 165         struct acpi_button *button = NULL;
 166
 167         ACPI_FUNCTION_TRACE("acpi_button_add_fs");
 168
 169         if (!device || !acpi_driver_data(device))
 170                 return_VALUE(-EINVAL);
 171
 172         button = acpi_driver_data(device);
 173
 174         switch (button->type) {
 175         case ACPI_BUTTON_TYPE_POWER:
 176         case ACPI_BUTTON_TYPE_POWERF:
 177                 if (!acpi_power_dir)
 178                         acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
 179                                                     acpi_button_dir);
 180                 entry = acpi_power_dir;
 181                 break;
 182         case ACPI_BUTTON_TYPE_SLEEP:
 183         case ACPI_BUTTON_TYPE_SLEEPF:
 184                 if (!acpi_sleep_dir)
 185                         acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
 186                                                     acpi_button_dir);
 187                 entry = acpi_sleep_dir;
 188                 break;
 189         case ACPI_BUTTON_TYPE_LID:
 190                 if (!acpi_lid_dir)
 191                         acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
 192                                                   acpi_button_dir);
 193                 entry = acpi_lid_dir;
 194                 break;
 195         }
 196
 197         if (!entry)
 198                 return_VALUE(-ENODEV);
 199         entry->owner = THIS_MODULE;
 200
 201         acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
 202         if (!acpi_device_dir(device))
 203                 return_VALUE(-ENODEV);
 204         acpi_device_dir(device)->owner = THIS_MODULE;
 205
 206         /* 'info' [R] */
 207         entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
 208                                   S_IRUGO, acpi_device_dir(device));
 209         if (!entry)
 210                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 211                                   "Unable to create '%s' fs entry\n",
 212                                   ACPI_BUTTON_FILE_INFO));
 213         else {
 214                 entry->proc_fops = &acpi_button_info_fops;
 215                 entry->data = acpi_driver_data(device);
 216                 entry->owner = THIS_MODULE;
 217         }
 218
 219         /* show lid state [R] */
 220         if (button->type == ACPI_BUTTON_TYPE_LID) {
 221                 entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
 222                                           S_IRUGO, acpi_device_dir(device));
 223                 if (!entry)
 224                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 225                                           "Unable to create '%s' fs entry\n",
 226                                           ACPI_BUTTON_FILE_INFO));
 227                 else {
 228                         entry->proc_fops = &acpi_button_state_fops;
 229                         entry->data = acpi_driver_data(device);
 230                         entry->owner = THIS_MODULE;
 231                 }
 232         }
 233
 234         return_VALUE(0);
 235 }
 236
 237 static int acpi_button_remove_fs(struct acpi_device *device)
 238 {
 239         struct acpi_button *button = NULL;
 240
 241         ACPI_FUNCTION_TRACE("acpi_button_remove_fs");
 242
 243         button = acpi_driver_data(device);
 244         if (acpi_device_dir(device)) {
 245                 if (button->type == ACPI_BUTTON_TYPE_LID)
 246                         remove_proc_entry(ACPI_BUTTON_FILE_STATE,
 247                                           acpi_device_dir(device));
 248                 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
 249                                   acpi_device_dir(device));
 250
 251                 remove_proc_entry(acpi_device_bid(device),
 252                                   acpi_device_dir(device)->parent);
 253                 acpi_device_dir(device) = NULL;
 254         }
 255
 256         return_VALUE(0);
 257 }
 258
 259 /* --------------------------------------------------------------------------
 260                                 Driver Interface
 261    -------------------------------------------------------------------------- */
 262
 263 static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 264 {
 265         struct acpi_button *button = (struct acpi_button *)data;
 266
 267         ACPI_FUNCTION_TRACE("acpi_button_notify");
 268
 269         if (!button || !button->device)
 270                 return_VOID;
 271
 272         switch (event) {
 273         case ACPI_BUTTON_NOTIFY_STATUS:
 274                 acpi_bus_generate_event(button->device, event,
 275                                         ++button->pushed);
 276                 break;
 277         default:
 278                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 279                                   "Unsupported event [0x%x]\n", event));
 280                 break;
 281         }
 282
 283         return_VOID;
 284 }
 285
 286 static acpi_status acpi_button_notify_fixed(void *data)
 287 {
 288         struct acpi_button *button = (struct acpi_button *)data;
 289
 290         ACPI_FUNCTION_TRACE("acpi_button_notify_fixed");
 291
 292         if (!button)
 293                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 294
 295         acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
 296
 297         return_ACPI_STATUS(AE_OK);
 298 }
 299
 300 static int acpi_button_add(struct acpi_device *device)
 301 {
 302         int result = 0;
 303         acpi_status status = AE_OK;
 304         struct acpi_button *button = NULL;
 305
 306         ACPI_FUNCTION_TRACE("acpi_button_add");
 307
 308         if (!device)
 309                 return_VALUE(-EINVAL);
 310
 311         button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
 312         if (!button)
 313                 return_VALUE(-ENOMEM);
 314         memset(button, 0, sizeof(struct acpi_button));
 315
 316         button->device = device;
 317         button->handle = device->handle;
 318         acpi_driver_data(device) = button;
 319
 320         /*
 321          * Determine the button type (via hid), as fixed-feature buttons
 322          * need to be handled a bit differently than generic-space.
 323          */
 324         if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {
 325                 button->type = ACPI_BUTTON_TYPE_POWER;
 326                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER);
 327                 sprintf(acpi_device_class(device), "%s/%s",
 328                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
 329         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {
 330                 button->type = ACPI_BUTTON_TYPE_POWERF;
 331                 strcpy(acpi_device_name(device),
 332                        ACPI_BUTTON_DEVICE_NAME_POWERF);
 333                 sprintf(acpi_device_class(device), "%s/%s",
 334                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
 335         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
 336                 button->type = ACPI_BUTTON_TYPE_SLEEP;
 337                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP);
 338                 sprintf(acpi_device_class(device), "%s/%s",
 339                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
 340         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {
 341                 button->type = ACPI_BUTTON_TYPE_SLEEPF;
 342                 strcpy(acpi_device_name(device),
 343                        ACPI_BUTTON_DEVICE_NAME_SLEEPF);
 344                 sprintf(acpi_device_class(device), "%s/%s",
 345                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
 346         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
 347                 button->type = ACPI_BUTTON_TYPE_LID;
 348                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID);
 349                 sprintf(acpi_device_class(device), "%s/%s",
 350                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
 351         } else {
 352                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unsupported hid [%s]\n",
 353                                   acpi_device_hid(device)));
 354                 result = -ENODEV;
 355                 goto end;
 356         }
 357
 358         result = acpi_button_add_fs(device);
 359         if (result)
 360                 goto end;
 361
 362         switch (button->type) {
 363         case ACPI_BUTTON_TYPE_POWERF:
 364                 status =
 365                     acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 366                                                      acpi_button_notify_fixed,
 367                                                      button);
 368                 break;
 369         case ACPI_BUTTON_TYPE_SLEEPF:
 370                 status =
 371                     acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 372                                                      acpi_button_notify_fixed,
 373                                                      button);
 374                 break;
 375         default:
 376                 status = acpi_install_notify_handler(button->handle,
 377                                                      ACPI_DEVICE_NOTIFY,
 378                                                      acpi_button_notify,
 379                                                      button);
 380                 break;
 381         }
 382
 383         if (ACPI_FAILURE(status)) {
 384                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 385                                   "Error installing notify handler\n"));
 386                 result = -ENODEV;
 387                 goto end;
 388         }
 389
 390         if (device->wakeup.flags.valid) {
 391                 /* Button's GPE is run-wake GPE */
 392                 acpi_set_gpe_type(device->wakeup.gpe_device,
 393                                   device->wakeup.gpe_number,
 394                                   ACPI_GPE_TYPE_WAKE_RUN);
 395                 acpi_enable_gpe(device->wakeup.gpe_device,
 396                                 device->wakeup.gpe_number, ACPI_NOT_ISR);
 397                 device->wakeup.state.enabled = 1;
 398         }
 399
 400         printk(KERN_INFO PREFIX "%s [%s]\n",
 401                acpi_device_name(device), acpi_device_bid(device));
 402
 403       end:
 404         if (result) {
 405                 acpi_button_remove_fs(device);
 406                 kfree(button);
 407         }
 408
 409         return_VALUE(result);
 410 }
 411
 412 static int acpi_button_remove(struct acpi_device *device, int type)
 413 {
 414         acpi_status status = 0;
 415         struct acpi_button *button = NULL;
 416
 417         ACPI_FUNCTION_TRACE("acpi_button_remove");
 418
 419         if (!device || !acpi_driver_data(device))
 420                 return_VALUE(-EINVAL);
 421
 422         button = acpi_driver_data(device);
 423
 424         /* Unregister for device notifications. */
 425         switch (button->type) {
 426         case ACPI_BUTTON_TYPE_POWERF:
 427                 status =
 428                     acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 429                                                     acpi_button_notify_fixed);
 430                 break;
 431         case ACPI_BUTTON_TYPE_SLEEPF:
 432                 status =
 433                     acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 434                                                     acpi_button_notify_fixed);
 435                 break;
 436         default:
 437                 status = acpi_remove_notify_handler(button->handle,
 438                                                     ACPI_DEVICE_NOTIFY,
 439                                                     acpi_button_notify);
 440                 break;
 441         }
 442
 443         if (ACPI_FAILURE(status))
 444                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 445                                   "Error removing notify handler\n"));
 446
 447         acpi_button_remove_fs(device);
 448
 449         kfree(button);
 450
 451         return_VALUE(0);
 452 }
 453
 454 static int __init acpi_button_init(void)
 455 {
 456         int result = 0;
 457
 458         ACPI_FUNCTION_TRACE("acpi_button_init");
 459
 460         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
 461         if (!acpi_button_dir)
 462                 return_VALUE(-ENODEV);
 463         acpi_button_dir->owner = THIS_MODULE;
 464         result = acpi_bus_register_driver(&acpi_button_driver);
 465         if (result < 0) {
 466                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
 467                 return_VALUE(-ENODEV);
 468         }
 469
 470         return_VALUE(0);
 471 }
 472
 473 static void __exit acpi_button_exit(void)
 474 {
 475         ACPI_FUNCTION_TRACE("acpi_button_exit");
 476
 477         acpi_bus_unregister_driver(&acpi_button_driver);
 478
 479         if (acpi_power_dir)
 480                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
 481         if (acpi_sleep_dir)
 482                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
 483         if (acpi_lid_dir)
 484                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
 485         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
 486
 487         return_VOID;
 488 }
 489
 490 module_init(acpi_button_init);
 491 module_exit(acpi_button_exit);