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