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